ondc-code-generator 0.8.9 → 1.0.0

package/dist/bin/cli.js

@@ -126,6 +126,10 @@ function getSupportedLanguage(lang) {
             return SupportedLanguages.Golang;
         case "md":
             return SupportedLanguages.Markdown;
+        case "rag":
+            return SupportedLanguages.RAG;
+        case "rag_table":
+            return SupportedLanguages.RAG_TABLE;
         default:
             throw new Error(`Unsupported language: ${lang}. Supported languages are: ${getValidLanguageOptions()}`);
     }

package/dist/generator/config-compiler.d.ts

@@ -15,15 +15,29 @@ export declare class ConfigCompiler {
     errorDefinitions: ErrorDefinition[] | undefined;
     generatorConfig: CodeGeneratorConfig | undefined;
     language: SupportedLanguages;
+    domain?: string | string[];
+    version?: string;
     private SchemaExtractionService;
     constructor(language: SupportedLanguages);
     initialize: (buildYaml: string, generatorConfig?: Partial<CodeGeneratorConfig>) => Promise<void>;
     performValidations: (valConfig: ValidationConfig) => Promise<void>;
     withMinimalValidations: (valConfig: ValidationConfig) => Promise<void>;
-    generateCode: (valConfig: ValidationConfig, codeName?: string, minimal?: boolean, outputPath?: string, absolutePath?: boolean, goPackageName?: string) => Promise<void>;
+    generateCode: (valConfig: ValidationConfig, codeGenConfig?: CodeGenConfig | string) => Promise<void>;
     generateL0Schema: (outputPath?: string, type?: "json" | "typescript", absolutePath?: boolean) => Promise<void>;
     generateValidPaths: () => Promise<Record<string, string[]>>;
-    generateValidationFromBuild: (codeName: string, outputPath: string, absolutePath?: boolean, goPackageName?: string) => Promise<void>;
+    generateValidationFromBuild: (codeGenConfig: CodeGenConfig | string, outputPath?: string, absolutePath?: boolean, goPackageName?: string) => Promise<void>;
     extractPayloadsFromBuild: (outputPath: string) => Promise<void>;
 }
+export type CodeGenConfig = {
+    codeName: string;
+    goPkgName?: string;
+    domain?: string | string[];
+    version?: string;
+    /** Skip full path/enum validations and run minimal checks only. Default: false */
+    minimal?: boolean;
+    /** Base output directory. Default: "./" */
+    outputPath?: string;
+    /** Treat outputPath as absolute (skip prepending "generated/<codeName>"). Default: false */
+    absolutePath?: boolean;
+};
 export {};

package/dist/generator/config-compiler.js

@@ -13,6 +13,8 @@ import { PythonGenerator } from "./generators/python/py-generator.js";
 import { JavascriptGenerator } from "./generators/javascript/js-generator.js";
 import { GoGenerator } from "./generators/go/go-generator.js";
 import { MarkdownDocGenerator } from "./generators/documentation/md-generator.js";
+import { RagGenerator } from "./generators/rag/rag-generator.js";
+import { RagTableGenerator } from "./generators/rag/rag-table-generator.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const defaultConfig = {
@@ -32,9 +34,10 @@ export class ConfigCompiler {
                 this.SchemaExtractionService.extractPossiblePaths(this.jsonSchemas);
             const errors = this.buildData["x-errorcodes"];
             this.errorDefinitions = errors.code;
+            this.domain = this.buildData.info?.domain;
+            this.version = this.buildData.info?.version;
         };
         this.performValidations = async (valConfig) => {
-            // try {
             if (!this.buildData)
                 throw new Error("Build data not initialized");
             if (!this.jsonSchemas)
@@ -44,22 +47,19 @@ export class ConfigCompiler {
             if (!this.errorDefinitions)
                 throw new Error("Error definitions not initialized");
             await new ConfigValidator("", valConfig, this.possibleJsonPaths, this.errorDefinitions).validate();
-            // } catch (e) {
-            // 	logger.error(e);
-            // 	throw new Error(e as any);
-            // }
         };
         this.withMinimalValidations = async (valConfig) => {
-            // try {
             await new ConfigValidator("", valConfig, {}, [], {
                 minimal: true,
             }).validate();
-            // } catch (e) {
-            // logger.error(e);
-            // throw new Error("validation failed");
         };
-        // };
-        this.generateCode = async (valConfig, codeName = "L1-Validations", minimal = false, outputPath = "./", absolutePath = false, goPackageName = "validationpkg") => {
+        this.generateCode = async (valConfig, codeGenConfig = "L1-Validations") => {
+            // Accept either the new CodeGenConfig object or the legacy positional
+            // string (codeName) so existing call-sites continue to work.
+            const config = typeof codeGenConfig === "string"
+                ? { codeName: codeGenConfig }
+                : codeGenConfig;
+            const { codeName = "L1-Validations", goPkgName = "validationpkg", minimal = false, outputPath = "./", absolutePath = false, domain = this.domain, version = this.version, } = config;
             try {
                 console.log("[ CODE GENERATION ] Starting code generation...");
                 valConfig = JSON.parse(JSON.stringify(valConfig));
@@ -80,26 +80,52 @@ export class ConfigCompiler {
                     case SupportedLanguages.Typescript:
                         await new TypescriptGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode({
                             codeName: codeName,
+                            domain: domain,
+                            version: version,
                         });
                         break;
                     case SupportedLanguages.Python:
                         await new PythonGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode({
                             codeName: codeName,
+                            domain: domain,
+                            version: version,
                         });
                         break;
                     case SupportedLanguages.Javascript:
                         await new JavascriptGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode({
                             codeName: codeName,
+                            domain: domain,
+                            version: version,
                         });
                         break;
                     case SupportedLanguages.Golang:
                         await new GoGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode({
                             codeName: codeName,
-                            goPkgName: goPackageName,
+                            goPkgName: goPkgName,
+                            domain: domain,
+                            version: version,
                         });
                         break;
                     case SupportedLanguages.Markdown:
-                        await new MarkdownDocGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode();
+                        await new MarkdownDocGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode({
+                            codeName: codeName,
+                            domain: domain,
+                            version: version,
+                        });
+                        break;
+                    case SupportedLanguages.RAG:
+                        await new RagGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode({
+                            codeName: codeName,
+                            domain: domain,
+                            version: version,
+                        });
+                        break;
+                    case SupportedLanguages.RAG_TABLE:
+                        await new RagTableGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode({
+                            codeName: codeName,
+                            domain: domain,
+                            version: version,
+                        });
                         break;
                     default:
                         throw new Error("Language not supported");
@@ -144,19 +170,31 @@ export class ConfigCompiler {
         this.generateValidPaths = async () => {
             if (!this.possibleJsonPaths)
                 throw new Error("Possible paths not initialized");
-            // writeFileSync(
-            // 	"./validPaths.json",
-            // 	JSON.stringify(this.possibleJsonPaths, null, 2)
-            // );
             return this.possibleJsonPaths;
         };
-        this.generateValidationFromBuild = async (codeName, outputPath, absolutePath = false, goPackageName = "validationpkg") => {
+        this.generateValidationFromBuild = async (codeGenConfig, outputPath, absolutePath, goPackageName) => {
             if (!this.buildData)
                 throw new Error("Build data not initialized");
             const valConfig = this.buildData["x-validations"];
             if (!valConfig)
                 throw new Error("No validation config found in build data");
-            await this.generateCode(valConfig, codeName, false, outputPath, absolutePath, goPackageName);
+            // Support legacy positional call: (codeName, outputPath, absolutePath, goPkgName)
+            const config = typeof codeGenConfig === "string"
+                ? {
+                    codeName: codeGenConfig,
+                    outputPath: outputPath ?? "./",
+                    absolutePath: absolutePath ?? false,
+                    goPkgName: goPackageName ?? "validationpkg",
+                    domain: this.buildData.info?.domain,
+                    version: this.buildData.info?.version,
+                }
+                : {
+                    ...codeGenConfig,
+                    domain: codeGenConfig.domain ?? this.buildData?.info?.domain,
+                    version: codeGenConfig.version ??
+                        this.buildData?.info?.version,
+                };
+            await this.generateCode(valConfig, config);
         };
         this.extractPayloadsFromBuild = async (outputPath) => {
             if (!this.buildData)

package/dist/generator/generators/classes/abstract-generator.d.ts

@@ -3,6 +3,8 @@ import { ErrorDefinition } from "../../../types/error-codes";
 export type CodeGeneratorProps = {
     codeName: string;
     goPkgName?: string;
+    domain?: string | string[];
+    version?: string;
 };
 export declare abstract class CodeGenerator {
     validationConfig: ValidationConfig;

package/dist/generator/generators/documentation/md-generator.d.ts

@@ -1,10 +1,17 @@
-import { TestObject } from "../../../types/config-types.js";
-import { CodeGenerator } from "../classes/abstract-generator.js";
+import { CodeGenerator, CodeGeneratorProps } from "../classes/abstract-generator.js";
+/**
+ * MarkdownDocGenerator — generates a readme.md and a styled index.html
+ * for a validation config, reusing RagTableGenerator for the table layout.
+ *
+ * Output:
+ *   ./readme.md          — concatenated GFM table markdown for all actions
+ *   ./page/index.html    — the same content rendered to HTML with a stylesheet
+ *   ./page/style.css     — stylesheet
+ */
 export declare class MarkdownDocGenerator extends CodeGenerator {
     generateSessionDataCode(): Promise<void>;
     generateUnitTestingCode(): Promise<void>;
+    codeConfig: CodeGeneratorProps | undefined;
     generateValidationCode: () => Promise<void>;
-    generateCode: () => Promise<void>;
-    generateMarkdownForTest: (testObject: TestObject) => string;
-    generateHtmlCode: (markdownData: string) => Promise<string>;
+    generateCode: (codeConfig: CodeGeneratorProps) => Promise<void>;
 }

package/dist/generator/generators/documentation/md-generator.js

@@ -1,55 +1,50 @@
-import { ConfigSyntax, TestObjectSyntax } from "../../../constants/syntax.js";
-import { CodeGenerator } from "../classes/abstract-generator.js";
-import { markdownMessageGenerator } from "./markdown-message-generator.js";
+import { ConfigSyntax } from "../../../constants/syntax.js";
+import { CodeGenerator, } from "../classes/abstract-generator.js";
 import { writeFileWithFsExtra } from "../../../utils/fs-utils.js";
 import { marked } from "marked";
 import Mustache from "mustache";
 import { readFileSync } from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
-import { addTabToMarkdown } from "../../../utils/general-utils/string-utils.js";
+import { RagTableGenerator } from "../rag/rag-table-generator.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
+/**
+ * MarkdownDocGenerator — generates a readme.md and a styled index.html
+ * for a validation config, reusing RagTableGenerator for the table layout.
+ *
+ * Output:
+ *   ./readme.md          — concatenated GFM table markdown for all actions
+ *   ./page/index.html    — the same content rendered to HTML with a stylesheet
+ *   ./page/style.css     — stylesheet
+ */
 export class MarkdownDocGenerator extends CodeGenerator {
     constructor() {
         super(...arguments);
         this.generateValidationCode = async () => {
             const testConfig = this.validationConfig[ConfigSyntax.Tests];
+            // Reuse RagTableGenerator's table builder — same config, same error codes
+            const tableGen = new RagTableGenerator(this.validationConfig, this.errorCodes, this.rootPath);
+            // Build one GFM table section per action and concatenate
             let finalMarkdown = "";
-            for (const key in testConfig) {
-                const testObjects = testConfig[key];
-                const betaConfig = {
-                    [TestObjectSyntax.Name]: key,
-                    [TestObjectSyntax.Return]: testObjects,
-                };
-                const md = this.generateMarkdownForTest(betaConfig);
-                finalMarkdown += `\n\n${md}`;
+            for (const action of Object.keys(testConfig)) {
+                const section = tableGen.buildActionMarkdown(action, action, // use action name as codeName heading inside the doc
+                testConfig[action], this.codeConfig);
+                finalMarkdown += `\n\n${section}`;
             }
+            finalMarkdown = finalMarkdown.trimStart();
             const cssData = readFileSync(path.resolve(__dirname, "./templates/style.css"), "utf-8");
             const htmlTemplate = readFileSync(path.resolve(__dirname, "./templates/index.mustache"), "utf-8");
             writeFileWithFsExtra(this.rootPath, "./readme.md", finalMarkdown);
             writeFileWithFsExtra(this.rootPath, "./page/index.html", Mustache.render(htmlTemplate, {
-                content: await this.generateHtmlCode(finalMarkdown),
+                content: await marked(finalMarkdown),
             }));
             writeFileWithFsExtra(this.rootPath, "./page/style.css", cssData);
         };
-        this.generateCode = async () => {
+        this.generateCode = async (codeConfig) => {
+            this.codeConfig = codeConfig; // store for use in generateValidationCode
             await this.generateValidationCode();
         };
-        this.generateMarkdownForTest = (testObject) => {
-            const ret = testObject[TestObjectSyntax.Return];
-            if (typeof ret === "string") {
-                const skip = testObject[TestObjectSyntax.Continue];
-                return markdownMessageGenerator(ret, testObject, testObject[TestObjectSyntax.Name], skip ? [skip] : undefined);
-            }
-            const subMardowns = ret.map((r) => {
-                return this.generateMarkdownForTest(r);
-            });
-            return `- **${testObject[TestObjectSyntax.Name]}** : All the following sub conditions must pass as per the api requirement\n\n${addTabToMarkdown(subMardowns.join("\n\n"))}`;
-        };
-        this.generateHtmlCode = async (markdownData) => {
-            return await marked(markdownData);
-        };
     }
     generateSessionDataCode() {
         throw new Error("Method not implemented.");

package/dist/generator/generators/documentation/templates/index.mustache

@@ -1,36 +1,172 @@
 <!DOCTYPE html>
 <html lang="en">
 <head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>API SERVICE VALIDATIONS</title>
-    <!-- Link to the CSS file -->
-    <link rel="stylesheet" href="./style.css">
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>API Validations</title>
+  <link rel="stylesheet" href="./style.css">
 </head>
 <body>
-    <div id="content">
-        <h2>List of validations of api</h2>
-        {{{content}}}
+
+<header class="top-bar">
+  <span class="logo">&#9724; ONDC Validations</span>
+  <div class="toolbar">
+    <div class="search-wrap">
+      <svg class="search-icon" viewBox="0 0 20 20" fill="none">
+        <circle cx="8.5" cy="8.5" r="5.5" stroke="currentColor" stroke-width="1.8"/>
+        <path d="M13 13l3.5 3.5" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"/>
+      </svg>
+      <input id="search" type="text" placeholder="Search tests, descriptions, error codes&hellip;" autocomplete="off">
+      <button id="clear-search" class="clear-btn hidden">&times;</button>
     </div>
-</body>
+    <div class="filter-group" id="type-filter">
+      <button class="pill active" data-type="all">All</button>
+      <button class="pill" data-type="group">GRP - Groups</button>
+      <button class="pill" data-type="leaf">LF - Tests</button>
+    </div>
+  </div>
+</header>
+
+<div class="layout">
+  <nav id="sidebar">
+    <p class="nav-heading">Actions</p>
+    <!-- populated by JS -->
+  </nav>
+
+  <main id="content">
+    {{{content}}}
+  </main>
+</div>
+
+<div id="match-count" class="hidden"></div>
+
 <script>
-    document.addEventListener('DOMContentLoaded', function() {
-        // Select all list items that have a nested <ul> (collapsible items)
-        const collapsibleItems = document.querySelectorAll('li > ul');
-
-        collapsibleItems.forEach(function(nestedList) {
-            const parentLi = nestedList.parentElement;
-            parentLi.classList.add('collapsible', 'collapsed');
-
-            // Add click event listener to the <p> inside the list item
-            const clickableArea = parentLi.querySelector('p');
-            clickableArea.addEventListener('click', function(e) {
-                // Prevent click events on links inside the <p>
-                if (e.target.tagName !== 'A') {
-                    parentLi.classList.toggle('collapsed');
-                }
-            });
-        });
+(function () {
+
+  /* ── 1. Strip YAML front-matter bleed-through ─────────────────────────
+     marked renders --- as <hr> and the key:value block as <h2>           */
+  document.querySelectorAll('#content hr').forEach(hr => {
+    const sib = hr.nextElementSibling;
+    if (sib && sib.tagName === 'H2' &&
+        /action:|codeName:|numTests:|generated:/.test(sib.textContent)) {
+      const trailingHr = sib.nextElementSibling;
+      if (trailingHr && trailingHr.tagName === 'HR') trailingHr.remove();
+      sib.remove();
+      hr.remove();
+    }
+  });
+
+  /* ── 2. Build sidebar nav from h1 headings ────────────────────────── */
+  const nav = document.getElementById('sidebar');
+  document.querySelectorAll('#content h1').forEach((h1, i) => {
+    const id = 'section-' + i;
+    h1.id = id;
+    const link = document.createElement('a');
+    link.href = '#' + id;
+    const match = h1.textContent.match(/`([^`]+)`/);
+    link.textContent = match ? match[1] : h1.textContent.slice(0, 28);
+    link.addEventListener('click', () => {
+      nav.querySelectorAll('a').forEach(a => a.classList.remove('active'));
+      link.classList.add('active');
     });
+    nav.appendChild(link);
+  });
+
+  /* ── 3. Tag every table body row with data attributes ─────────────── */
+  document.querySelectorAll('table tbody tr').forEach(row => {
+    const typeCell = row.cells[1];
+    if (!typeCell) return;
+    row.dataset.rowtype = typeCell.textContent.includes('GRP') ? 'group' : 'leaf';
+    row.dataset.text = row.textContent.toLowerCase();
+    /* cache original inner HTML of each cell for highlight restore */
+    Array.from(row.cells).forEach(td => { td.dataset.raw = td.innerHTML; });
+  });
+
+  /* ── 4. Shared filter function ────────────────────────────────────── */
+  const searchInput = document.getElementById('search');
+  const clearBtn    = document.getElementById('clear-search');
+  const countEl     = document.getElementById('match-count');
+  let activeType = 'all';
+
+  function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  }
+
+  function applyFilters() {
+    const q = searchInput.value.trim().toLowerCase();
+    clearBtn.classList.toggle('hidden', q === '');
+    let visible = 0, total = 0;
+
+    document.querySelectorAll('table tbody tr').forEach(row => {
+      const typeOk = activeType === 'all' || row.dataset.rowtype === activeType;
+      const textOk = q === '' || (row.dataset.text || '').includes(q);
+      const show   = typeOk && textOk;
+      row.style.display = show ? '' : 'none';
+      if (show) visible++;
+      total++;
+
+      /* inline search highlight */
+      Array.from(row.cells).forEach(td => {
+        if (!td.dataset.raw) return;
+        if (q === '') {
+          td.innerHTML = td.dataset.raw;
+        } else {
+          td.innerHTML = td.dataset.raw.replace(
+            new RegExp('(' + escapeRe(q) + ')', 'gi'),
+            '<mark>$1</mark>'
+          );
+        }
+      });
+    });
+
+    const filtered = q !== '' || activeType !== 'all';
+    countEl.textContent = filtered ? visible + ' / ' + total + ' rows shown' : '';
+    countEl.classList.toggle('hidden', !filtered);
+  }
+
+  searchInput.addEventListener('input', applyFilters);
+  clearBtn.addEventListener('click', () => {
+    searchInput.value = '';
+    applyFilters();
+    searchInput.focus();
+  });
+
+  /* ── 5. Type filter pills ─────────────────────────────────────────── */
+  document.querySelectorAll('#type-filter .pill').forEach(btn => {
+    btn.addEventListener('click', () => {
+      document.querySelectorAll('#type-filter .pill')
+              .forEach(b => b.classList.remove('active'));
+      btn.classList.add('active');
+      activeType = btn.dataset.type;
+      applyFilters();
+    });
+  });
+
+  /* ── 6. Keyboard shortcut: / to focus search ─────────────────────── */
+  document.addEventListener('keydown', e => {
+    if (e.key === '/' && document.activeElement !== searchInput) {
+      e.preventDefault();
+      searchInput.focus();
+    }
+    if (e.key === 'Escape') {
+      searchInput.value = '';
+      applyFilters();
+      searchInput.blur();
+    }
+  });
+
+  /* ── 7. Highlight active section on scroll ────────────────────────── */
+  const observer = new IntersectionObserver(entries => {
+    entries.forEach(e => {
+      if (e.isIntersecting) {
+        nav.querySelectorAll('a').forEach(a =>
+          a.classList.toggle('active', a.getAttribute('href') === '#' + e.target.id));
+      }
+    });
+  }, { threshold: 0.5 });
+  document.querySelectorAll('#content h1').forEach(h => observer.observe(h));
+
+})();
 </script>
+</body>
 </html>