ondc-code-generator 0.2.9 → 0.3.1

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, {}, [], {
+                    minimal: 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[];
+    minimal: 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: {
+        minimal: boolean;
+    };
+    constructor(validationPath: string, config: ValidationConfig, stringJsonPaths: Record<string, string[]>, errorDefinitions: ErrorDefinition[], settings?: {
+        minimal: 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`);
@@ -20,6 +20,7 @@ export class ConfigValidator {
                     stringJsonPaths: this.stringJsonPaths[api],
                     errorDefinitions: this.errorDefinitions,
                     externalVariables: externalVariables,
+                    minimal: this.validatorSettings.minimal,
                 };
                 await new TestsValidator(testList, path, dependencies).validate();
             }
@@ -28,5 +29,13 @@ export class ConfigValidator {
         this.config = config;
         this.stringJsonPaths = stringJsonPaths;
         this.errorDefinitions = errorDefinitions;
+        if (settings) {
+            this.validatorSettings = settings;
+        }
+        else {
+            this.validatorSettings = {
+                minimal: false,
+            };
+        }
     }
 }

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

@@ -9,18 +9,21 @@ export declare class NameValidator extends TestObjectValidator {
 }
 export declare class ScopeValidator extends TestObjectValidator {
     impossiblePaths: string[];
-    constructor(testObject: TestObject, path: string, impossiblePaths: string[]);
+    minimal: boolean;
+    constructor(testObject: TestObject, path: string, impossiblePaths: string[], minimal?: boolean);
     validate: () => Promise<void>;
 }
 export declare class ErrorCodeValidator extends TestObjectValidator {
     possibleErrorCodes: ErrorDefinition[];
-    constructor(testObject: TestObject, path: string, possibleErrorCodes: ErrorDefinition[]);
+    minimal: boolean;
+    constructor(testObject: TestObject, path: string, possibleErrorCodes: ErrorDefinition[], minimal?: boolean);
     validate: () => Promise<void>;
 }
 export declare class VariableValidator extends TestObjectValidator {
     possibleJsonPaths: string[];
     externalVariables: string[];
-    constructor(testObject: TestObject, path: string, posibleJsonPaths: string[], externalVariables: string[]);
+    minimal: boolean;
+    constructor(testObject: TestObject, path: string, posibleJsonPaths: string[], externalVariables: string[], minimal?: boolean);
     validate: () => Promise<void>;
     validateKey(key: string): void;
     validateExternalData(path: string, definedExternalValues: string[]): void;

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

@@ -41,8 +41,9 @@ export class NameValidator extends TestObjectValidator {
     }
 }
 export class ScopeValidator extends TestObjectValidator {
-    constructor(testObject, path, impossiblePaths) {
+    constructor(testObject, path, impossiblePaths, minimal = false) {
         super(testObject, path);
+        this.minimal = false;
         this.validate = async () => {
             const path = this.targetObject[TestObjectSyntax.Scope];
             if (typeof path !== "string") {
@@ -54,16 +55,20 @@ export class ScopeValidator extends TestObjectValidator {
             if (!path.startsWith(`$.`)) {
                 throw new Error(`${TestObjectSyntax.Scope} json path should start with $. at ${this.validationPath}`);
             }
+            if (this.minimal)
+                return;
             if (this.impossiblePaths.includes(replaceBracketsWithAsteriskNested(path))) {
                 throw new Error(`${TestObjectSyntax.Scope} can't be a path that returns a array of string it must be a json path which returns a array of objects at path ${this.validationPath}`);
             }
         };
         this.impossiblePaths = impossiblePaths;
+        this.minimal = minimal;
     }
 }
 export class ErrorCodeValidator extends TestObjectValidator {
-    constructor(testObject, path, possibleErrorCodes) {
+    constructor(testObject, path, possibleErrorCodes, minimal = false) {
         super(testObject, path);
+        this.minimal = false;
         this.validate = async () => {
             if (!this.targetObject[TestObjectSyntax.ErrorCode]) {
                 return;
@@ -74,6 +79,8 @@ export class ErrorCodeValidator extends TestObjectValidator {
             if (typeof this.targetObject[TestObjectSyntax.ErrorCode] !== "number") {
                 throw new Error(`${TestObjectSyntax.ErrorCode} should be a number at path ${this.validationPath}`);
             }
+            if (this.minimal)
+                return;
             const errorCode = this.targetObject[TestObjectSyntax.ErrorCode];
             if (!this.possibleErrorCodes.some((code) => code.code === errorCode)) {
                 throw new Error(`${TestObjectSyntax.ErrorCode} don't exist in error codes at path ${this.validationPath}`);
@@ -86,11 +93,13 @@ export class ErrorCodeValidator extends TestObjectValidator {
             }
         };
         this.possibleErrorCodes = possibleErrorCodes;
+        this.minimal = minimal;
     }
 }
 export class VariableValidator extends TestObjectValidator {
-    constructor(testObject, path, posibleJsonPaths, externalVariables) {
+    constructor(testObject, path, posibleJsonPaths, externalVariables, minimal = false) {
         super(testObject, path);
+        this.minimal = false;
         this.validate = async () => {
             for (const key in this.targetObject) {
                 if (Object.values(TestObjectSyntax).includes(key)) {
@@ -119,6 +128,8 @@ export class VariableValidator extends TestObjectValidator {
                         path = `${scope}.${pathWithoutDollar}`;
                     }
                     const replaced = replaceBracketsWithAsteriskNested(path);
+                    if (this.minimal)
+                        return;
                     if (!this.possibleJsonPaths.includes(replaced)) {
                         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 +138,7 @@ export class VariableValidator extends TestObjectValidator {
         };
         this.externalVariables = externalVariables;
         this.possibleJsonPaths = posibleJsonPaths;
+        this.minimal = minimal;
     }
     validateKey(key) {
         if (nodeReservedKeywords.has(key)) {

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

@@ -8,12 +8,12 @@ export class CompleteTestObjectValidator extends TestObjectValidator {
             await new RequiredFieldsValidator(this.targetObject, this.validationPath).validate();
             await new NameValidator(this.targetObject, this.validationPath).validate();
             if (this.targetObject[TestObjectSyntax.Scope]) {
-                await new ScopeValidator(this.targetObject, this.validationPath, this.dependencies.stringJsonPaths).validate();
+                await new ScopeValidator(this.targetObject, this.validationPath, this.dependencies.stringJsonPaths, this.dependencies.minimal).validate();
             }
             if (this.targetObject[TestObjectSyntax.ErrorCode]) {
-                await new ErrorCodeValidator(this.targetObject, this.validationPath, this.dependencies.errorDefinitions).validate();
+                await new ErrorCodeValidator(this.targetObject, this.validationPath, this.dependencies.errorDefinitions, this.dependencies.minimal).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.minimal).validate();
             if (this.targetObject[TestObjectSyntax.Continue]) {
                 await new ContinueValidator(this.targetObject, this.validationPath).validate();
             }

package/dist/index.js

@@ -1,23 +1,20 @@
 import { ConfigCompiler } from "./generator/config-compiler.js";
 export { ConfigCompiler };
-// import { readFileSync } from "fs";
-// import path from "path";
-// import { fileURLToPath } from "url";
-// const __filename = fileURLToPath(import.meta.url);
-// const __dirname = path.dirname(__filename);
-// import { SupportedLanguages } from "./types/compiler-types.js";
-// const main = async () => {
-// 	const compiler = new ConfigCompiler(SupportedLanguages.Typescript);
-// 	const buildPath = path.resolve(__dirname, "../samples/build.yaml");
-// 	const valConfigPath = path.resolve(
-// 		__dirname,
-// 		"../samples/validation-config.json"
-// 	);
-// 	const buildYaml = readFileSync(buildPath, "utf-8");
-// 	const valConfig = JSON.parse(readFileSync(valConfigPath, "utf-8"));
-// 	await compiler.initialize(buildYaml);
-// 	await compiler.generateCode(valConfig, "L1-validations");
-// };
-// (async () => {
-// 	await main();
-// })();
+import { readFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+import { SupportedLanguages } from "./types/compiler-types.js";
+const main = async () => {
+    const compiler = new ConfigCompiler(SupportedLanguages.Typescript);
+    const buildPath = path.resolve(__dirname, "../samples/build.yaml");
+    const valConfigPath = path.resolve(__dirname, "../samples/validation-config.json");
+    const buildYaml = readFileSync(buildPath, "utf-8");
+    const valConfig = JSON.parse(readFileSync(valConfigPath, "utf-8"));
+    await compiler.initialize(buildYaml);
+    await compiler.generateCode(valConfig, "L1-validations", true);
+};
+(async () => {
+    await main();
+})();

package/package.json

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