js-core-1.5.0 - fix critical bug in v1.4.0

Author: elisherer

javascript/json-transform-core/package-lock.json

@@ -1,7 +1,7 @@
 {
   "name": "@nlighten/json-transform-core",
   "description": "Core types and utilities for handling JSON transformers",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "main": "dist/json-transform-core.js",
   "umd:main": "dist/json-transform-core.umd.js",
   "module": "dist/json-transform-core.module.js",
@@ -40,10 +40,10 @@
   },
   "homepage": "https://github.com/nlighten-oss/json-transform#readme",
   "peerDependencies": {
-    "@nlighten/json-schema-utils": "^1.0.2"
+    "@nlighten/json-schema-utils": "^1.0.3"
   },
   "devDependencies": {
-    "@nlighten/json-schema-utils": "^1.0.2",
+    "@nlighten/json-schema-utils": "^1.0.3",
     "microbundle": "^0.15.1",
     "prettier": "3.1.1",
     "typescript": "^5.3.3",

javascript/json-transform-core/package.json

@@ -3,17 +3,17 @@ import { ContextVariablesSchemas } from "./functions/context";
 import { FunctionDescriptor } from "./functions/types";
 
 export class ParseContext {
-  paths?: Record<string, TypeSchema> = {};
-  additionalContext?: Record<string, TypeSchema>;
-  knownVariables: Set<string>;
+  private readonly paths?: Record<string, TypeSchema>;
+  private readonly additionalContext?: Record<string, TypeSchema>;
+  private knownVariables: Set<string>;
 
   constructor(
     paths?: Record<string, TypeSchema>,
     additionalContext?: Record<string, TypeSchema>,
     previousPaths?: string[],
   ) {
     this.paths = paths;
-    this.additionalContext = additionalContext ?? ContextVariablesSchemas;
+    this.additionalContext = additionalContext;
     this.knownVariables = new Set();
     if (paths) {
       for (const path in paths) {
@@ -35,14 +35,46 @@ export class ParseContext {
     }
   }
 
+  hasPaths() {
+    return Boolean(this.paths);
+  }
+
+  hasPath(path: string) {
+    return typeof this.paths?.[path] !== "undefined";
+  }
+
+  /**
+   * If you are about to change the result, use this and not 'resolve()'
+   * @param path
+   */
+  getPath(path: string) {
+    return this.paths?.[path];
+  }
+
+  setPath(path: string, type: TypeSchema) {
+    if (!this.paths) return;
+    this.paths[path] = type;
+    const v = path.split(/[.[]/, 1)[0];
+    this.knownVariables.add(v);
+  }
+
+  removePaths(paths: string[], variableToRemove?: string) {
+    for (const path of paths) {
+      delete this.paths?.[path];
+    }
+    if (variableToRemove) {
+      this.knownVariables.delete(variableToRemove);
+    }
+  }
+
   resolve(key: string) {
-    return this.additionalContext?.[key] ?? this.paths?.[key];
+    return ContextVariablesSchemas[key] ?? this.additionalContext?.[key] ?? this.paths?.[key];
   }
 
-  isJsonPathReference(path: any): boolean {
-    if (typeof path !== "string") return false;
+  isReferencingKnownVariable(path: any): boolean {
+    if (typeof path !== "string" || path.startsWith("$$")) return false;
     const v = path.split(/[.[]/, 1)[0];
-    return path === v || path.startsWith(v + ".") || path.startsWith(v + "[");
+    return this.knownVariables.has(v) && (path === v || path.startsWith(v + ".") || path.startsWith(v + "["));
   }
 }
 

javascript/json-transform-core/src/ParseContext.ts

@@ -94,7 +94,7 @@ class FunctionsParser {
     this.handleClientFunction = handler;
   }
 
-  get(name: string) {
+  get(name: string, args?: Record<string, any>) {
     return this.clientFunctions?.[name] ?? embeddedDefinitions[name as EmbeddedTransformerFunction];
   }
 
@@ -134,14 +134,7 @@ class FunctionsParser {
     if (func.overrides || callback) {
       const argsWithoutParenthesis = m[3];
       const args = parseArgs(func, argsWithoutParenthesis);
-      if (func.overrides) {
-        for (const override of func.overrides) {
-          if (override.if.every(c => args[c.argument]?.toString().toUpperCase() === c.equals)) {
-            func = override.then; // replace func instance based on args
-            break;
-          }
-        }
-      }
+      func = getOverriddenFunction(func, args);
       if (callback) {
         const inlineFunctionValue = m[5];
         callback(funcName, func, inlineFunctionValue, args);
@@ -160,15 +153,7 @@ class FunctionsParser {
           const match = this.matchObject(value, true);
           if (match) return match;
         }
-        let func = this.get(funcName);
-        if (func.overrides) {
-          for (const override of func.overrides) {
-            if (override.if.every(c => data[c.argument]?.toString().toUpperCase() === c.equals)) {
-              func = override.then; // replace func instance based on args
-              break;
-            }
-          }
-        }
+        const func = getOverriddenFunction(this.get(funcName), data);
         return {
           name: funcName,
           func,
@@ -214,3 +199,17 @@ export const parseArgs = (func: FunctionDescriptor, args?: string) => {
         {} as Record<string, any>, // we can't really infer type, and strings are the only ones that matter anyway
       );
 };
+
+export const getOverriddenFunction = (func: FunctionDescriptor, args?: Record<string, any>) => {
+  if (!func.overrides || !args) return func;
+  for (const override of func.overrides) {
+    if (
+      override.if.every(
+        c => (args[c.argument] ?? override.then.defaultValues?.[c.argument])?.toString().toUpperCase() === c.equals,
+      )
+    ) {
+      return override.then; // replace func instance based on args
+    }
+  }
+  return func;
+};

javascript/json-transform-core/src/functions/functionsParser.ts

@@ -1,5 +1,18 @@
-import { JSONSchemaUtils, TypeSchema } from "@nlighten/json-schema-utils";
-import { FunctionDescriptor } from "./types";
+import { JSONSchemaUtils } from "@nlighten/json-schema-utils";
+import { Argument, FunctionDescriptor } from "./types";
+
+const getDefaultValues = (args?: Argument[]) => {
+  const defaultValues: Record<string, any> = {};
+  if (Array.isArray(args)) {
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      if (arg.default !== undefined) {
+        defaultValues[arg.name] = arg.default;
+      }
+    }
+  }
+  return defaultValues;
+};
 
 function parseSchemas<T extends string>(
   functions: Record<T, FunctionDescriptor>,
@@ -10,16 +23,23 @@ function parseSchemas<T extends string>(
     if (func.outputSchema) {
       func.parsedOutputSchema = JSONSchemaUtils.parse(func.outputSchema);
     }
+    func.defaultValues = getDefaultValues(func.arguments);
+
     if (custom) {
       func.custom = true;
     }
     if (Array.isArray(func.overrides)) {
       for (let i = 0; i < func.overrides.length; i++) {
         const schemaOverride = func.overrides[i].then.outputSchema;
         func.overrides[i] = {
-          ...func,
-          overrides: null,
-          parsedOutputSchema: schemaOverride && JSONSchemaUtils.parse(schemaOverride),
+          if: func.overrides[i].if,
+          then: {
+            ...func,
+            ...func.overrides[i].then,
+            overrides: undefined,
+            parsedOutputSchema: schemaOverride && JSONSchemaUtils.parse(schemaOverride),
+            defaultValues: getDefaultValues(func.overrides[i].then.arguments),
+          },
         };
       }
     }

javascript/json-transform-core/src/functions/parseSchemas.ts

@@ -86,7 +86,7 @@ export enum EmbeddedTransformerFunction {
 export const EmbeddedTransformerFunctions = Object.keys(EmbeddedTransformerFunction) as EmbeddedTransformerFunction[];
 
 export type Argument = {
-  name?: string;
+  name: string;
   type: string;
   description?: string;
   enum?: string[];
@@ -108,7 +108,7 @@ export type ConditionalOverrides = {
 
 export type FunctionDescriptor = {
   aliasTo?: string;
-  inputSchema?: Argument;
+  inputSchema?: Omit<Argument, "name">;
   arguments?: Argument[];
   description: string;
   notes?: string;
@@ -123,4 +123,5 @@ export type FunctionDescriptor = {
   custom?: boolean;
   /** (when outputSchema) Parsed in advance to get all possible paths */
   parsedOutputSchema?: ParsedSchema;
+  defaultValues?: Record<string, any>;
 };

javascript/json-transform-core/src/functions/types.ts

@@ -4,6 +4,7 @@ export {
   getFunctionObjectSignature,
   functionsParser,
   parseArgs,
+  getOverriddenFunction,
 } from "./functions/functionsParser";
 export {
   type Argument,