ondc-code-generator 0.5.42 → 0.5.51

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-native-generator.js

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

package/dist/index.js

@@ -42,5 +42,5 @@ export { ConfigCompiler };
 // };
 // (async () => {
 // 	await main();
-// 	console.log("Code generation completed.");
+// 	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/package.json

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