ondc-code-generator 0.0.1 → 0.0.2

package/dist/constants/syntax.js

@@ -5,6 +5,7 @@ export var TestObjectSyntax;
     TestObjectSyntax["Scope"] = "_SCOPE_";
     TestObjectSyntax["Continue"] = "_CONTINUE_";
     TestObjectSyntax["ErrorCode"] = "_ERROR_CODE_";
+    TestObjectSyntax["SuccessCode"] = "_SUCCESS_CODE_";
 })(TestObjectSyntax || (TestObjectSyntax = {}));
 export const ExternalDataSyntax = "_EXTERNAL";
 export var ConfigSyntax;
@@ -18,6 +19,7 @@ export const ConfigKeyWords = [
     TestObjectSyntax.Scope,
     TestObjectSyntax.Continue,
     TestObjectSyntax.ErrorCode,
+    TestObjectSyntax.SuccessCode,
     ConfigSyntax.Tests,
     ConfigSyntax.SessionData,
 ];

package/dist/example.js

@@ -0,0 +1,22 @@
+"use strict";
+// import { readFileSync } from "fs";
+// import path from "path";
+// import { fileURLToPath } from "url";
+// import { SupportedLanguages } from "./types/compiler-types.js";
+// const __filename = fileURLToPath(import.meta.url);
+// const __dirname = path.dirname(__filename);
+// 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);
+// };
+// (async () => {
+// 	await main();
+// })();

package/dist/{Generator → generator}/config-compiler.js

@@ -4,6 +4,9 @@ import logger from "../utils/logger.js";
 import { SupportedLanguages } from "../types/compiler-types.js";
 import { TypescriptGenerator } from "./generators/typescript/ts-generator.js";
 import { ConfigValidator } from "./validators/config-validator.js";
+import { writeAndFormatCode } from "../utils/fs-utils.js";
+import { readFileSync } from "fs";
+import Mustache from "mustache";
 const defaultConfig = {
     removeRequiredfromSchema: true,
     removeEnumsfromSchema: true,
@@ -15,7 +18,7 @@ export class ConfigCompiler {
             const finalConfig = { ...defaultConfig, ...generatorConfig };
             this.buildData = await loadAndDereferenceYaml(buildYaml);
             this.jsonSchemas = await this.SchemaExtactionService.extractSchemas(this.buildData, finalConfig.removeRequiredfromSchema, finalConfig.removeEnumsfromSchema);
-            this.possibleJsonPahts = this.SchemaExtactionService.extractPossiblePaths(this.jsonSchemas);
+            this.possibleJsonPaths = this.SchemaExtactionService.extractPossiblePaths(this.jsonSchemas);
             const errors = this.buildData["x-errorcodes"];
             this.errorDefinitions = errors.code;
         };
@@ -25,11 +28,11 @@ export class ConfigCompiler {
                     throw new Error("Build data not initialized");
                 if (!this.jsonSchemas)
                     throw new Error("Schemas not initialized");
-                if (!this.possibleJsonPahts)
+                if (!this.possibleJsonPaths)
                     throw new Error("Possible paths not initialized");
                 if (!this.errorDefinitions)
                     throw new Error("Error definitions not initialized");
-                await new ConfigValidator("", valConfig, this.possibleJsonPahts, this.errorDefinitions).validate();
+                await new ConfigValidator("", valConfig, this.possibleJsonPaths, this.errorDefinitions).validate();
             }
             catch (e) {
                 logger.error(e);
@@ -41,12 +44,30 @@ export class ConfigCompiler {
             // Generate code based on the language
             switch (this.language) {
                 case SupportedLanguages.Typescript:
-                    await new TypescriptGenerator(valConfig, this.errorDefinitions ?? [], "./L1-validations").generateCode();
+                    await new TypescriptGenerator(valConfig, this.errorDefinitions ?? [], "./generated/L1-validations").generateCode();
                     break;
                 default:
                     throw new Error("Language not supported");
             }
         };
+        this.generateL0Schema = async () => {
+            if (!this.jsonSchemas) {
+                throw new Error("Schemas not initialized");
+            }
+            for (const schema in this.jsonSchemas) {
+                const json = this.jsonSchemas[schema];
+                writeAndFormatCode(`./generated/L0-schemas`, `${schema}.ts`, `export const ${schema} = ${JSON.stringify(json, null, 2)}`, "typescript");
+            }
+            const actions = Object.keys(this.jsonSchemas).map((schema) => {
+                return {
+                    action: schema,
+                };
+            });
+            const template = readFileSync("/Users/rudranshsinghal/ondc/automation-utility/official-code/code-generator/src/generator/generators/typescript/templates/schema-template.mustache", "utf-8");
+            console.log(actions);
+            const l0 = Mustache.render(template, { actions });
+            writeAndFormatCode(`./generated/L0-schemas`, `index.ts`, l0, "typescript");
+        };
         this.language = language;
         this.SchemaExtactionService = new SchemaExtactionService();
     }

package/dist/{Generator → generator}/generators/documentation/markdown-message-generator.js

@@ -2,23 +2,10 @@ import { CompileToMarkdown } from "../../../services/return-complier/ast-functio
 import { buildAstFromInput } from "../../../services/return-complier/combined.js";
 import Mustache from "mustache";
 import { addBlockquoteToMarkdown, addTabToMarkdown, ConvertArrayToStringsInTestObject, } from "../../../utils/general-utils/string-utils.js";
-import { TestObjectSyntax } from "../../../constants/syntax";
 export function markdownMessageGenerator(returnInput, variableValues, startingPointer, skipInput) {
     const ast = buildAstFromInput(returnInput);
     const returnTemplate = CompileToMarkdown(ast, startingPointer, 0, false);
-    if (variableValues[TestObjectSyntax.Scope]) {
-        const scope = variableValues[TestObjectSyntax.Scope];
-        for (const key in variableValues) {
-            if (Object.values(TestObjectSyntax).includes(key)) {
-                continue;
-            }
-            const path = variableValues[key];
-            const pathWithoutDollar = path.slice(2);
-            variableValues[key] = `${scope}.${pathWithoutDollar}`;
-        }
-    }
     let finalReturn = Mustache.render(returnTemplate, ConvertArrayToStringsInTestObject(variableValues));
-    console.log(finalReturn);
     if (skipInput) {
         let skipMarkdown = `Note: **Condition ${startingPointer}** can be skipped if the following conditions are met:`;
         const letters = "BCDEFGHIJKLMNOPQRSTUVWXYZ";

package/dist/{Generator → generator}/generators/typescript/ts-generator.js

@@ -9,7 +9,6 @@ import { ConvertArrayToString } from "../../../utils/general-utils/string-utils.
 import { compileInputToTs } from "./ts-ast.js";
 import { CodeGenerator } from "../classes/abstract-generator.js";
 import { writeAndFormatCode } from "../../../utils/fs-utils.js";
-import logger from "../../../utils/logger.js";
 import { MarkdownDocGenerator } from "../documentation/md-generator.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -61,6 +60,7 @@ export class TypescriptGenerator extends CodeGenerator {
                     ? compileInputToTs(testObject[TestObjectSyntax.Continue])
                     : undefined,
                 validationCode: await this.createValidationLogicCode(testObject),
+                successCode: testObject[TestObjectSyntax.SuccessCode] ?? 200,
             };
             return {
                 funcName: testObject[TestObjectSyntax.Name],
@@ -90,7 +90,6 @@ export class TypescriptGenerator extends CodeGenerator {
                 const names = functionCodes.map((f) => {
                     return { name: f.funcName };
                 });
-                logger.debug(JSON.stringify(names));
                 return Mustache.render(template, {
                     isNested: true,
                     nestedFunctions: functionCodes.map((f) => f.code).join("\n"),
@@ -100,7 +99,7 @@ export class TypescriptGenerator extends CodeGenerator {
         };
     }
     CreateErrorMarkdown(testObject, skipList) {
-        return markdownMessageGenerator(testObject[TestObjectSyntax.Return], testObject, "A", skipList);
+        return markdownMessageGenerator(testObject[TestObjectSyntax.Return], testObject, testObject[TestObjectSyntax.Name], skipList);
     }
     createVariablesCode(testObject) {
         const variables = [];
@@ -108,7 +107,7 @@ export class TypescriptGenerator extends CodeGenerator {
         for (const name of varNames) {
             const value = testObject[name];
             const final = typeof value === "string"
-                ? `payloadUtils.getJsonPath(testObj, '${value}')`
+                ? `payloadUtils.getJsonPath(testObj, "${value}")`
                 : ConvertArrayToString(value);
             variables.push({
                 name: name,

package/dist/{Generator → generator}/validators/abstract-validator.js

@@ -1,6 +1,6 @@
 export class TestObjectValidator {
     constructor(testObject, path) {
         this.targetObject = testObject;
-        this.validtionPath = path;
+        this.validationPath = path;
     }
 }

package/dist/{Generator → 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(validtionPath, config, stringJsonPaths, errorDefinitions) {
+    constructor(validationPath, config, stringJsonPaths, errorDefinitions) {
         this.validate = async () => {
             if (!this.config[ConfigSyntax.Tests])
                 throw new Error(`Tests not found in config`);
@@ -11,11 +11,11 @@ export class ConfigValidator {
                 throw new Error(`SessionData not found in config`);
             const sessionData = this.config[ConfigSyntax.SessionData];
             const tests = this.config[ConfigSyntax.Tests];
-            await new SessionDataValidator(`${this.validtionPath}/${ConfigSyntax.SessionData}`, sessionData).validate();
+            await new SessionDataValidator(`${this.validationPath}/${ConfigSyntax.SessionData}`, sessionData).validate();
             const externalVariables = getExternalVariables(sessionData);
             for (const api in tests) {
                 const testList = tests[api];
-                const path = `${this.validtionPath}/${ConfigSyntax.Tests}/${api}`;
+                const path = `${this.validationPath}/${ConfigSyntax.Tests}/${api}`;
                 const dependencies = {
                     stringJsonPaths: this.stringJsonPaths[api],
                     errorDefinitions: this.errorDefinitions,
@@ -24,7 +24,7 @@ export class ConfigValidator {
                 await new TestsValidator(testList, path, dependencies).validate();
             }
         };
-        this.validtionPath = validtionPath;
+        this.validationPath = validationPath;
         this.config = config;
         this.stringJsonPaths = stringJsonPaths;
         this.errorDefinitions = errorDefinitions;

package/dist/{Generator → generator}/validators/session-data-config/session-data-validator.js

@@ -3,11 +3,11 @@ export class SessionDataValidator {
     constructor(validtionPath, sessionData) {
         this.validate = async () => {
             Object.entries(this.sessionData).forEach(([key, value]) => {
-                const newPath = `${this.validtionPath}/${key}`;
+                const newPath = `${this.validationPath}/${key}`;
                 this.validateSessionData(value, newPath);
             });
         };
-        this.validtionPath = validtionPath;
+        this.validationPath = validtionPath;
         this.sessionData = sessionData;
     }
     validateSessionData(variable, path) {

package/dist/{Generator → generator}/validators/tests-config/sub-validations.js

@@ -2,7 +2,7 @@ import { TestObjectSyntax, nodeReservedKeywords, ExternalDataSyntax, ConfigSynta
 import { buildAst } from "../../../services/return-complier/ast.js";
 import { checkValidVariables } from "../../../services/return-complier/ast-functions/semantic-validations.js";
 import { parseReturnInput } from "../../../services/return-complier/parser.js";
-import { isValidVariableName, } from "../../../utils/general-utils/string-utils.js";
+import { isSnakeCase, isValidVariableName, } from "../../../utils/general-utils/string-utils.js";
 import { isValidVariableValueType } from "../../../utils/general-utils/validation-utils.js";
 import { isValidJsonPath, replaceBracketsWithAsteriskNested, } from "../../../utils/json-path-utils/paths.js";
 import { TestObjectValidator, } from "../abstract-validator.js";
@@ -12,10 +12,10 @@ export class RequiredFieldsValidator extends TestObjectValidator {
         super(...arguments);
         this.validate = async () => {
             if (!this.targetObject[TestObjectSyntax.Name]) {
-                throw new Error(`${TestObjectSyntax.Name} is required at path ${this.validtionPath}`);
+                throw new Error(`${TestObjectSyntax.Name} is required at path ${this.validationPath}`);
             }
             if (!this.targetObject[TestObjectSyntax.Return]) {
-                throw new Error(`${TestObjectSyntax.Return} is required at path ${this.validtionPath}`);
+                throw new Error(`${TestObjectSyntax.Return} is required at path ${this.validationPath}`);
             }
         };
     }
@@ -25,20 +25,18 @@ export class NameValidator extends TestObjectValidator {
         super(...arguments);
         this.validate = async () => {
             if (typeof this.targetObject[TestObjectSyntax.Name] !== "string") {
-                throw new Error(`${TestObjectSyntax.Name} should be a string at path ${this.validtionPath}`);
+                throw new Error(`${TestObjectSyntax.Name} should be a string at path ${this.validationPath}`);
             }
             const name = this.targetObject[TestObjectSyntax.Name];
             if (name.length < 1) {
-                throw new Error(`${TestObjectSyntax.Name} can't be a non-empty string at path ${this.validtionPath}`);
+                throw new Error(`${TestObjectSyntax.Name} can't be a non-empty string at path ${this.validationPath}`);
             }
             if (nodeReservedKeywords.has(name)) {
-                throw new Error(`${TestObjectSyntax.Name} can't be a reserved keyword at path ${this.validtionPath}`);
+                throw new Error(`${TestObjectSyntax.Name} can't be a reserved keyword at path ${this.validationPath}`);
+            }
+            if (!isSnakeCase(name)) {
+                throw new Error(`${TestObjectSyntax.Name} must be in snake_case at path ${this.validationPath}`);
             }
-            // if (!isSnakeCase(name)) {
-            // 	throw new Error(
-            // 		`${TestObjectSyntax.Name} must be in snake_case at path ${this.validtionPath}`
-            // 	);
-            // }
         };
     }
 }
@@ -48,16 +46,16 @@ export class ScopeValidator extends TestObjectValidator {
         this.validate = async () => {
             const path = this.targetObject[TestObjectSyntax.Scope];
             if (typeof path !== "string") {
-                throw new Error(`${TestObjectSyntax.Scope} should be a string at path ${this.validtionPath}`);
+                throw new Error(`${TestObjectSyntax.Scope} should be a string at path ${this.validationPath}`);
             }
             if (!isValidJsonPath(path)) {
-                throw new Error(`${TestObjectSyntax.Scope} should be a valid json path at path ${this.validtionPath}`);
+                throw new Error(`${TestObjectSyntax.Scope} should be a valid json path at path ${this.validationPath}`);
             }
             if (!path.startsWith(`$.`)) {
-                throw new Error(`${TestObjectSyntax.Scope} json path should start with $. at ${this.validtionPath}`);
+                throw new Error(`${TestObjectSyntax.Scope} json path should start with $. at ${this.validationPath}`);
             }
             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.validtionPath}`);
+                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;
@@ -71,14 +69,20 @@ export class ErrorCodeValidator extends TestObjectValidator {
                 return;
             }
             if (typeof this.targetObject[TestObjectSyntax.Return] !== "string") {
-                throw new Error(`You can't define a ${TestObjectSyntax.ErrorCode} with nested ${TestObjectSyntax.Return} at path ${this.validtionPath}`);
+                throw new Error(`You can't define a ${TestObjectSyntax.ErrorCode} with nested ${TestObjectSyntax.Return} at path ${this.validationPath}`);
             }
             if (typeof this.targetObject[TestObjectSyntax.ErrorCode] !== "number") {
-                throw new Error(`${TestObjectSyntax.ErrorCode} should be a number at path ${this.validtionPath}`);
+                throw new Error(`${TestObjectSyntax.ErrorCode} should be a number at path ${this.validationPath}`);
             }
             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.validtionPath}`);
+                throw new Error(`${TestObjectSyntax.ErrorCode} don't exist in error codes at path ${this.validationPath}`);
+            }
+            if (!this.targetObject[TestObjectSyntax.SuccessCode]) {
+                return;
+            }
+            if (typeof this.targetObject[TestObjectSyntax.SuccessCode] !== "number") {
+                throw new Error(`${TestObjectSyntax.SuccessCode} should be a number at path ${this.validationPath}`);
             }
         };
         this.possibleErrorCodes = possibleErrorCodes;
@@ -94,15 +98,16 @@ export class VariableValidator extends TestObjectValidator {
                 }
                 this.validateKey(key);
                 const value = this.targetObject[key];
+                console.log(value);
                 if (!isValidVariableValueType(value)) {
-                    throw new Error(`Variable: ${key} should be a string or array of primitives at path ${this.validtionPath}`);
+                    throw new Error(`Variable: ${key} should be a string or array of primitives at path ${this.validationPath}`);
                 }
                 if (typeof value === "string") {
                     if (!isValidJsonPath(value)) {
-                        throw new Error(`Variable: ${key} should be a valid jsonPath at ${this.validtionPath}`);
+                        throw new Error(`Variable: ${key} should be a valid jsonPath at ${this.validationPath}`);
                     }
                     if (!value.startsWith(`$.`)) {
-                        throw new Error(`Variable: ${key} should start with $. at ${this.validtionPath}`);
+                        throw new Error(`Variable: ${key} should start with $. at ${this.validationPath}`);
                     }
                     if (value.startsWith(`$.${ExternalDataSyntax}`)) {
                         this.validateExternalData(value, this.externalVariables);
@@ -116,7 +121,7 @@ export class VariableValidator extends TestObjectValidator {
                     }
                     const replaced = replaceBracketsWithAsteriskNested(path);
                     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.validtionPath} found orignal ${path} replaces: ${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}`);
                     }
                 }
             }
@@ -126,22 +131,22 @@ export class VariableValidator extends TestObjectValidator {
     }
     validateKey(key) {
         if (nodeReservedKeywords.has(key)) {
-            throw new Error(`${key} can't be a reserved keyword at path ${this.validtionPath}`);
+            throw new Error(`${key} can't be a reserved keyword at path ${this.validationPath}`);
         }
         if (key.includes(" ")) {
-            throw new Error(`${key} can't contain spaces at path ${this.validtionPath}`);
+            throw new Error(`${key} can't contain spaces at path ${this.validationPath}`);
         }
         if (key === this.targetObject[TestObjectSyntax.Name]) {
-            throw new Error(`${key} can't be the same as ${TestObjectSyntax.Name} at path ${this.validtionPath}`);
+            throw new Error(`${key} can't be the same as ${TestObjectSyntax.Name} at path ${this.validationPath}`);
         }
         if (!isValidVariableName(key)) {
-            throw new Error(`${key} is not a valid variable name at path ${this.validtionPath}`);
+            throw new Error(`${key} is not a valid variable name at path ${this.validationPath}`);
         }
     }
     validateExternalData(path, definedExternalValues) {
         const externalData = path.split(".")[2];
         if (!definedExternalValues.includes(externalData)) {
-            throw new Error(`${externalData} is not defined in ${ConfigSyntax.SessionData} data at path ${this.validtionPath}`);
+            throw new Error(`${externalData} is not defined in ${ConfigSyntax.SessionData} data at path ${this.validationPath}`);
         }
     }
 }
@@ -154,13 +159,13 @@ export class ContinueValidator extends TestObjectValidator {
                 if (typeof contStatement === "string") {
                     const cst = parseReturnInput(contStatement);
                     const ast = buildAst(cst);
-                    checkValidVariables(ast, this.definedVariables, this.validtionPath);
+                    checkValidVariables(ast, this.definedVariables, this.validationPath);
                     return;
                 }
-                throw new Error(`${TestObjectSyntax.Continue} should be a string at path ${this.validtionPath}`);
+                throw new Error(`${TestObjectSyntax.Continue} should be a string at path ${this.validationPath}`);
             }
             catch (err) {
-                throw new Error(err.message + " at path " + this.validtionPath);
+                throw new Error(err.message + " at path " + this.validationPath);
             }
         };
         this.definedVariables = Object.keys(testObject).filter((key) => !Object.values(TestObjectSyntax).includes(key));
@@ -175,17 +180,17 @@ export class ReturnValidator extends TestObjectValidator {
                 if (typeof returnStatement === "string") {
                     const cst = parseReturnInput(returnStatement);
                     const ast = buildAst(cst);
-                    checkValidVariables(ast, this.definedVariables, this.validtionPath);
+                    checkValidVariables(ast, this.definedVariables, this.validationPath);
                     return;
                 }
                 if (Array.isArray(returnStatement)) {
-                    await new TestsValidator(returnStatement, this.validtionPath, this.dependencies).validate();
+                    await new TestsValidator(returnStatement, this.validationPath, this.dependencies).validate();
                     return;
                 }
                 throw new Error(`${TestObjectSyntax.Return} should be a string or arrays`);
             }
             catch (err) {
-                throw new Error(err.message + " at path " + this.validtionPath);
+                throw new Error(err.message + " at path " + this.validationPath);
             }
         };
         this.definedVariables = Object.keys(testObject).filter((key) => !Object.values(TestObjectSyntax).includes(key));

package/dist/{Generator → generator}/validators/tests-config/test-list-validator.js

@@ -6,7 +6,7 @@ export class TestsValidator {
             this.validateDuplicateNames();
             let i = 0;
             for (const test of this.tests) {
-                const newPath = `${this.validtionPath}/${i}/${TestObjectSyntax.Name} = ${test[TestObjectSyntax.Name]}`;
+                const newPath = `${this.validationPath}/${i}/${TestObjectSyntax.Name} = ${test[TestObjectSyntax.Name]}`;
                 await new CompleteTestObjectValidator(test, newPath, this.dependencies).validate();
                 i++;
             }
@@ -24,13 +24,13 @@ export class TestsValidator {
                 }
             });
             if (duplicates.size > 0) {
-                throw new Error(`Duplicate test names found at ${this.validtionPath}: ${[
+                throw new Error(`Duplicate test names found at ${this.validationPath}: ${[
                     ...duplicates,
                 ].join(", ")}`);
             }
         };
         this.tests = tests;
-        this.validtionPath = configPath;
+        this.validationPath = configPath;
         this.dependencies = dependencies;
     }
 }

package/dist/{Generator → generator}/validators/tests-config/test-validator.js

@@ -5,19 +5,19 @@ export class CompleteTestObjectValidator extends TestObjectValidator {
     constructor(testObject, path, dependencies) {
         super(testObject, path);
         this.validate = async () => {
-            await new RequiredFieldsValidator(this.targetObject, this.validtionPath).validate();
-            await new NameValidator(this.targetObject, this.validtionPath).validate();
+            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.validtionPath, this.dependencies.stringJsonPaths).validate();
+                await new ScopeValidator(this.targetObject, this.validationPath, this.dependencies.stringJsonPaths).validate();
             }
             if (this.targetObject[TestObjectSyntax.ErrorCode]) {
-                await new ErrorCodeValidator(this.targetObject, this.validtionPath, this.dependencies.errorDefinitions).validate();
+                await new ErrorCodeValidator(this.targetObject, this.validationPath, this.dependencies.errorDefinitions).validate();
             }
-            await new VariableValidator(this.targetObject, this.validtionPath, this.dependencies.stringJsonPaths, this.dependencies.externalVariables).validate();
+            await new VariableValidator(this.targetObject, this.validationPath, this.dependencies.stringJsonPaths, this.dependencies.externalVariables).validate();
             if (this.targetObject[TestObjectSyntax.Continue]) {
-                await new ContinueValidator(this.targetObject, this.validtionPath).validate();
+                await new ContinueValidator(this.targetObject, this.validationPath).validate();
             }
-            await new ReturnValidator(this.targetObject, this.validtionPath, this.dependencies).validate();
+            await new ReturnValidator(this.targetObject, this.validationPath, this.dependencies).validate();
         };
         this.dependencies = dependencies;
     }

package/dist/index.js

@@ -1,39 +1,2 @@
-import { readFileSync } from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-import { SupportedLanguages } from "./types/compiler-types.js";
 import { ConfigCompiler } from "./generator/config-compiler.js";
-// Get __dirname equivalent
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-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);
-    // await compiler.performValidations(valConfig);
-    // const inputs = [
-    // 	"a are unique && b are unique",
-    // 	"a are unique",
-    // 	"(a are unique && b are unique) || c are unique",
-    // 	"a are unique && b are unique || c are unique",
-    // 	"a are unique && (b are unique || c are unique)",
-    // 	"a are unique && b are unique && c are unique && d are unique",
-    // 	"a are unique && !(b are unique || !(c are unique))",
-    // 	"a are unique && (b are unique || !(!(c are unique))) && !(d are unique)",
-    // ];
-    // let output = "";
-    // for (const input of inputs) {
-    // 	const cst = parseReturnInput(input);
-    // 	const ast = buildAst(cst);
-    // 	const out = CompileToMarkdown(ast, "A", 0, false);
-    // 	output += `\n## ${input}\n\n${out}\n`;
-    // }
-    // writeFileSync(path.resolve(__dirname, "../samples/output.md"), output);
-};
-(async () => {
-    await main();
-})();
+export { ConfigCompiler };

package/dist/services/return-complier/tokens.js

@@ -50,16 +50,19 @@ export const NoneIn = createToken({
 export const EqualTo = createToken({
     name: "EqualTo",
     pattern: /equal to/i,
+    categories: CustomBinaryFunctions,
     label: "equal to",
 });
 export const GreaterThan = createToken({
     name: "GreaterThan",
     pattern: /greater than/i,
+    categories: CustomBinaryFunctions,
     label: "greater than",
 });
 export const LessThan = createToken({
     name: "LessThan",
     pattern: /less than/i,
+    categories: CustomBinaryFunctions,
     label: "less than",
 });
 export const WhiteSpace = createToken({

package/dist/utils/general-utils/string-utils.js

@@ -1,4 +1,4 @@
-import { nodeReservedKeywords } from "../../constants/syntax.js";
+import { nodeReservedKeywords, TestObjectSyntax, } from "../../constants/syntax.js";
 import { getVariablesFromTest } from "./test-object-utils.js";
 /**
  * 	Check if the string matches the pattern: lowercase letters and underscores only, no leading or trailing underscores
@@ -7,7 +7,7 @@ import { getVariablesFromTest } from "./test-object-utils.js";
  * @returns true if the string is in snake_case, false otherwise
  */
 export function isSnakeCase(str) {
-    const snakeCasePattern = /^[a-z0-9]+(_[a-z0-9]+)*$/;
+    const snakeCasePattern = /^[a-z0-9A-Z]+(_[a-z0-9A-Z]+)*$/;
     return snakeCasePattern.test(str);
 }
 export function isValidVariableName(input) {
@@ -33,12 +33,20 @@ export function addBlockquoteToMarkdown(markdown) {
 export function ConvertArrayToStringsInTestObject(testObject) {
     const variables = getVariablesFromTest(testObject);
     const testDuplicate = { ...testObject };
+    const scope = testObject[TestObjectSyntax.Scope];
     for (const variable of variables) {
         if (Array.isArray(testObject[variable])) {
             let vals = testObject[variable].map((v) => `"${v}"`).join(", ");
             vals = vals.replace(/"/g, `"`);
             testDuplicate[variable] = `[${vals}]`;
         }
+        else {
+            if (scope) {
+                const path = testDuplicate[variable];
+                const pathWithoutDollar = path.slice(2);
+                testDuplicate[variable] = `${scope}.${pathWithoutDollar}`;
+            }
+        }
     }
     return testDuplicate;
 }

package/package.json

@@ -1,13 +1,15 @@
 {
 	"name": "ondc-code-generator",
-	"version": "0.0.1",
+	"version": "0.0.2",
 	"description": "generate code from build.yaml ",
 	"main": "index.js",
 	"type": "module",
 	"scripts": {
 		"build": "tsc",
 		"start": "node ./dist/index.js",
-		"dev": "nodemon"
+		"dev": "nodemon",
+		"clean": "rm -rf dist",
+		"prepare": "npm run clean && npm run build"
 	},
 	"author": "extedcoud",
 	"license": "MIT",

package/dist/Generator/config-validator.js

@@ -1,21 +0,0 @@
-/*
-    validations:
-        a single test object validations:
-            1. name validations
-            2. scope validation
-            3. variable validation
-            4. continue and return validations
-            5. errorcode validations
-            6. json path validations
-            7. external data validations
-
-        upper validations:
-            1. unique names
-            2. _session_data_ are valid
-            3. _tests_ are valid
-        
-        x-errorcode validations:
-            1. all codes are unique
-*/
-export class ConfigValidator {
-}

package/dist/Generator/generators/markdown-message-generator.js

@@ -1,25 +0,0 @@
-import { CompileToMarkdown } from "../../services/return-complier/ast-functions/compile-to-markdown.js";
-import { buildAstFromInput } from "../../services/return-complier/combined.js";
-import Mustache from "mustache";
-import { addBlockquoteToMarkdown, ConvertArrayToStringsInTestObject, } from "../../utils/general-utils/string-utils.js";
-export function markdownMessageGenerator(returnInput, variableValues, startingPointer, skipInput) {
-    const ast = buildAstFromInput(returnInput);
-    const returnTemplate = CompileToMarkdown(ast, startingPointer, 0, false);
-    let finalReturn = Mustache.render(returnTemplate, ConvertArrayToStringsInTestObject(variableValues));
-    console.log(finalReturn);
-    if (skipInput) {
-        let skipMarkdown = `Note: **Condition ${startingPointer}** can be skipped if the following conditions are met:`;
-        const letters = "BCDEFGHIJKLMNOPQRSTUVWXYZ";
-        let index = 0;
-        for (const skip of skipInput) {
-            const skipAst = buildAstFromInput(skip);
-            const skipTemplate = CompileToMarkdown(skipAst, letters[index], 0, false);
-            const finalSkip = Mustache.render(skipTemplate, ConvertArrayToStringsInTestObject(variableValues));
-            skipMarkdown += `\n\n${finalSkip}`;
-            index++;
-        }
-        const blockSkip = addBlockquoteToMarkdown(skipMarkdown);
-        finalReturn += `\n###\n${blockSkip}`;
-    }
-    return finalReturn;
-}

package/dist/Generator/pipline.js

@@ -1 +0,0 @@
-"use strict";

package/dist/Generator/validators/validation-error.js

@@ -1,9 +0,0 @@
-"use strict";
-class ValidationError extends Error {
-    constructor(message, path, value = null) {
-        super(message);
-        this.name = "ValidationError";
-        this.path = path;
-        this.value = value;
-    }
-}

package/dist/services/rename-later/main.js

@@ -1 +0,0 @@
-"use strict";

package/dist/services/rename-later/parser.js

@@ -1,22 +0,0 @@
-import { CstParser } from "chevrotain";
-import { allTokens, NumberLiteral, PlusMinusOperator } from "./tokens.js";
-export default class CalculatorParser extends CstParser {
-    constructor() {
-        super(allTokens);
-        const $ = this;
-        $.RULE("expression", () => {
-            $.SUBRULE($.additionExpression);
-        });
-        $.RULE("additionExpression", () => {
-            $.SUBRULE($.atomicExpression, { LABEL: "lhs" });
-            $.MANY(() => {
-                $.CONSUME(PlusMinusOperator);
-                $.SUBRULE2($.atomicExpression, { LABEL: "rhs" });
-            });
-        });
-        $.RULE("atomicExpression", () => {
-            $.CONSUME(NumberLiteral);
-        });
-        $.performSelfAnalysis();
-    }
-}

package/dist/services/rename-later/tokens.js

@@ -1,32 +0,0 @@
-import { createToken, Lexer } from "chevrotain";
-export const NumberLiteral = createToken({
-    name: "NumberLiteral",
-    pattern: /[0-9]+/,
-});
-export const PlusMinusOperator = createToken({
-    name: "PlusMinusOperator",
-    pattern: Lexer.NA,
-});
-export const Plus = createToken({
-    name: "Plus",
-    pattern: /\+/,
-    categories: PlusMinusOperator,
-});
-export const Minus = createToken({
-    name: "Minus",
-    pattern: /-/,
-    categories: PlusMinusOperator,
-});
-export const WhiteSpace = createToken({
-    name: "WhiteSpace",
-    pattern: /\s+/,
-    line_breaks: true,
-    group: Lexer.SKIPPED,
-});
-export const allTokens = [
-    Plus,
-    Minus,
-    NumberLiteral,
-    PlusMinusOperator,
-    WhiteSpace,
-];

package/dist/services/rename-later/tokens1.js

@@ -1,33 +0,0 @@
-import { createToken, Lexer } from "chevrotain";
-export const NumberLiteral = createToken({
-    name: "NumberLiteral",
-    pattern: /[0-9]+/,
-});
-export const PlusMinusOperator = createToken({
-    name: "PlusMinusOperator",
-    pattern: Lexer.NA,
-});
-export const Plus = createToken({
-    name: "Plus",
-    pattern: /\+/,
-    categories: PlusMinusOperator,
-});
-export const Minus = createToken({
-    name: "Minus",
-    pattern: /-/,
-    categories: PlusMinusOperator,
-});
-export const WhiteSpace = createToken({
-    name: "WhiteSpace",
-    pattern: /\s+/,
-    line_breaks: true,
-    group: Lexer.SKIPPED,
-});
-export const allTokens = [
-    Plus,
-    Minus,
-    NumberLiteral,
-    PlusMinusOperator,
-    WhiteSpace,
-];
-console.log(allTokens);

package/dist/utils/file-system.js

@@ -1 +0,0 @@
-"use strict";