Support expression for primitive type in json schema

runtime/engine/src/main/java/io/aklivity/zilla/runtime/engine/config/EngineConfigReader.java

@@ -19,6 +19,7 @@
 import static java.util.Collections.singletonMap;
 import static org.agrona.LangUtil.rethrowUnchecked;
 
+import java.io.IOException;
 import java.io.InputStream;
 import java.io.Reader;
 import java.io.StringReader;
@@ -29,10 +30,14 @@
 import java.util.List;
 import java.util.function.Consumer;
 
+import jakarta.json.Json;
 import jakarta.json.JsonArray;
+import jakarta.json.JsonArrayBuilder;
 import jakarta.json.JsonObject;
+import jakarta.json.JsonObjectBuilder;
 import jakarta.json.JsonPatch;
 import jakarta.json.JsonReader;
+import jakarta.json.JsonValue;
 import jakarta.json.bind.Jsonb;
 import jakarta.json.bind.JsonbBuilder;
 import jakarta.json.bind.JsonbConfig;
@@ -46,21 +51,25 @@
 import org.leadpony.justify.api.ProblemHandler;
 
 import io.aklivity.zilla.runtime.engine.Engine;
+import io.aklivity.zilla.runtime.engine.expression.ExpressionResolver;
 import io.aklivity.zilla.runtime.engine.internal.config.NamespaceAdapter;
 import io.aklivity.zilla.runtime.engine.internal.config.schema.UniquePropertyKeysSchema;
 
 public final class EngineConfigReader
 {
     private final ConfigAdapterContext context;
+    private final ExpressionResolver expressions;
     private final Collection<URL> schemaTypes;
     private final Consumer<String> logger;
 
     public EngineConfigReader(
         ConfigAdapterContext context,
+        ExpressionResolver expressions,
         Collection<URL> schemaTypes,
         Consumer<String> logger)
     {
         this.context = context;
+        this.expressions = expressions;
         this.schemaTypes = schemaTypes;
         this.logger = logger;
     }
@@ -91,18 +100,13 @@ public EngineConfig read(
                 schemaObject = schemaPatch.apply(schemaObject);
             }
 
-            if (logger != null)
+            if (!validateAnnotatedSchema(schemaObject, schemaProvider, errors, configText))
             {
-                final StringWriter out = new StringWriter();
-                schemaProvider.createGeneratorFactory(singletonMap(PRETTY_PRINTING, true))
-                    .createGenerator(out)
-                    .write(schemaObject)
-                    .close();
-
-                final String schemaText = out.getBuffer().toString();
-                logger.accept(schemaText);
+                break read;
             }
 
+            configText = expressions.resolve(configText);
+
             JsonParser schemaParser = schemaProvider.createParserFactory(null)
                 .createParser(new StringReader(schemaObject.toString()));
 
@@ -139,11 +143,11 @@ public EngineConfig read(
             }
 
             JsonbConfig config = new JsonbConfig()
-                    .withAdapters(new NamespaceAdapter(context));
+                .withAdapters(new NamespaceAdapter(context));
             Jsonb jsonb = JsonbBuilder.newBuilder()
-                    .withProvider(provider)
-                    .withConfig(config)
-                    .build();
+                .withProvider(provider)
+                .withConfig(config)
+                .build();
 
             Reader reader = new StringReader(readable);
             EngineConfigBuilder<EngineConfig> builder = EngineConfig.builder();
@@ -174,4 +178,158 @@ public EngineConfig read(
 
         return engine;
     }
+
+    private boolean validateAnnotatedSchema(
+        JsonObject schemaObject,
+        JsonProvider schemaProvider,
+        List<Exception> errors,
+        String configText)
+    {
+        boolean valid = false;
+
+        validate:
+        try
+        {
+            final JsonObject annotatedSchemaObject = (JsonObject) annotateJsonObject(schemaObject);
+
+            if (logger != null)
+            {
+                final StringWriter out = new StringWriter();
+                schemaProvider.createGeneratorFactory(singletonMap(PRETTY_PRINTING, true))
+                    .createGenerator(out)
+                    .write(annotatedSchemaObject)
+                    .close();
+
+                final String schemaText = out.getBuffer().toString();
+                logger.accept(schemaText);
+            }
+
+            final JsonParser schemaParser = schemaProvider.createParserFactory(null)
+                .createParser(new StringReader(schemaObject.toString()));
+
+            final JsonValidationService service = JsonValidationService.newInstance();
+            ProblemHandler handler = service.createProblemPrinter(msg -> errors.add(new ConfigException(msg)));
+            final JsonSchemaReader validator = service.createSchemaReader(schemaParser);
+            final JsonSchema schema = new UniquePropertyKeysSchema(validator.read());
+
+            String readable = configText.stripTrailing();
+
+            IntArrayList configsAt = new IntArrayList();
+            for (int configAt = 0; configAt < readable.length(); )
+            {
+                configsAt.addInt(configAt);
+
+                Reader reader = new StringReader(readable);
+                reader.skip(configAt);
+
+                try (JsonParser parser = service.createParser(reader, schema, handler))
+                {
+                    while (parser.hasNext())
+                    {
+                        parser.next();
+                    }
+
+                    configAt += (int) parser.getLocation().getStreamOffset();
+                }
+
+                if (!errors.isEmpty())
+                {
+                    break validate;
+                }
+            }
+
+            valid = true;
+        }
+        catch (IOException ex)
+        {
+            errors.add(ex);
+        }
+
+        return valid;
+
+    }
+
+    private JsonValue annotateJsonObject(
+        JsonObject jsonObject)
+    {
+        JsonObjectBuilder builder = Json.createObjectBuilder();
+
+        jsonObject.forEach((key, value) ->
+        {
+            if ("expression".equals(key))
+            {
+                builder.add(key, value);
+            }
+            else if (value.getValueType() == JsonValue.ValueType.OBJECT)
+            {
+                builder.add(key, annotateJsonObject(value.asJsonObject()));
+            }
+            else if (value.getValueType() == JsonValue.ValueType.ARRAY)
+            {
+                builder.add(key, annotateJsonArray(value.asJsonArray()));
+            }
+            else if (key.equals("type") &&
+                isPrimitiveType(value.toString().replaceAll("\"", "")))
+            {
+                JsonValue pattern = jsonObject.get("pattern");
+                builder.add(key, value);
+                builder.add("anyOf", createOneOfTypes(value.toString().replaceAll("\"", ""), pattern));
+            }
+            else if (!"pattern".equals(key))
+            {
+                builder.add(key, value);
+            }
+        });
+
+        return builder.build();
+    }
+
+    private JsonValue annotateJsonArray(
+        JsonArray jsonArray)
+    {
+        JsonArrayBuilder arrayBuilder = Json.createArrayBuilder();
+
+        jsonArray.forEach(item ->
+        {
+            if (item.getValueType() == JsonValue.ValueType.OBJECT)
+            {
+                arrayBuilder.add(annotateJsonObject(item.asJsonObject()));
+            }
+            else
+            {
+                arrayBuilder.add(item);
+            }
+        });
+
+        return arrayBuilder.build();
+    }
+
+    private boolean isPrimitiveType(
+        String type)
+    {
+        return "string".equals(type) ||
+            "integer".equals(type) ||
+            "boolean".equals(type) ||
+            "number".equals(type);
+    }
+
+    private JsonArray createOneOfTypes(
+        String originalType,
+        JsonValue pattern)
+    {
+        JsonArrayBuilder oneOfArrayBuilder = Json.createArrayBuilder();
+        JsonObjectBuilder objectBuilder = Json.createObjectBuilder();
+        objectBuilder.add("type", originalType);
+        if (pattern != null)
+        {
+            objectBuilder.add("pattern", pattern);
+        }
+        oneOfArrayBuilder.add(objectBuilder);
+
+        oneOfArrayBuilder.add(Json.createObjectBuilder()
+            .add("$ref", "#/$defs/expression")
+        );
+
+        return oneOfArrayBuilder.build();
+    }
 }

runtime/engine/src/main/java/io/aklivity/zilla/runtime/engine/internal/registry/EngineManager.java

@@ -171,17 +171,13 @@ private EngineConfig parse(
 
         logger.accept(configText);
 
-        if (config.configResolveExpressions())
-        {
-            configText = expressions.resolve(configText);
-        }
-
         try
         {
             final Function<String, String> namespaceReadURL = l -> readURL.apply(configURL, l);
 
             EngineConfigReader reader = new EngineConfigReader(
                 new NamespaceConfigAdapterContext(namespaceReadURL),
+                expressions,
                 schemaTypes,
                 config.verboseSchema() ? logger : null);
 

specs/engine.spec/src/main/scripts/io/aklivity/zilla/specs/engine/schema/engine.schema.json

@@ -105,6 +105,10 @@
 
     "$defs":
     {
+        "expression":{
+            "type": "string",
+            "pattern": "\\$\\{\\{\\s*([^\\s\\}]*)\\.([^\\s\\}]*)\\s*\\}\\}"
+        },
         "vault":
         {
             "type": "object",