ondc-code-generator 0.5.41 → 0.5.50

package/dist/generator/config-compiler.js

@@ -10,6 +10,7 @@ import { fileURLToPath } from "url";
 import path from "path";
 import { duplicateVariablesInChildren } from "../utils/config-utils/duplicateVariables.js";
 import { PythonGenerator } from "./generators/python/py-generator.js";
+import { JavascriptGenerator } from "./generators/javascript/js-generator.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const defaultConfig = {
@@ -58,7 +59,6 @@ export class ConfigCompiler {
         this.generateCode = async (valConfig, codeName = "L1-Validations", minimal = false, outputPath = "./") => {
             valConfig = JSON.parse(JSON.stringify(valConfig));
             if (this.generatorConfig?.duplicateVariablesInChildren) {
-                console.log("Duplicating variables");
                 valConfig = duplicateVariablesInChildren(valConfig);
             }
             if (minimal) {
@@ -80,6 +80,11 @@ export class ConfigCompiler {
                         codeName: codeName,
                     });
                     break;
+                case SupportedLanguages.Javascript:
+                    await new JavascriptGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode({
+                        codeName: codeName,
+                    });
+                    break;
                 default:
                     throw new Error("Language not supported");
             }
@@ -105,7 +110,6 @@ export class ConfigCompiler {
                     };
                 });
                 const template = readFileSync(path.resolve(__dirname, "../generator/generators/typescript/templates/schema-template.mustache"), "utf-8");
-                console.log(actions);
                 const l0 = Mustache.render(template, { actions });
                 await writeAndFormatCode(targetPath, `index.ts`, l0, "typescript");
             }

package/dist/generator/generators/documentation/markdown-message-generator.d.ts

@@ -1,2 +1,8 @@
 import { TestObject } from "../../../types/config-types.js";
+/**
+ * Generates the human-friendly Markdown doc:
+ * - Title: "### Validation: <NAME>"
+ * - Body:  top-level AND/OR group (no 1.1.1 pointers)
+ * - Skip:  blockquoted "Skip if:" with a unified "Any of these are true:" list
+ */
 export declare function markdownMessageGenerator(returnInput: string, variableValues: TestObject, startingPointer: string, skipInput?: string[]): string;

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

@@ -1,26 +1,34 @@
-import { CompileToMarkdown } from "../../../services/return-complier/ast-functions/compile-to-markdown.js";
+import { CompileToMarkdown, CompileToMarkdownForSkip, } from "../../../services/return-complier/ast-functions/compile-to-markdown.js";
 import { buildAstFromInput } from "../../../services/return-complier/combined.js";
 import Mustache from "mustache";
-import { addBlockquoteToMarkdown, addTabToMarkdown, ConvertArrayToStringsInTestObject, } from "../../../utils/general-utils/string-utils.js";
+import { addBlockquoteToMarkdown, ConvertArrayToStringsInTestObject, } from "../../../utils/general-utils/string-utils.js";
 import { TestObjectSyntax } from "../../../constants/syntax.js";
+/**
+ * Generates the human-friendly Markdown doc:
+ * - Title: "### Validation: <NAME>"
+ * - Body:  top-level AND/OR group (no 1.1.1 pointers)
+ * - Skip:  blockquoted "Skip if:" with a unified "Any of these are true:" list
+ */
 export function markdownMessageGenerator(returnInput, variableValues, startingPointer, skipInput) {
     const ast = buildAstFromInput(returnInput);
     const returnTemplate = variableValues[TestObjectSyntax.Description]
         ? variableValues[TestObjectSyntax.Description]
-        : CompileToMarkdown(ast, startingPointer, 0, false);
-    let finalReturn = Mustache.render(returnTemplate, ConvertArrayToStringsInTestObject(variableValues));
-    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++;
+        : CompileToMarkdown(ast, /*topLevel*/ true, /*depth*/ 0, /*forNot*/ false);
+    let finalReturn = `#### ${startingPointer}\n\n` +
+        Mustache.render(returnTemplate, ConvertArrayToStringsInTestObject(variableValues));
+    if (skipInput && skipInput.length > 0) {
+        let skipMarkdown = `**Skip if:**\n`;
+        for (const expr of skipInput) {
+            const skAst = buildAstFromInput(expr);
+            const skBlock = CompileToMarkdownForSkip(skAst, 
+            /*topLevel*/ false, 
+            /*depth*/ 2, 
+            /*forNot*/ false);
+            skipMarkdown += `\n${skBlock}`;
         }
-        const blockSkip = addTabToMarkdown(addBlockquoteToMarkdown(skipMarkdown));
+        // ✅ Render the skip section with Mustache so {{{attr}}} etc. interpolate
+        const renderedSkip = Mustache.render(skipMarkdown, ConvertArrayToStringsInTestObject(variableValues));
+        const blockSkip = addBlockquoteToMarkdown(renderedSkip);
         finalReturn += `\n\n${blockSkip}`;
     }
     return finalReturn;

package/dist/generator/generators/javascript/js-generator.d.ts

@@ -0,0 +1,19 @@
+import { CodeGenerator, CodeGeneratorProps } from "../classes/abstract-generator.js";
+export declare class JavascriptGenerator extends CodeGenerator {
+    private tempTsPath;
+    constructor(validationConfig: any, errorCodes: any[], rootPath?: string);
+    generateSessionDataCode: () => Promise<never>;
+    generateValidationCode: () => Promise<void>;
+    generateCode: (codeConfig: CodeGeneratorProps) => Promise<void>;
+    private createTsConfig;
+    private compileToJavaScript;
+    private processGeneratedFiles;
+    private copyAndProcessJsFiles;
+    private copyTypeDefinitions;
+    private processJavaScriptImports;
+    private processTypeDefinitionImports;
+    private getAllFiles;
+    private generatePackageJson;
+    private runCommand;
+    private cleanup;
+}

package/dist/generator/generators/javascript/js-generator.js

@@ -0,0 +1,215 @@
+import path from "path";
+import { fileURLToPath } from "url";
+import { CodeGenerator, } from "../classes/abstract-generator.js";
+import { writeAndFormatCode } from "../../../utils/fs-utils.js";
+import { TypescriptGenerator } from "../typescript/ts-generator.js";
+import logger from "../../../utils/logger.js";
+import fs from "fs-extra";
+import { MarkdownDocGenerator } from "../documentation/md-generator.js";
+import { exec } from "child_process";
+import { promisify } from "util";
+const execAsync = promisify(exec);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export class JavascriptGenerator extends CodeGenerator {
+    constructor(validationConfig, errorCodes, rootPath = "./") {
+        super(validationConfig, errorCodes, rootPath);
+        this.generateSessionDataCode = async () => {
+            throw new Error("Method not implemented.");
+        };
+        this.generateValidationCode = async () => {
+            // This will be handled by the TypeScript generator in generateCode
+        };
+        this.generateCode = async (codeConfig) => {
+            try {
+                logger.info("Generating JavaScript code using TypeScript compilation...");
+                // Step 1: Generate TypeScript code in a temporary directory
+                logger.debug("Step 1: Generating TypeScript code in temp directory");
+                await fs.ensureDir(this.tempTsPath);
+                const tsGenerator = new TypescriptGenerator(this.validationConfig, this.errorCodes, this.tempTsPath);
+                await tsGenerator.generateCode(codeConfig);
+                // Step 2: Create tsconfig.json for compilation
+                logger.debug("Step 2: Creating TypeScript configuration");
+                await this.createTsConfig();
+                // Step 3: Install TypeScript if not available and compile
+                logger.debug("Step 3: Compiling TypeScript to JavaScript");
+                await this.compileToJavaScript();
+                // Step 4: Copy and modify generated files
+                logger.debug("Step 4: Processing generated files");
+                await this.processGeneratedFiles();
+                // Step 5: Generate package.json
+                logger.debug("Step 5: Creating package.json");
+                await this.generatePackageJson(codeConfig.codeName);
+                // Step 6: Generate documentation
+                logger.debug("Step 6: Generating documentation");
+                await new MarkdownDocGenerator(this.validationConfig, this.errorCodes, this.rootPath).generateCode();
+                // Step 7: Clean up temporary files
+                logger.debug("Step 7: Cleaning up temporary files");
+                await this.cleanup();
+                logger.info("JavaScript code generation completed successfully");
+            }
+            catch (error) {
+                logger.error("Error during JavaScript code generation:", error);
+                await this.cleanup(); // Ensure cleanup even on error
+                throw error;
+            }
+        };
+        this.tempTsPath = path.resolve(rootPath, "../temp-ts-generation");
+    }
+    async createTsConfig() {
+        const tsConfig = {
+            compilerOptions: {
+                target: "ES2020",
+                module: "ESNext",
+                moduleResolution: "node",
+                declaration: true,
+                outDir: "./js-output",
+                rootDir: ".",
+                strict: false,
+                esModuleInterop: true,
+                allowSyntheticDefaultImports: true,
+                skipLibCheck: true,
+                forceConsistentCasingInFileNames: true,
+                allowJs: true,
+                noEmitOnError: false,
+                removeComments: false,
+            },
+            include: ["./**/*.ts"],
+            exclude: ["node_modules", "./js-output"],
+        };
+        await writeAndFormatCode(this.tempTsPath, "tsconfig.json", JSON.stringify(tsConfig, null, 2), "json");
+    }
+    async compileToJavaScript() {
+        logger.debug("Compiling TypeScript to JavaScript...");
+        try {
+            // Try using npx tsc first
+            await this.runCommand("npx tsc", this.tempTsPath);
+        }
+        catch (error) {
+            // If npx tsc fails, try to install TypeScript locally and retry
+            logger.info("TypeScript compilation failed, installing TypeScript...");
+            await this.runCommand("npm init -y", this.tempTsPath);
+            await this.runCommand("npm install --save-dev typescript", this.tempTsPath);
+            await this.runCommand("npx tsc", this.tempTsPath);
+        }
+    }
+    async processGeneratedFiles() {
+        const jsOutputPath = path.resolve(this.tempTsPath, "js-output");
+        // Ensure the target directory exists
+        await fs.ensureDir(this.rootPath);
+        // Copy all .js files and modify imports
+        await this.copyAndProcessJsFiles(jsOutputPath, this.rootPath);
+        // Copy all .d.ts files
+        await this.copyTypeDefinitions(jsOutputPath, this.rootPath);
+    }
+    async copyAndProcessJsFiles(sourceDir, targetDir) {
+        if (!(await fs.pathExists(sourceDir))) {
+            throw new Error(`Source directory ${sourceDir} does not exist`);
+        }
+        const files = await this.getAllFiles(sourceDir, ".js");
+        for (const file of files) {
+            const relativePath = path.relative(sourceDir, file);
+            const targetFile = path.resolve(targetDir, relativePath);
+            let content = await fs.readFile(file, "utf-8");
+            // Convert TypeScript-style imports to work better with JavaScript
+            content = this.processJavaScriptImports(content);
+            await fs.ensureDir(path.dirname(targetFile));
+            await fs.writeFile(targetFile, content);
+        }
+    }
+    async copyTypeDefinitions(sourceDir, targetDir) {
+        if (!(await fs.pathExists(sourceDir))) {
+            logger.warn(`Type definitions source directory ${sourceDir} does not exist`);
+            return;
+        }
+        const files = await this.getAllFiles(sourceDir, ".d.ts");
+        for (const file of files) {
+            const relativePath = path.relative(sourceDir, file);
+            const targetFile = path.resolve(targetDir, relativePath);
+            let content = await fs.readFile(file, "utf-8");
+            // Process .d.ts imports
+            content = this.processTypeDefinitionImports(content);
+            await fs.ensureDir(path.dirname(targetFile));
+            await fs.writeFile(targetFile, content);
+        }
+    }
+    processJavaScriptImports(content) {
+        // For ES modules, we need to keep the .js extensions in imports
+        // But fix the .js.js issue if it occurs
+        return content
+            .replace(/\.js\.js/g, ".js")
+            .replace(/from\s+["']([^"']+)\.ts["']/g, "from '$1.js'")
+            .replace(/import\s+["']([^"']+)\.ts["']/g, "import '$1.js'");
+    }
+    processTypeDefinitionImports(content) {
+        // Fix TypeScript imports in .d.ts files
+        return content
+            .replace(/from\s+["']([^"']+)\.ts["']/g, "from '$1'")
+            .replace(/import\s+["']([^"']+)\.ts["']/g, "import '$1'")
+            .replace(/\.js\.js/g, ".js");
+    }
+    async getAllFiles(dir, extension) {
+        const files = [];
+        if (!(await fs.pathExists(dir))) {
+            return files;
+        }
+        const items = await fs.readdir(dir, { withFileTypes: true });
+        for (const item of items) {
+            const fullPath = path.resolve(dir, item.name);
+            if (item.isDirectory()) {
+                const subFiles = await this.getAllFiles(fullPath, extension);
+                files.push(...subFiles);
+            }
+            else if (item.isFile() && item.name.endsWith(extension)) {
+                files.push(fullPath);
+            }
+        }
+        return files;
+    }
+    async generatePackageJson(codeName) {
+        const packageJson = {
+            name: codeName.toLowerCase().replace(/[^a-z0-9-]/g, "-"),
+            version: "1.0.0",
+            description: `Generated validation library: ${codeName}`,
+            type: "module",
+            main: "index.js",
+            types: "index.d.ts",
+            scripts: {
+                test: 'echo "Error: no test specified" && exit 1',
+            },
+            dependencies: {
+                // Add any runtime dependencies your generated code needs
+                jsonpath: "^1.1.1",
+            },
+            keywords: ["validation", "api", "testing", "javascript", "ondc"],
+            author: "Generated by ONDC Code Generator",
+            license: "MIT",
+        };
+        await writeAndFormatCode(this.rootPath, "package.json", JSON.stringify(packageJson, null, 2), "json");
+    }
+    async runCommand(command, cwd) {
+        try {
+            const { stdout, stderr } = await execAsync(command, { cwd });
+            if (stderr && !stderr.includes("npm WARN")) {
+                logger.warn(`Command stderr: ${command}`, stderr);
+            }
+            return stdout;
+        }
+        catch (error) {
+            logger.error(`Command failed: ${command}`, error.message);
+            throw new Error(`Command failed: ${command}
+${error.message}`);
+        }
+    }
+    async cleanup() {
+        try {
+            if (await fs.pathExists(this.tempTsPath)) {
+                await fs.remove(this.tempTsPath);
+                logger.debug("Cleaned up temporary TypeScript files");
+            }
+        }
+        catch (error) {
+            logger.warn("Failed to clean up temporary files:", error);
+        }
+    }
+}

package/dist/generator/generators/javascript/js-native-generator.js

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

package/dist/index.js

@@ -15,22 +15,32 @@ export { ConfigCompiler };
 // 	);
 // 	const buildYaml = readFileSync(buildPath, "utf-8");
 // 	const valConfig = JSON.parse(readFileSync(valConfigPath, "utf-8"));
-// 	await compiler.initialize(buildYaml);
-// 	await compiler.generateCode(
+// 	// await compiler.initialize(buildYaml);
+// 	// 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/"
+// 	// );
+// 	// JavaScript generation example
+// 	const compilerJs = new ConfigCompiler(SupportedLanguages.Javascript);
+// 	await compilerJs.initialize(buildYaml);
+// 	await compilerJs.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/"
+// 		"./alpha/javascriptNative/"
 // 	);
 // };
 // (async () => {
 // 	await main();
+// 	console.log("========== Code generation completed. ==========");
 // })();

package/dist/services/return-complier/ast-functions/compile-to-markdown.d.ts

@@ -1,2 +1,24 @@
 import { AstNode } from "../ast.js";
-export declare function CompileToMarkdown(ast: AstNode, pointer: string, depth: number | undefined, forNot: boolean): string;
+/**
+ * Public API: Compile an AST to *readable* Markdown with:
+ * - No pointer numbering (no 1.1.1)
+ * - Natural language groups ("All of the following…" / "Any of these…")
+ * - Leaves rendered as short sentences
+ *
+ * @param ast
+ * @param topLevel Whether this is the very first group under the title
+ * @param depth    Controls bullet/indent
+ * @param forNot   Carries NOT (!) context downward
+ */
+export declare function CompileToMarkdown(ast: AstNode, topLevel?: boolean, depth?: number, forNot?: boolean): string;
+/**
+ * Skip-specific version: Compile an AST to *readable* Markdown for skip conditions with:
+ * - More natural language ("{{lhs}} is not in the payload" instead of "{{lhs}} must not be present")
+ * - Simpler phrasing suitable for skip conditions
+ *
+ * @param ast
+ * @param topLevel Whether this is the very first group under the title
+ * @param depth    Controls bullet/indent
+ * @param forNot   Carries NOT (!) context downward
+ */
+export declare function CompileToMarkdownForSkip(ast: AstNode, topLevel?: boolean, depth?: number, forNot?: boolean): string;

package/dist/services/return-complier/ast-functions/compile-to-markdown.js

@@ -1,66 +1,133 @@
 import { AllIn, AnyIn, AreUnique, ArePresent, EqualTo, FollowRegex, GreaterThan, LessThan, NoneIn, } from "../tokens.js";
+/**
+ * Leaf (unary/binary) message templates, rewritten to be short & human-friendly.
+ * NOTE: We keep triple-mustaches so Mustache can expand safely.
+ */
 const uniaryMessages = {
-    [AreUnique.LABEL ?? "are unique"]: (variable, forNot) => `all values of {{{${variable}}}} must${forNot ? " **not**" : ""} be unique`,
-    [ArePresent.LABEL ?? "are present"]: (variable, forNot) => `{{{${variable}}}} must${forNot ? " **not**" : ""} be present in the payload`,
+    [AreUnique.LABEL ?? "are unique"]: (variable, forNot) => `All values of {{{${variable}}}} ${forNot ? "must **not** be unique" : "are unique"}`,
+    [ArePresent.LABEL ?? "are present"]: (variable, forNot) => `{{{${variable}}}} ${forNot ? "must **not** be present" : "must be present"} in the payload`,
+};
+/**
+ * Skip-specific message templates for more natural language in skip conditions
+ */
+const skipUniaryMessages = {
+    [AreUnique.LABEL ?? "are unique"]: (variable, forNot) => `{{{${variable}}}} values ${forNot ? "are not unique" : "are unique"}`,
+    [ArePresent.LABEL ?? "are present"]: (variable, forNot) => `{{{${variable}}}} ${forNot ? "is not in the payload" : "is in the payload"}`,
 };
 const binaryMessages = {
-    [AllIn.LABEL ?? "all in"]: (lhs, rhs, forNot) => `every element of {{{${lhs}}}} must${forNot ? " **not**" : ""} be in {{{${rhs}}}}`,
-    [AnyIn.LABEL ?? "any in"]: (lhs, rhs, forNot) => `at least one element of {{{${lhs}}}} must${forNot ? " **not**" : ""} be in {{{${rhs}}}}`,
-    [FollowRegex.LABEL ?? "follow regex"]: (lhs, rhs, forNot) => `all elements of {{{${lhs}}}} must${forNot ? " **not**" : ""} follow every regex in {{{${rhs}}}}`,
-    [NoneIn.LABEL ?? "none in"]: (lhs, rhs, forNot) => `no element of {{{${lhs}}}} must${forNot ? " **not**" : ""} be in {{{${rhs}}}}`,
-    [EqualTo.LABEL ?? "equal to"]: (lhs, rhs, forNot) => `{{{${lhs}}}} must${forNot ? " **not**" : ""} be equal to {{{${rhs}}}}`,
-    [GreaterThan.LABEL ?? "greater than"]: (lhs, rhs, forNot) => `{{{${lhs}}}} must${forNot ? " **not**" : ""} be greater than {{{${rhs}}}}`,
-    [LessThan.LABEL ?? "less than"]: (lhs, rhs, forNot) => `{{{${lhs}}}} must${forNot ? " **not**" : ""} be less than {{{${rhs}}}}`,
+    [AllIn.LABEL ?? "all in"]: (lhs, rhs, forNot) => `${forNot ? "Not all" : "All"} elements of {{{${lhs}}}} ${forNot ? "may be" : "must be"} in {{{${rhs}}}}`,
+    [AnyIn.LABEL ?? "any in"]: (lhs, rhs, forNot) => `${forNot ? "None of" : "At least one of"} {{{${lhs}}}} ${forNot ? "may be" : "must be"} in {{{${rhs}}}}`,
+    [FollowRegex.LABEL ?? "follow regex"]: (lhs, rhs, forNot) => `${forNot ? "Some elements of" : "All elements of"} {{{${lhs}}}} ${forNot ? "may fail to" : "must"} follow every regex in {{{${rhs}}}}`,
+    [NoneIn.LABEL ?? "none in"]: (lhs, rhs, forNot) => `${forNot ? "Some elements of" : "No element of"} {{{${lhs}}}} ${forNot ? "may be in" : "must be in"} {{{${rhs}}}}`,
+    [EqualTo.LABEL ?? "equal to"]: (lhs, rhs, forNot) => `{{{${lhs}}}} ${forNot ? "must **not** equal" : "must equal"} {{{${rhs}}}}`,
+    [GreaterThan.LABEL ?? "greater than"]: (lhs, rhs, forNot) => `{{{${lhs}}}} ${forNot ? "must **not** be greater than" : "must be greater than"} {{{${rhs}}}}`,
+    [LessThan.LABEL ?? "less than"]: (lhs, rhs, forNot) => `{{{${lhs}}}} ${forNot ? "must **not** be less than" : "must be less than"} {{{${rhs}}}}`,
+};
+/**
+ * Skip-specific binary message templates for more natural language in skip conditions
+ */
+const skipBinaryMessages = {
+    [AllIn.LABEL ?? "all in"]: (lhs, rhs, forNot) => `${forNot ? "not all" : "all"} elements of {{{${lhs}}}} are in {{{${rhs}}}}`,
+    [AnyIn.LABEL ?? "any in"]: (lhs, rhs, forNot) => `${forNot ? "none of" : "any of"} {{{${lhs}}}} are in {{{${rhs}}}}`,
+    [FollowRegex.LABEL ?? "follow regex"]: (lhs, rhs, forNot) => `{{{${lhs}}}} ${forNot ? "doesn't follow" : "follows"} regex {{{${rhs}}}}`,
+    [NoneIn.LABEL ?? "none in"]: (lhs, rhs, forNot) => `${forNot ? "some" : "none"} of {{{${lhs}}}} are in {{{${rhs}}}}`,
+    [EqualTo.LABEL ?? "equal to"]: (lhs, rhs, forNot) => `{{{${lhs}}}} ${forNot ? "is not equal to" : "equals"} {{{${rhs}}}}`,
+    [GreaterThan.LABEL ?? "greater than"]: (lhs, rhs, forNot) => `{{{${lhs}}}} ${forNot ? "is not greater than" : "is greater than"} {{{${rhs}}}}`,
+    [LessThan.LABEL ?? "less than"]: (lhs, rhs, forNot) => `{{{${lhs}}}} ${forNot ? "is not less than" : "is less than"} {{{${rhs}}}}`,
 };
-export function CompileToMarkdown(ast, pointer, depth = 0, forNot) {
-    const indent = "  ".repeat(depth); // 2 spaces per depth level
-    // Helper function to indent multi-line strings
-    function indentMultilineString(str, indentLevel) {
-        const subIndent = "  ".repeat(indentLevel);
-        return str
+/**
+ * Public API: Compile an AST to *readable* Markdown with:
+ * - No pointer numbering (no 1.1.1)
+ * - Natural language groups ("All of the following…" / "Any of these…")
+ * - Leaves rendered as short sentences
+ *
+ * @param ast
+ * @param topLevel Whether this is the very first group under the title
+ * @param depth    Controls bullet/indent
+ * @param forNot   Carries NOT (!) context downward
+ */
+export function CompileToMarkdown(ast, topLevel = true, depth = 0, forNot = false) {
+    return compileToMarkdownInternal(ast, topLevel, depth, forNot, false);
+}
+/**
+ * Skip-specific version: Compile an AST to *readable* Markdown for skip conditions with:
+ * - More natural language ("{{lhs}} is not in the payload" instead of "{{lhs}} must not be present")
+ * - Simpler phrasing suitable for skip conditions
+ *
+ * @param ast
+ * @param topLevel Whether this is the very first group under the title
+ * @param depth    Controls bullet/indent
+ * @param forNot   Carries NOT (!) context downward
+ */
+export function CompileToMarkdownForSkip(ast, topLevel = true, depth = 0, forNot = false) {
+    return compileToMarkdownInternal(ast, topLevel, depth, forNot, true);
+}
+/**
+ * Internal implementation shared by both CompileToMarkdown and CompileToMarkdownForSkip
+ */
+function compileToMarkdownInternal(ast, topLevel = true, depth = 0, forNot = false, isSkip = false) {
+    const indent = "  ".repeat(depth);
+    // Render a group label (AND/OR) with correct style.
+    function groupLabel(isAnd, asBullet, indentStr) {
+        const label = isAnd
+            ? "**All of the following must be true:**"
+            : "**Any of these must be true:**";
+        return asBullet ? `${indentStr}- ${label}` : `${indentStr}${label}`;
+    }
+    // Ensure each line in a block is indented (used for nested groups).
+    function indentBlock(block, extraDepth = 1) {
+        const pad = "  ".repeat(extraDepth);
+        return block
             .split("\n")
-            .map((line) => subIndent + line)
+            .map((l) => (l.length ? pad + l : l))
             .join("\n");
     }
+    // RETURN: just compile its expression at same depth/topLevel
     if (ast.type === "returnStatement") {
-        const returnStatement = ast;
-        const generated = CompileToMarkdown(returnStatement.expression, `${pointer}`, depth, forNot);
-        return `${generated}`;
+        const ret = ast;
+        return compileToMarkdownInternal(ret.expression, topLevel, depth, forNot, isSkip);
     }
+    // AND / OR group
     if (ast.type === "binaryOperator") {
-        const binary = ast;
-        const subMdLhs = CompileToMarkdown(binary.lhs, getNextPointer(pointer, 1), depth + 1, forNot);
-        const subMdRhs = CompileToMarkdown(binary.rhs, getNextPointer(pointer, 2), depth + 1, forNot);
-        const indentedSubMdLhs = indentMultilineString(subMdLhs, 0); // LHS already indented
-        const indentedSubMdRhs = indentMultilineString(subMdRhs, 0); // RHS already indented
-        if (binary.operator === "&&") {
-            return `${indent}- **condition ${pointer}**: all of the following sub conditions must${forNot ? "**not**" : ""} be met:\n\n${indentedSubMdLhs}\n${indentedSubMdRhs}`;
+        const { operator, lhs, rhs } = ast;
+        const isAnd = operator === "&&";
+        const labelLine = groupLabel(isAnd, !topLevel, indent);
+        // Render children as bullet items (no numbering)
+        const leftRendered = compileToMarkdownInternal(lhs, false, depth + 1, forNot, isSkip);
+        const rightRendered = compileToMarkdownInternal(rhs, false, depth + 1, forNot, isSkip);
+        // If top-level group: label as standalone line, then list items
+        // If nested: label as bullet, then nested bullets further indented
+        if (topLevel) {
+            return [labelLine, leftRendered, rightRendered].join("\n");
         }
-        if (binary.operator === "||") {
-            return `${indent}- **condition ${pointer}**: any one of the following sub conditions must${forNot ? "**not**" : ""} be met:\n\n${indentedSubMdLhs}\n${indentedSubMdRhs}`;
+        else {
+            return [labelLine, leftRendered, rightRendered].join("\n");
         }
     }
+    // NOT
     if (ast.type === "notOperator") {
         const not = ast;
-        return CompileToMarkdown(not.expression, pointer, depth, !forNot);
+        return compileToMarkdownInternal(not.expression, topLevel, depth, !forNot, isSkip);
     }
+    // LEAVES (unary / binary custom functions)
     if (ast.type === "customUniaryFunction") {
-        const customFunction = ast;
-        const func = customFunction.customFunction;
-        const messageFunction = uniaryMessages[func];
-        const lhs = customFunction.expression;
-        return `${indent}- **condition ${pointer}**: ${messageFunction(lhs.name, forNot)}`;
+        const custom = ast;
+        const fn = custom.customFunction;
+        const lhs = custom.expression;
+        const msgFn = isSkip
+            ? skipUniaryMessages[fn]
+            : uniaryMessages[fn];
+        return `${indent}- ${msgFn(lhs.name, forNot)}`;
     }
     if (ast.type === "customBinaryFunction") {
-        const customFunction = ast;
-        const func = customFunction.customFunction;
-        const messageFunction = binaryMessages[func];
-        const lhs = customFunction.lhs;
-        const rhs = customFunction.rhs;
-        return `${indent}- **condition ${pointer}**: ${messageFunction(lhs.name, rhs.name, forNot)}`;
+        const custom = ast;
+        const fn = custom.customFunction;
+        const lhs = custom.lhs;
+        const rhs = custom.rhs;
+        const msgFn = isSkip
+            ? skipBinaryMessages[fn]
+            : binaryMessages[fn];
+        return `${indent}- ${msgFn(lhs.name, rhs.name, forNot)}`;
     }
     throw new Error("Invalid AST node:" + JSON.stringify(ast));
 }
-function getNextPointer(currentPointer, nextIndex) {
-    return `${currentPointer}.${nextIndex}`;
-}

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

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

package/dist/types/compiler-types.js

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

package/dist/utils/logger.js

@@ -31,6 +31,7 @@ const logLevel = process.env.NODE_ENV === "production" ? "info" : "debug";
 // Configure Winston logger
 const logger = winston.createLogger({
     level: logLevel,
+    silent: true,
     format: combine(timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), errors({ stack: true }), // Include stack trace in error messages
     logFormat),
     transports: [

package/package.json

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