ondc-code-generator 0.4.5 → 0.5.0

package/dist/generator/generators/typescript/ts-generator.js

@@ -23,13 +23,14 @@ export class TypescriptGenerator extends CodeGenerator {
             for (const key in testConfig) {
                 const testObjects = testConfig[key];
                 const betaConfig = {
-                    [TestObjectSyntax.Name]: key,
+                    [TestObjectSyntax.Name]: key + "Validations",
                     [TestObjectSyntax.Return]: testObjects,
                 };
                 const testFunction = await this.generateTestFunction(betaConfig);
                 const apiTestTemplate = readFileSync(path.resolve(__dirname, "./templates/api-test.mustache"), "utf-8");
                 const finalCode = Mustache.render(apiTestTemplate, {
                     functionCode: testFunction.code,
+                    apiName: key,
                 });
                 await writeAndFormatCode(this.rootPath, `./api-tests/${key}.ts`, finalCode, "typescript");
             }
@@ -63,6 +64,9 @@ export class TypescriptGenerator extends CodeGenerator {
                     : undefined,
                 validationCode: await this.createValidationLogicCode(testObject),
                 successCode: testObject[TestObjectSyntax.SuccessCode] ?? 200,
+                errorCode: testObject[TestObjectSyntax.ErrorCode] ?? 30000,
+                testName: testObject[TestObjectSyntax.Name],
+                TEST_OBJECT: `${JSON.stringify(testObject)}`,
             };
             return {
                 funcName: testObject[TestObjectSyntax.Name],
@@ -80,6 +84,8 @@ export class TypescriptGenerator extends CodeGenerator {
                     returnStatement: returnStatement,
                     errorCode: testObject[TestObjectSyntax.ErrorCode] ?? 30000,
                     errorDescription: this.CreateErrorMarkdown(testObject, skipList),
+                    testName: testObject[TestObjectSyntax.Name],
+                    TEST_OBJECT: `${JSON.stringify(testObject)}`,
                 });
             }
             else {
@@ -96,6 +102,8 @@ export class TypescriptGenerator extends CodeGenerator {
                     isNested: true,
                     nestedFunctions: functionCodes.map((f) => f.code).join("\n"),
                     names: names,
+                    testName: testObject[TestObjectSyntax.Name],
+                    TEST_OBJECT: `${JSON.stringify(testObject)}`,
                 });
             }
         };
@@ -158,31 +166,35 @@ export class TypescriptGenerator extends CodeGenerator {
     }
     generateIndexFile(apis, functionName = "L1Validations") {
         functionName = functionName.replace(/[^a-zA-Z0-9_]/g, "");
-        const importsCode = apis
+        let importsCode = apis
             .map((api) => `import ${api} from "./api-tests/${api}";`)
             .join("\n");
+        importsCode += `\nimport { ValidationConfig,validationOutput } from "./types/test-config";`;
+        importsCode += `\nimport normalizeKeys from "./utils/json-normalizer";`;
+        const masterTemplate = readFileSync(path.resolve(__dirname, "./templates/index.mustache"), "utf-8");
         const masterFunction = `
-				export function perform${functionName}(action: string, payload: any,allErrors = false, externalData : any = {}) {
-				const normalizedPayload = normalizeKeys(payload);
-				externalData._SELF = normalizedPayload;
+				export function perform${functionName}(action: string, payload: any, config?: Partial<ValidationConfig>, externalData: any = {}) {
+					const completeConfig: ValidationConfig = {
+						...{ onlyInvalid: true, standardLogs: false, hideParentErrors: true, _debug: false },
+						...config,
+					};
+					const normalizedPayload = normalizeKeys(JSON.parse(JSON.stringify(payload)));
+					externalData._SELF = normalizedPayload;
 					switch (action) {
 						${apis
             .map((api) => `case "${api}": return ${api}({
 				payload: normalizedPayload,
 				externalData: externalData,
-				config: {
-					runAllValidations: allErrors,
-				},
+				config: completeConfig,
 			});`)
             .join("\n")}
 						default:
 							throw new Error("Action not found");
 					}
 			}`;
-        return `	
-				import normalizeKeys from "./utils/json-normalizer";
-				${importsCode}
-				${masterFunction}
-			`;
+        return Mustache.render(masterTemplate, {
+            importsCode: importsCode,
+            masterFunction: masterFunction,
+        });
     }
 }

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

@@ -1,4 +1,4 @@
-import { TestObjectSyntax, nodeReservedKeywords, ExternalDataSyntax, ConfigSyntax, } from "../../../constants/syntax.js";
+import { TestObjectSyntax, ReservedKeywords, ExternalDataSyntax, ConfigSyntax, } from "../../../constants/syntax.js";
 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";
@@ -31,7 +31,7 @@ export class NameValidator extends TestObjectValidator {
             if (name.length < 1) {
                 throw new Error(`${TestObjectSyntax.Name} can't be a non-empty string at path ${this.validationPath}`);
             }
-            if (nodeReservedKeywords.has(name)) {
+            if (ReservedKeywords.has(name)) {
                 throw new Error(`${TestObjectSyntax.Name} can't be a reserved keyword at path ${this.validationPath}`);
             }
             if (!isSnakeCase(name)) {
@@ -141,7 +141,7 @@ export class VariableValidator extends TestObjectValidator {
         this.minimal = minimal;
     }
     validateKey(key) {
-        if (nodeReservedKeywords.has(key)) {
+        if (ReservedKeywords.has(key)) {
             throw new Error(`${key} can't be a reserved keyword at path ${this.validationPath}`);
         }
         if (key.includes(" ")) {

package/dist/index.js

@@ -7,7 +7,7 @@ export { ConfigCompiler };
 // const __dirname = path.dirname(__filename);
 // import { SupportedLanguages } from "./types/compiler-types.js";
 // const main = async () => {
-// 	const compiler = new ConfigCompiler(SupportedLanguages.Typescript);
+// 	const compiler = new ConfigCompiler(SupportedLanguages.Python);
 // 	const buildPath = path.resolve(__dirname, "../samples/build.yaml");
 // 	const valConfigPath = path.resolve(
 // 		__dirname,
@@ -16,7 +16,20 @@ 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", false, "./alpha/");
+// 	await compiler.generateCode(
+// 		valConfig,
+// 		"L1_validations",
+// 		false,
+// 		"./alpha/python/"
+// 	);
+// 	const compilerTy = new ConfigCompiler(SupportedLanguages.Typescript);
+// 	await compilerTy.initialize(buildYaml);
+// 	await compilerTy.generateCode(
+// 		valConfig,
+// 		"L1_validations",
+// 		false,
+// 		"./alpha/typescript/"
+// 	);
 // };
 // (async () => {
 // 	await main();

package/dist/types/compiler-types.d.ts

@@ -1,3 +1,4 @@
 export declare enum SupportedLanguages {
-    Typescript = "typescript"
+    Typescript = "typescript",
+    Python = "python"
 }

package/dist/types/compiler-types.js

@@ -1,4 +1,5 @@
 export var SupportedLanguages;
 (function (SupportedLanguages) {
     SupportedLanguages["Typescript"] = "typescript";
+    SupportedLanguages["Python"] = "python";
 })(SupportedLanguages || (SupportedLanguages = {}));

package/dist/utils/fs-utils.js

@@ -9,11 +9,54 @@ export function writeFileWithFsExtra(rootPath, relativeFilePath, content) {
     fs.outputFileSync(filePath, content);
 }
 export async function formatCode(code, lang) {
+    if (lang === "text") {
+        // No formatting for plain text files
+        return code;
+    }
+    if (lang == "python") {
+        // Basic Python formatting - clean up extra whitespace and blank lines
+        return formatPythonCode(code);
+    }
     return await prettier.format(code, {
         parser: lang,
         tabWidth: 4,
     });
 }
+function formatPythonCode(code) {
+    const lines = code.split("\n");
+    const formattedLines = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Skip lines that are only whitespace
+        if (line.trim() === "") {
+            // Only add empty line if the previous line wasn't empty
+            if (formattedLines.length > 0 &&
+                formattedLines[formattedLines.length - 1].trim() !== "") {
+                formattedLines.push("");
+            }
+            continue;
+        }
+        // Add the line as-is (preserve existing indentation)
+        formattedLines.push(line);
+    }
+    // Remove multiple consecutive empty lines
+    const cleanedLines = [];
+    let lastWasEmpty = false;
+    for (const line of formattedLines) {
+        const isEmpty = line.trim() === "";
+        if (isEmpty && lastWasEmpty) {
+            continue; // Skip consecutive empty lines
+        }
+        cleanedLines.push(line);
+        lastWasEmpty = isEmpty;
+    }
+    // Remove trailing empty lines
+    while (cleanedLines.length > 0 &&
+        cleanedLines[cleanedLines.length - 1].trim() === "") {
+        cleanedLines.pop();
+    }
+    return cleanedLines.join("\n") + "\n";
+}
 export async function writeAndFormatCode(rootPath, relativeFilePath, content, lang) {
     const formattedCode = await formatCode(content, lang);
     writeFileWithFsExtra(rootPath, relativeFilePath, formattedCode);

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

@@ -1,4 +1,4 @@
-import { nodeReservedKeywords, TestObjectSyntax, } from "../../constants/syntax.js";
+import { ReservedKeywords, 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
@@ -15,7 +15,7 @@ export function isValidVariableName(input) {
     const validVariableNameRegex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
     // Check if input matches the regex
     const matchesPattern = validVariableNameRegex.test(input);
-    const isNotReservedKeyword = !nodeReservedKeywords.has(input);
+    const isNotReservedKeyword = !ReservedKeywords.has(input);
     return matchesPattern && isNotReservedKeyword;
 }
 /**

package/package.json

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