ondc-code-generator 0.2.9 → 0.3.0

package/dist/generator/config-compiler.d.ts

@@ -19,7 +19,8 @@ export declare class ConfigCompiler {
     constructor(language: SupportedLanguages);
     initialize: (buildYaml: string, generatorConfig?: Partial<CodeGeneratorConfig>) => Promise<void>;
     performValidations: (valConfig: ValidationConfig) => Promise<void>;
-    generateCode: (valConfig: ValidationConfig, codeName?: string) => Promise<void>;
+    withMinimalValidations: (valConfig: ValidationConfig) => Promise<void>;
+    generateCode: (valConfig: ValidationConfig, codeName?: string, minimal?: boolean) => Promise<void>;
     generateL0Schema: () => Promise<void>;
     generateValidPaths: () => Promise<Record<string, string[]>>;
 }

package/dist/generator/config-compiler.js

@@ -46,13 +46,29 @@ export class ConfigCompiler {
                 throw new Error("Validation failed");
             }
         };
-        this.generateCode = async (valConfig, codeName = "L1-Validations") => {
+        this.withMinimalValidations = async (valConfig) => {
+            try {
+                await new ConfigValidator("", valConfig, {}, [], {
+                    skipJsonPathTest: true,
+                }).validate();
+            }
+            catch (e) {
+                logger.error(e);
+                throw new Error("validation failed");
+            }
+        };
+        this.generateCode = async (valConfig, codeName = "L1-Validations", minimal = false) => {
             valConfig = JSON.parse(JSON.stringify(valConfig));
             if (this.generatorConfig?.duplicateVariablesInChildren) {
                 console.log("Duplicating variables");
                 valConfig = duplicateVariablesInChildren(valConfig);
             }
-            await this.performValidations(valConfig);
+            if (minimal) {
+                await this.withMinimalValidations(valConfig);
+            }
+            else {
+                await this.performValidations(valConfig);
+            }
             // Generate code based on the language
             switch (this.language) {
                 case SupportedLanguages.Typescript:

package/dist/generator/generators/typescript/templates/json-path-utils.mustache

@@ -1,17 +1,35 @@
 import jsonpath from "jsonpath";
+
+function isPrimitive(val: any): boolean {
+	return val === null || ['string', 'number', 'boolean'].includes(typeof val);
+}
+
+function isListOfStringsOrNull(arr: any[]): boolean {
+	return Array.isArray(arr) && arr.every((item) => typeof item === 'string' || item === null);
+}
+
 function getJsonPath(payload: any, path: string) {
 	let output = jsonpath.query(payload, path);
+
+	if (!Array.isArray(output)) {
+		throw new Error(`Expected output to be an array, got ${typeof output}`);
+	}
+
+	// Check if all items are primitive
+	const allPrimitives = output.every(isPrimitive);
+
+	if (!allPrimitives) {
+		throw new Error(`Expected output to be a list of primitives, but found complex types.`);
+	}
+
+	// Handle nulls
 	if (isListOfStringsOrNull(output)) {
 		output = output.map((o) => (o === null ? "null" : o));
 	}
+
 	return output.length === 0 ? [] : output;
 }
-function isListOfStringsOrNull(variable: any): boolean {
-	return (
-		Array.isArray(variable) &&
-		variable.every((item) => item === null || typeof item === "string")
-	);
-}
+
 export default {
 	getJsonPath,
 };

package/dist/generator/validators/abstract-validator.d.ts

@@ -14,4 +14,5 @@ export interface TestsValidatorDependencies {
     stringJsonPaths: string[];
     errorDefinitions: ErrorDefinition[];
     externalVariables: string[];
+    skipJsonPathTest?: boolean;
 }

package/dist/generator/validators/config-validator.d.ts

@@ -6,6 +6,11 @@ export declare class ConfigValidator implements IValidator {
     config: ValidationConfig;
     stringJsonPaths: Record<string, string[]>;
     errorDefinitions: ErrorDefinition[];
-    constructor(validationPath: string, config: ValidationConfig, stringJsonPaths: Record<string, string[]>, errorDefinitions: ErrorDefinition[]);
+    validatorSettings: {
+        skipJsonPathTest: boolean;
+    };
+    constructor(validationPath: string, config: ValidationConfig, stringJsonPaths: Record<string, string[]>, errorDefinitions: ErrorDefinition[], settings?: {
+        skipJsonPathTest: boolean;
+    });
     validate: () => Promise<void>;
 }

package/dist/generator/validators/config-validator.js

@@ -3,7 +3,7 @@ import { getExternalVariables } from "../../utils/general-utils/validation-utils
 import { SessionDataValidator } from "./session-data-config/session-data-validator.js";
 import { TestsValidator } from "./tests-config/test-list-validator.js";
 export class ConfigValidator {
-    constructor(validationPath, config, stringJsonPaths, errorDefinitions) {
+    constructor(validationPath, config, stringJsonPaths, errorDefinitions, settings) {
         this.validate = async () => {
             if (!this.config[ConfigSyntax.Tests])
                 throw new Error(`Tests not found in config`);
@@ -28,5 +28,13 @@ export class ConfigValidator {
         this.config = config;
         this.stringJsonPaths = stringJsonPaths;
         this.errorDefinitions = errorDefinitions;
+        if (settings) {
+            this.validatorSettings = settings;
+        }
+        else {
+            this.validatorSettings = {
+                skipJsonPathTest: false,
+            };
+        }
     }
 }

package/dist/generator/validators/tests-config/sub-validations.d.ts

@@ -20,7 +20,8 @@ export declare class ErrorCodeValidator extends TestObjectValidator {
 export declare class VariableValidator extends TestObjectValidator {
     possibleJsonPaths: string[];
     externalVariables: string[];
-    constructor(testObject: TestObject, path: string, posibleJsonPaths: string[], externalVariables: string[]);
+    skipJsonPathTest: boolean;
+    constructor(testObject: TestObject, path: string, posibleJsonPaths: string[], externalVariables: string[], skipJsonPathTest?: boolean);
     validate: () => Promise<void>;
     validateKey(key: string): void;
     validateExternalData(path: string, definedExternalValues: string[]): void;

package/dist/generator/validators/tests-config/sub-validations.js

@@ -89,8 +89,9 @@ export class ErrorCodeValidator extends TestObjectValidator {
     }
 }
 export class VariableValidator extends TestObjectValidator {
-    constructor(testObject, path, posibleJsonPaths, externalVariables) {
+    constructor(testObject, path, posibleJsonPaths, externalVariables, skipJsonPathTest = false) {
         super(testObject, path);
+        this.skipJsonPathTest = false;
         this.validate = async () => {
             for (const key in this.targetObject) {
                 if (Object.values(TestObjectSyntax).includes(key)) {
@@ -119,7 +120,8 @@ export class VariableValidator extends TestObjectValidator {
                         path = `${scope}.${pathWithoutDollar}`;
                     }
                     const replaced = replaceBracketsWithAsteriskNested(path);
-                    if (!this.possibleJsonPaths.includes(replaced)) {
+                    if (!this.possibleJsonPaths.includes(replaced) &&
+                        !this.skipJsonPathTest) {
                         throw new Error(`Variable: ${key} should be a jsonPath that returns a array of strings or the path don't exist in the schema, at ${this.validationPath} found original ${path} replaces: ${replaced}`);
                     }
                 }
@@ -127,6 +129,7 @@ export class VariableValidator extends TestObjectValidator {
         };
         this.externalVariables = externalVariables;
         this.possibleJsonPaths = posibleJsonPaths;
+        this.skipJsonPathTest = skipJsonPathTest;
     }
     validateKey(key) {
         if (nodeReservedKeywords.has(key)) {

package/dist/generator/validators/tests-config/test-validator.js

@@ -13,7 +13,7 @@ export class CompleteTestObjectValidator extends TestObjectValidator {
             if (this.targetObject[TestObjectSyntax.ErrorCode]) {
                 await new ErrorCodeValidator(this.targetObject, this.validationPath, this.dependencies.errorDefinitions).validate();
             }
-            await new VariableValidator(this.targetObject, this.validationPath, this.dependencies.stringJsonPaths, this.dependencies.externalVariables).validate();
+            await new VariableValidator(this.targetObject, this.validationPath, this.dependencies.stringJsonPaths, this.dependencies.externalVariables, this.dependencies.skipJsonPathTest).validate();
             if (this.targetObject[TestObjectSyntax.Continue]) {
                 await new ContinueValidator(this.targetObject, this.validationPath).validate();
             }

package/dist/index.js

@@ -16,7 +16,7 @@ export { ConfigCompiler };
 // 	const buildYaml = readFileSync(buildPath, "utf-8");
 // 	const valConfig = JSON.parse(readFileSync(valConfigPath, "utf-8"));
 // 	await compiler.initialize(buildYaml);
-// 	await compiler.generateCode(valConfig, "L1-validations");
+// await compiler.generateCode(valConfig, "L1-validations");
 // };
 // (async () => {
 // 	await main();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ondc-code-generator",
-	"version": "0.2.9",
+	"version": "0.3.0",
 	"description": "generate code from build.yaml ",
 	"main": "dist/index.js",
 	"type": "module",