ondc-code-generator 0.3.0 → 0.3.2

package/dist/generator/config-compiler.js

@@ -49,7 +49,7 @@ export class ConfigCompiler {
         this.withMinimalValidations = async (valConfig) => {
             try {
                 await new ConfigValidator("", valConfig, {}, [], {
-                    skipJsonPathTest: true,
+                    minimal: true,
                 }).validate();
             }
             catch (e) {

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

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

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

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

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

@@ -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();
             }
@@ -33,7 +34,7 @@ export class ConfigValidator {
         }
         else {
             this.validatorSettings = {
-                skipJsonPathTest: false,
+                minimal: false,
             };
         }
     }

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

@@ -9,19 +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[];
-    skipJsonPathTest: boolean;
-    constructor(testObject: TestObject, path: string, posibleJsonPaths: string[], externalVariables: string[], skipJsonPathTest?: boolean);
+    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,12 +93,13 @@ export class ErrorCodeValidator extends TestObjectValidator {
             }
         };
         this.possibleErrorCodes = possibleErrorCodes;
+        this.minimal = minimal;
     }
 }
 export class VariableValidator extends TestObjectValidator {
-    constructor(testObject, path, posibleJsonPaths, externalVariables, skipJsonPathTest = false) {
+    constructor(testObject, path, posibleJsonPaths, externalVariables, minimal = false) {
         super(testObject, path);
-        this.skipJsonPathTest = false;
+        this.minimal = false;
         this.validate = async () => {
             for (const key in this.targetObject) {
                 if (Object.values(TestObjectSyntax).includes(key)) {
@@ -120,8 +128,9 @@ export class VariableValidator extends TestObjectValidator {
                         path = `${scope}.${pathWithoutDollar}`;
                     }
                     const replaced = replaceBracketsWithAsteriskNested(path);
-                    if (!this.possibleJsonPaths.includes(replaced) &&
-                        !this.skipJsonPathTest) {
+                    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}`);
                     }
                 }
@@ -129,7 +138,7 @@ export class VariableValidator extends TestObjectValidator {
         };
         this.externalVariables = externalVariables;
         this.possibleJsonPaths = posibleJsonPaths;
-        this.skipJsonPathTest = skipJsonPathTest;
+        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, this.dependencies.skipJsonPathTest).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

@@ -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", true);
 // };
 // (async () => {
 // 	await main();

package/package.json

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