java-0.9.0 - align initialization method, multiple fixes and add json-smart

Author: elisherer

README.md

@@ -23,6 +23,8 @@
     }
 ```
 
+- See available adapters [here](https://github.com/nlighten-oss/json-transform/tree/main/java/json-transform/src/main/java/co/nlighten/jsontransform/adapters)
+
 Then in the code where you want to transform JSON objects:
 
 ```java
@@ -32,4 +34,14 @@ Then in the code where you want to transform JSON objects:
     // 'input' - The input of the transformer (referred as '$')
     // 'additionalContext' - (optional) Map of additional inputs to refer during transformation 
     Object transformed = transformer.transform(input, additionalContext);
+```
+
+### JavaScript
+
+```js
+    // 'definition' is the spec of the transformer    
+    const transformer = new JsonTransformer(definition);
+    // 'input' - The input of the transformer (referred as '$')
+    // 'additionalContext' - (optional) Map of additional inputs to refer during transformation 
+    const result = await transformer.transform(input, additionalContext);
 ```

java/json-transform/build.gradle

@@ -9,14 +9,15 @@ plugins {
 }
 
 group 'co.nlighten'
-version = '0.8.0'
+version = '0.9.0'
 
 ext {
     gsonVersion = "2.10.1"
     jsonVersion = '20240303'
     jsonPathVersion = "2.9.0"
     jmhVersion = "1.36"
     jacksonBindVersion = "2.17.1"
+    jsonSmartVersion = "2.5.2"
     snakeYamlVersion = "2.7"
     coNlightenShortUuidVersion = "0.1.1"
     slf4jVersion = "2.0.11"
@@ -39,6 +40,7 @@ dependencies {
     /** JSON **/
     compileOnly "com.google.code.gson:gson:${gsonVersion}"
     compileOnly "com.fasterxml.jackson.core:jackson-databind:${jacksonBindVersion}"
+    compileOnly "net.minidev:json-smart:${jsonSmartVersion}"
     implementation "org.json:json:${jsonVersion}" // for XML conversion
     implementation "com.jayway.jsonpath:json-path:${jsonPathVersion}"
 
@@ -52,6 +54,7 @@ dependencies {
     testImplementation 'org.junit.jupiter:junit-jupiter'
     testImplementation "com.google.code.gson:gson:${gsonVersion}"
     testImplementation "com.fasterxml.jackson.core:jackson-databind:${jacksonBindVersion}"
+    testImplementation "net.minidev:json-smart:${jsonSmartVersion}"
 }
 
 jar { archiveClassifier = '' }

java/json-transform/src/main/java/co/nlighten/jsontransform/DebuggableTransformerFunctions.java

@@ -10,8 +10,7 @@ public class DebuggableTransformerFunctions extends TransformerFunctions{
 
     public record TransformerDebugInfo(Object result) {}
 
-    public DebuggableTransformerFunctions(JsonAdapter<?, ?, ?> adapter) {
-        super(adapter);
+    public DebuggableTransformerFunctions() {
         debugResults = new HashMap<>();
     }
 
@@ -30,12 +29,12 @@ private TransformerFunctions.FunctionMatchResult<Object> auditAndReturn(String p
         return matchResult;
     }
 
-    public TransformerFunctions.FunctionMatchResult<Object> matchObject(String path, Object definition, ParameterResolver resolver, JsonTransformerFunction transformer) {
-        return auditAndReturn(path, super.matchObject(path, definition, resolver, transformer));
+    public TransformerFunctions.FunctionMatchResult<Object> matchObject(JsonAdapter<?,?,?> adapter, String path, Object definition, ParameterResolver resolver, JsonTransformerFunction transformer) {
+        return auditAndReturn(path, super.matchObject(adapter, path, definition, resolver, transformer));
     }
 
-    public TransformerFunctions.FunctionMatchResult<Object> matchInline(String path, String value, ParameterResolver resolver, JsonTransformerFunction transformer) {
-        return auditAndReturn(path, super.matchInline(path, value, resolver, transformer));
+    public TransformerFunctions.FunctionMatchResult<Object> matchInline(JsonAdapter<?,?,?> adapter, String path, String value, ParameterResolver resolver, JsonTransformerFunction transformer) {
+        return auditAndReturn(path, super.matchInline(adapter, path, value, resolver, transformer));
     }
 
     public Map<String, TransformerDebugInfo> getDebugResults() {

java/json-transform/src/main/java/co/nlighten/jsontransform/JsonTransformer.java

@@ -16,6 +16,7 @@ public class JsonTransformer implements Transformer {
     private final JsonAdapter<?, ?, ?> adapter;
     protected final Object definition;
 
+    private static final TransformerFunctionsAdapter DEFAULT_TRANSFORMER_FUNCTIONS = new TransformerFunctions();
     private final JsonTransformerFunction JSON_TRANSFORMER;
     private final TransformerFunctionsAdapter transformerFunctions;
 
@@ -24,7 +25,7 @@ public JsonTransformer(
             final JsonAdapter<?, ?, ?> adapter,
             final TransformerFunctionsAdapter functionsAdapter) {
         this.adapter = adapter != null ? adapter : JsonTransformerConfiguration.get().getAdapter();
-        this.transformerFunctions = functionsAdapter != null ? functionsAdapter : JsonTransformerConfiguration.get().getFunctionsAdapter();
+        this.transformerFunctions = functionsAdapter != null ? functionsAdapter : DEFAULT_TRANSFORMER_FUNCTIONS;
         this.definition = this.adapter.wrap(definition);
         this.JSON_TRANSFORMER = this::fromJsonElement;
     }
@@ -42,9 +43,13 @@ public JsonTransformer(
     }
 
     public JsonTransformer(final Object definition) {
-        this(definition, JsonTransformerConfiguration.get().getFunctionsAdapter());
+        this(definition, DEFAULT_TRANSFORMER_FUNCTIONS);
     }
 
+    public Object transform(Object payload, Map<String, Object> additionalContext, boolean allowReturningStreams, boolean unwrap) {
+        var result = transform(payload, additionalContext, allowReturningStreams);
+        return unwrap ? adapter.unwrap(result) : result;
+    }
 
     public Object transform(Object payload, Map<String, Object> additionalContext, boolean allowReturningStreams) {
         if (definition == null) {
@@ -60,7 +65,7 @@ protected Object fromJsonPrimitive(String path, Object definition, co.nlighten.j
         try {
             var val = adapter.getAsString(definition);
             // test for inline function (e.g. $$function:...)
-            var match = transformerFunctions.matchInline(path, val, resolver, JSON_TRANSFORMER);
+            var match = transformerFunctions.matchInline(adapter, path, val, resolver, JSON_TRANSFORMER);
             if (match != null) {
                 var matchResult = match.result();
                 if (matchResult instanceof JsonElementStreamer streamer) {
@@ -79,7 +84,7 @@ protected Object fromJsonPrimitive(String path, Object definition, co.nlighten.j
 
 
     protected Object fromJsonObject(String path, Object definition, co.nlighten.jsontransform.ParameterResolver resolver, boolean allowReturningStreams) {
-        var match = transformerFunctions.matchObject(path, definition, resolver, JSON_TRANSFORMER);
+        var match = transformerFunctions.matchObject(adapter, path, definition, resolver, JSON_TRANSFORMER);
         if (match != null) {
             var res = match.result();
             return res instanceof JsonElementStreamer s

java/json-transform/src/main/java/co/nlighten/jsontransform/JsonTransformerConfiguration.java

@@ -35,12 +35,4 @@ public JsonTransformerConfiguration(JsonAdapter<?, ?, ?> adapter) {
     public JsonAdapter<?, ?, ?> getAdapter() {
         return this.adapter;
     }
-
-    public DebuggableTransformerFunctions getDebuggableAdapter() {
-        return new DebuggableTransformerFunctions(this.adapter);
-    }
-
-    public TransformerFunctionsAdapter getFunctionsAdapter() {
-        return new TransformerFunctions(this.adapter);
-    }
 }

java/json-transform/src/main/java/co/nlighten/jsontransform/TransformerFunctions.java

@@ -24,9 +24,7 @@ public class TransformerFunctions implements TransformerFunctionsAdapter {
     public static final String ESCAPE_DOLLAR = "\\$";
     public static final String ESCAPE_HASH = "\\#";
 
-
     private static Map<String, TransformerFunction> functions = Map.of();
-    private final JsonAdapter<?, ?, ?> jsonAdapter;
 
     static {
         registerFunctions(
@@ -113,10 +111,6 @@ public class TransformerFunctions implements TransformerFunctionsAdapter {
         );
     }
 
-    public TransformerFunctions(JsonAdapter<?, ?, ?> adapter) {
-        this.jsonAdapter = adapter;
-    }
-
     @SafeVarargs
     public synchronized static void registerFunctions(Map.Entry<String, TransformerFunction>... moreFunctions) {
         var additions = Arrays.stream(moreFunctions).filter(x -> {
@@ -138,19 +132,19 @@ public synchronized static void registerFunctions(Map.Entry<String, TransformerF
     /**
      * Checks the context for a registered object function and returns the result if matched
      */
-    public FunctionMatchResult<Object> matchObject(String path, Object definition, co.nlighten.jsontransform.ParameterResolver resolver, JsonTransformerFunction transformer) {
+    public FunctionMatchResult<Object> matchObject(JsonAdapter<?,?,?> adapter, String path, Object definition, co.nlighten.jsontransform.ParameterResolver resolver, JsonTransformerFunction transformer) {
         if (definition == null) {
             return null;
         }
         // look for an object function
         // (precedence is all internal functions sorted alphabetically first, then client added ones second, by registration order)
         for (String key : functions.keySet()) {
-            if (jsonAdapter.has(definition, FUNCTION_KEY_PREFIX + key)) {
+            if (adapter.has(definition, FUNCTION_KEY_PREFIX + key)) {
                 var func = functions.get(key);
                 var context = new ObjectFunctionContext(
                         path,
                         definition,
-                        jsonAdapter,
+                        adapter,
                         FUNCTION_KEY_PREFIX + key,
                         func, resolver, transformer);
                 var resolvedPath = path + "." + FUNCTION_KEY_PREFIX + key;
@@ -166,7 +160,7 @@ public FunctionMatchResult<Object> matchObject(String path, Object definition, c
         return null;
     }
 
-    private InlineFunctionContext tryParseInlineFunction(String path, String value, co.nlighten.jsontransform.ParameterResolver resolver,
+    private InlineFunctionContext tryParseInlineFunction(JsonAdapter<?,?,?> adapter, String path, String value, co.nlighten.jsontransform.ParameterResolver resolver,
                                                                      JsonTransformerFunction transformer) {
         var matcher = inlineFunctionRegex.matcher(value);
         if (matcher.find()) {
@@ -182,7 +176,7 @@ private InlineFunctionContext tryParseInlineFunction(String path, String value,
                         var arg = argMatcher.group(1);
                         var trimmed = argMatcher.group(1).trim();
                         if (trimmed.startsWith(QUOTE_APOS) && trimmed.endsWith(QUOTE_APOS) && trimmed.length() > 1) {
-                            arg = jsonAdapter.getAsString(jsonAdapter.parse(trimmed));
+                            arg = adapter.getAsString(adapter.parse(trimmed));
                             //otherwise, take the whole argument as-is
                         }
                         args.add(arg);
@@ -198,7 +192,7 @@ private InlineFunctionContext tryParseInlineFunction(String path, String value,
                 return new InlineFunctionContext(
                         path + "/" + FUNCTION_KEY_PREFIX + functionKey,
                         input, args,
-                        jsonAdapter,
+                        adapter,
                         functionKey,
                         function,
                         resolver, transformer);
@@ -207,9 +201,9 @@ private InlineFunctionContext tryParseInlineFunction(String path, String value,
         return null;
     }
 
-    public FunctionMatchResult<Object> matchInline(String path, String value, ParameterResolver resolver, JsonTransformerFunction transformer) {
+    public FunctionMatchResult<Object> matchInline(JsonAdapter<?,?,?> adapter, String path, String value, ParameterResolver resolver, JsonTransformerFunction transformer) {
         if (value == null) return null;
-        var context = tryParseInlineFunction(path, value, resolver, transformer);
+        var context = tryParseInlineFunction(adapter, path, value, resolver, transformer);
         if (context == null) {
             return null;
         }

java/json-transform/src/main/java/co/nlighten/jsontransform/TransformerFunctionsAdapter.java

@@ -1,7 +1,9 @@
 package co.nlighten.jsontransform;
 
+import co.nlighten.jsontransform.adapters.JsonAdapter;
+
 public interface TransformerFunctionsAdapter {
-    TransformerFunctions.FunctionMatchResult<Object> matchInline(String path, String value, ParameterResolver resolver, JsonTransformerFunction transformer);
+    TransformerFunctions.FunctionMatchResult<Object> matchInline(JsonAdapter<?,?,?> adapter, String path, String value, ParameterResolver resolver, JsonTransformerFunction transformer);
 
-    TransformerFunctions.FunctionMatchResult<Object> matchObject(String path, Object definition, ParameterResolver resolver, JsonTransformerFunction transformer);
+    TransformerFunctions.FunctionMatchResult<Object> matchObject(JsonAdapter<?,?,?> adapter, String path, Object definition, ParameterResolver resolver, JsonTransformerFunction transformer);
 }

java/json-transform/src/main/java/co/nlighten/jsontransform/adapters/JsonAdapter.java

@@ -2,8 +2,7 @@
 
 import co.nlighten.jsontransform.ParameterResolver;
 import com.google.gson.JsonPrimitive;
-import com.jayway.jsonpath.DocumentContext;
-import com.jayway.jsonpath.JsonPath;
+import com.jayway.jsonpath.*;
 
 import java.lang.reflect.Array;
 import java.math.BigDecimal;
@@ -31,15 +30,19 @@ public abstract class JsonAdapter<JE, JA extends Iterable<JE>, JO extends JE> {
     private final JsonObjectAdapter<JE, JA, JO> jObject;
     private final JsonArrayAdapter<JE, JA, JO> jArray;
 
+    protected final ParseContext jsonPath;
+    protected final com.jayway.jsonpath.Configuration jsonPathConfiguration;
+
     public JsonAdapter(
             Supplier<JsonObjectAdapter<JE, JA, JO>> objectAdapterSupplier,
-            Supplier<JsonArrayAdapter<JE, JA, JO>> arrayAdapterSupplier) {
+            Supplier<JsonArrayAdapter<JE, JA, JO>> arrayAdapterSupplier,
+            com.jayway.jsonpath.Configuration jsonPathConfiguration) {
         this.jObject = objectAdapterSupplier.get();
         this.jArray = arrayAdapterSupplier.get();
+        this.jsonPathConfiguration = jsonPathConfiguration;
+        this.jsonPath = JsonPath.using(jsonPathConfiguration);
     }
 
-    public abstract String getName();
-
     /**
      * Checks if the given object is a Json element
      * @param value the object to check
@@ -399,23 +402,56 @@ public boolean isEmpty(Object value) {
         return false;
     }
 
-    /**
-     * Setup JsonPath using specific provider for it
-     */
-    public abstract void setupJsonPath();
-
     /**
      * Returns a document context for the given payload (Using JsonPath)
      * @param payload the payload to create a document context for
      * @return a document context
      */
-    public DocumentContext getDocumentContext(Object payload) {
-        setupJsonPath();
+    public DocumentContext getDocumentContext(Object payload, Iterable<String> options) {
         Object document = payload;
         if (!is(payload)) {
             document = wrap(payload);
         }
-        return JsonPath.parse(document);
+        var parseContext = jsonPath;
+        if (options != null) {
+            var opts = new HashSet<Option>();
+            for (var option : options) {
+                opts.add(Option.valueOf(option));
+            }
+            parseContext = JsonPath.using(new Configuration.ConfigurationBuilder()
+                    .jsonProvider(jsonPathConfiguration.jsonProvider())
+                    .mappingProvider(jsonPathConfiguration.mappingProvider())
+                    .options(opts)
+                    .build());
+        }
+        return parseContext.parse(document);
+    }
+
+    public DocumentContext getDocumentContext(Object payload) {
+        return getDocumentContext(payload, null);
+    }
+
+    public boolean nodesComparable() {
+        return true;
+    }
+
+    /**
+     * Checks if the given objects are equal based on Json implementation
+     * @param value the first object
+     * @param other the second object
+     * @return true if the objects are equal
+     */
+    public boolean areEqual(Object value, Object other) {
+        return Objects.equals(value, other);
+    }
+
+    /**
+     * Returns the hash code of the given object
+     * @param value the object to get the hash code for
+     * @return the hash code of the object
+     */
+    public int hashCode(Object value) {
+        return value == null ? 0 : value.hashCode();
     }
 
     /**

java/json-transform/src/main/java/co/nlighten/jsontransform/adapters/JsonAdapterHelpers.java

@@ -0,0 +1,12 @@
+package co.nlighten.jsontransform.adapters;
+
+public class JsonAdapterHelpers {
+    private static final String BACKSLASH = "\\";
+    public static String singleQuotedStringToDoubleQuoted(String value) {
+        return "\"" +
+                value.substring(1, value.length() - 1)
+                        .replace("\"", BACKSLASH + "\"")
+                        .replace(BACKSLASH + "'", "'") +
+                "\"";
+    }
+}