ondc-code-generator 0.7.0 → 0.7.4

package/README.md

@@ -190,3 +190,9 @@ await comp.initialize(buildString);
 const x_validations = JSON.parse(buildString)["x-validations"] as any;
 await comp.generateCode(x_validations, "L1-validations"); // pass the validations object and the name of the function of the generated code
 ```
+
+## scripts:
+
+```
+node ./dist/bin/cli.js xval -c "./samples/build.yaml" -o "./alpha/" -l "go"
+```

package/dist/bin/cli-tool.d.ts

@@ -0,0 +1,70 @@
+import chalkLib from "chalk";
+/** Color variants for different message types */
+export declare enum CliVariant {
+    INFO = "info",
+    SUCCESS = "success",
+    WARNING = "warning",
+    ERROR = "error",
+    DEBUG = "debug",
+    SUBTLE = "subtle",
+    PRIMARY = "primary",
+    SECONDARY = "secondary"
+}
+/** Multiline-safe padding config */
+export type CliPadding = {
+    top?: number;
+    bottom?: number;
+    left?: number;
+};
+export type TitleOptions = {
+    indentation?: number;
+    padding?: CliPadding;
+    badge?: string | null;
+};
+export type SkipOptions = {
+    indentation?: number;
+    reasonLabel?: string;
+};
+export type DescriptionOptions = {
+    indentation?: number;
+    padding?: CliPadding;
+    icon?: string | null;
+    prefix?: string | null;
+};
+type Formatter<TOpts = any> = (text: string, opts?: Partial<TOpts>) => string;
+/**
+ * Main CLI kit with:
+ *  - Multiline-safe indent/padding
+ *  - Extensible "dot-pattern" style registry (Cli.title.fancy, Cli.skip.subtle, etc.)
+ *  - Pluggable chalk instance (DI) to avoid hard-binding
+ */
+export default class Cli {
+    private static _chalk;
+    static setChalk(chalk: typeof chalkLib): void;
+    /** Style registry, editable at runtime with Cli.use("path", fn). */
+    private static registry;
+    /**
+     * Register/override a style function:
+     *   Cli.use("title.fancy", (text, opts) => "...custom...");
+     *   Cli.use("skip.warn",  (text, opts) => "...custom...");
+     */
+    static use<T = any>(path: string, fn: Formatter<T>): void;
+    /** Resolve a formatter by path; throws if missing. */
+    private static resolve;
+    static readonly title: {
+        (text: string, opts?: Partial<TitleOptions>): string;
+        [variant: string]: (text: string, opts?: Partial<TitleOptions>) => string;
+    };
+    static readonly skip: {
+        (text: string, opts?: Partial<SkipOptions>): string;
+        [variant: string]: (text: string, opts?: Partial<SkipOptions>) => string;
+    };
+    static readonly description: {
+        (text: string, opts?: Partial<DescriptionOptions>): string;
+        [variant: string]: (text: string, opts?: Partial<DescriptionOptions>) => string;
+    };
+    static indent(text: string, spaces?: number): any;
+    static padding(text: string, padding: CliPadding): any;
+    static hr(width?: number): any;
+}
+export {};

package/dist/bin/cli-tool.js

@@ -0,0 +1,310 @@
+var _a;
+import chalkLib from "chalk";
+/** Color variants for different message types */
+export var CliVariant;
+(function (CliVariant) {
+    CliVariant["INFO"] = "info";
+    CliVariant["SUCCESS"] = "success";
+    CliVariant["WARNING"] = "warning";
+    CliVariant["ERROR"] = "error";
+    CliVariant["DEBUG"] = "debug";
+    CliVariant["SUBTLE"] = "subtle";
+    CliVariant["PRIMARY"] = "primary";
+    CliVariant["SECONDARY"] = "secondary";
+})(CliVariant || (CliVariant = {}));
+/**
+ * A tiny utility to safely indent/pad across multiple lines (ANSI-friendly).
+ */
+function padLines(text, padding = {}) {
+    const { top = 0, bottom = 0, left = 0 } = padding;
+    const leftPad = " ".repeat(left);
+    const lines = text.split("\n").map((l) => (left > 0 ? leftPad + l : l));
+    const topPad = Array.from({ length: top }, () => "").join("\n");
+    const bottomPad = Array.from({ length: bottom }, () => "").join("\n");
+    return ((top ? topPad + "\n" : "") +
+        lines.join("\n") +
+        (bottom ? "\n" + bottomPad : ""));
+}
+/**
+ * Path helpers for dot-pattern registry: "title.fancy", "skip.subtle", etc.
+ */
+function getByPath(obj, path) {
+    return path
+        .split(".")
+        .reduce((acc, key) => (acc ? acc[key] : undefined), obj);
+}
+function setByPath(obj, path, value) {
+    const keys = path.split(".");
+    const last = keys.pop();
+    const parent = keys.reduce((acc, key) => (acc[key] ?? (acc[key] = {})), obj);
+    parent[last] = value;
+}
+/**
+ * Main CLI kit with:
+ *  - Multiline-safe indent/padding
+ *  - Extensible "dot-pattern" style registry (Cli.title.fancy, Cli.skip.subtle, etc.)
+ *  - Pluggable chalk instance (DI) to avoid hard-binding
+ */
+class Cli {
+    static setChalk(chalk) {
+        this._chalk = chalk;
+    }
+    /**
+     * Register/override a style function:
+     *   Cli.use("title.fancy", (text, opts) => "...custom...");
+     *   Cli.use("skip.warn",  (text, opts) => "...custom...");
+     */
+    static use(path, fn) {
+        setByPath(this.registry, path, fn);
+    }
+    /** Resolve a formatter by path; throws if missing. */
+    static resolve(path) {
+        const got = getByPath(this.registry, path);
+        if (!got)
+            throw new Error(`Cli: style "${path}" not found. Register it with Cli.use("${path}", fn).`);
+        return got;
+    }
+    // Utility passthroughs
+    static indent(text, spaces = 0) {
+        return this.registry.util.indent(text, spaces);
+    }
+    static padding(text, padding) {
+        return this.registry.util.padding(text, padding);
+    }
+    static hr(width) {
+        return this.registry.util.hr(width);
+    }
+}
+_a = Cli;
+// You can inject your own chalk-like instance if needed (for tests, themes, etc.)
+Cli._chalk = chalkLib;
+/** Style registry, editable at runtime with Cli.use("path", fn). */
+Cli.registry = {
+    title: {
+        default: ((text, opts) => {
+            const { indentation = 0, padding, badge } = opts || {};
+            const inner = (badge ? _a._chalk.black.bgYellow(` ${badge} `) + " " : "") +
+                _a._chalk.bold.black.bgYellow(` ${text} `);
+            const block = " ".repeat(indentation) + inner;
+            return padLines(block, padding ?? {});
+        }),
+        info: ((text, opts) => {
+            const { indentation = 0, padding, badge } = opts || {};
+            const inner = (badge ? _a._chalk.white.bgBlue(` ${badge} `) + " " : "") +
+                _a._chalk.bold.bgBlue.white(` ${text} `);
+            const block = " ".repeat(indentation) + inner;
+            return padLines(block, padding ?? {});
+        }),
+        success: ((text, opts) => {
+            const { indentation = 0, padding, badge } = opts || {};
+            const inner = (badge ? _a._chalk.black.bgGreen(` ${badge} `) + " " : "") +
+                _a._chalk.bold.bgGreen.black(` ${text} `);
+            const block = " ".repeat(indentation) + inner;
+            return padLines(block, padding ?? {});
+        }),
+        warning: ((text, opts) => {
+            const { indentation = 0, padding, badge } = opts || {};
+            const inner = (badge ? _a._chalk.black.bgYellow(` ${badge} `) + " " : "") +
+                _a._chalk.bold.bgYellow.black(` ${text} `);
+            const block = " ".repeat(indentation) + inner;
+            return padLines(block, padding ?? {});
+        }),
+        error: ((text, opts) => {
+            const { indentation = 0, padding, badge } = opts || {};
+            const inner = (badge ? _a._chalk.white.bgRed(` ${badge} `) + " " : "") +
+                _a._chalk.bold.bgRed.white(` ${text} `);
+            const block = " ".repeat(indentation) + inner;
+            return padLines(block, padding ?? {});
+        }),
+        debug: ((text, opts) => {
+            const { indentation = 0, padding, badge } = opts || {};
+            const inner = (badge ? _a._chalk.white.bgMagenta(` ${badge} `) + " " : "") +
+                _a._chalk.bold.bgMagenta.white(` ${text} `);
+            const block = " ".repeat(indentation) + inner;
+            return padLines(block, padding ?? {});
+        }),
+        primary: ((text, opts) => {
+            const { indentation = 0, padding, badge } = opts || {};
+            const inner = (badge ? _a._chalk.white.bgCyan(` ${badge} `) + " " : "") +
+                _a._chalk.bold.bgCyan.black(` ${text} `);
+            const block = " ".repeat(indentation) + inner;
+            return padLines(block, padding ?? {});
+        }),
+        secondary: ((text, opts) => {
+            const { indentation = 0, padding, badge } = opts || {};
+            const inner = (badge ? _a._chalk.black.bgGray(` ${badge} `) + " " : "") +
+                _a._chalk.bold.bgGray.white(` ${text} `);
+            const block = " ".repeat(indentation) + inner;
+            return padLines(block, padding ?? {});
+        }),
+        subtle: ((text, opts) => {
+            const { indentation = 0, padding, badge } = opts || {};
+            const inner = (badge ? _a._chalk.gray(`(${badge}) `) : "") +
+                _a._chalk.bold.underline(text);
+            const block = " ".repeat(indentation) + inner;
+            return padLines(block, padding ?? {});
+        }),
+        box: ((text, opts) => {
+            const { indentation = 0, padding, badge } = opts || {};
+            const label = badge ? `[${badge}] ` : "";
+            const content = label + text;
+            const lines = content.split("\n");
+            const width = Math.max(...lines.map((l) => l.length));
+            const top = "┌" + "─".repeat(width + 2) + "┐";
+            const bottom = "└" + "─".repeat(width + 2) + "┘";
+            const body = lines.map((l) => `│ ${l.padEnd(width, " ")} │`).join("\n");
+            const boxed = [top, body, bottom].join("\n");
+            const prefixed = " ".repeat(indentation) +
+                boxed.replace(/\n/g, "\n" + " ".repeat(indentation));
+            return padLines(prefixed, padding ?? {});
+        }),
+    },
+    skip: {
+        default: ((text, opts) => {
+            const { indentation = 0, reasonLabel = "skipped" } = opts || {};
+            return (" ".repeat(indentation) +
+                _a._chalk.yellowBright.italic(`- ${text} (${reasonLabel})`));
+        }),
+        info: ((text, opts) => {
+            const { indentation = 0, reasonLabel = "skipped" } = opts || {};
+            return (" ".repeat(indentation) +
+                _a._chalk.blue.italic(`- ${text} (${reasonLabel})`));
+        }),
+        success: ((text, opts) => {
+            const { indentation = 0, reasonLabel = "skipped" } = opts || {};
+            return (" ".repeat(indentation) +
+                _a._chalk.green.italic(`- ${text} (${reasonLabel})`));
+        }),
+        warning: ((text, opts) => {
+            const { indentation = 0, reasonLabel = "warning" } = opts || {};
+            return (" ".repeat(indentation) +
+                _a._chalk.yellow.italic(`⚠ ${text} (${reasonLabel})`));
+        }),
+        error: ((text, opts) => {
+            const { indentation = 0, reasonLabel = "error" } = opts || {};
+            return (" ".repeat(indentation) +
+                _a._chalk.red.italic(`✗ ${text} (${reasonLabel})`));
+        }),
+        debug: ((text, opts) => {
+            const { indentation = 0, reasonLabel = "debug" } = opts || {};
+            return (" ".repeat(indentation) +
+                _a._chalk.magenta.italic(`• ${text} (${reasonLabel})`));
+        }),
+        primary: ((text, opts) => {
+            const { indentation = 0, reasonLabel = "skipped" } = opts || {};
+            return (" ".repeat(indentation) +
+                _a._chalk.cyan.italic(`- ${text} (${reasonLabel})`));
+        }),
+        secondary: ((text, opts) => {
+            const { indentation = 0, reasonLabel = "skipped" } = opts || {};
+            return (" ".repeat(indentation) +
+                _a._chalk.gray.italic(`- ${text} (${reasonLabel})`));
+        }),
+        subtle: ((text, opts) => {
+            const { indentation = 0, reasonLabel = "skipped" } = opts || {};
+            return (" ".repeat(indentation) +
+                _a._chalk.dim(`- ${text} (${reasonLabel})`));
+        }),
+    },
+    description: {
+        default: ((text, opts) => {
+            const { indentation = 0, padding, icon, prefix } = opts || {};
+            const iconStr = icon ? `${icon} ` : "";
+            const prefixStr = prefix ? `${_a._chalk.bold(prefix)} ` : "";
+            const inner = iconStr + prefixStr + _a._chalk.gray(text);
+            const block = " ".repeat(indentation) + inner;
+            return padLines(block, padding ?? {});
+        }),
+        info: ((text, opts) => {
+            const { indentation = 0, padding, icon, prefix } = opts || {};
+            const iconStr = icon ? `${icon} ` : "ℹ️  ";
+            const prefixStr = prefix ? `${_a._chalk.blue.bold(prefix)} ` : "";
+            const inner = iconStr + prefixStr + _a._chalk.blue(text);
+            const block = " ".repeat(indentation) + inner;
+            return padLines(block, padding ?? {});
+        }),
+        success: ((text, opts) => {
+            const { indentation = 0, padding, icon, prefix } = opts || {};
+            const iconStr = icon ? `${icon} ` : "";
+            const prefixStr = prefix ? `${_a._chalk.green.bold(prefix)} ` : "";
+            const inner = iconStr + prefixStr + _a._chalk.green(text);
+            const block = " ".repeat(indentation) + inner;
+            return padLines(block, padding ?? {});
+        }),
+        warning: ((text, opts) => {
+            const { indentation = 0, padding, icon, prefix } = opts || {};
+            const iconStr = icon ? `${icon} ` : "";
+            const prefixStr = prefix ? `${_a._chalk.yellow.bold(prefix)} ` : "";
+            const inner = iconStr + prefixStr + _a._chalk.yellow(text);
+            const block = " ".repeat(indentation) + inner;
+            return padLines(block, padding ?? {});
+        }),
+        error: ((text, opts) => {
+            const { indentation = 0, padding, icon, prefix } = opts || {};
+            const iconStr = icon ? `${icon} ` : "";
+            const prefixStr = prefix ? `${_a._chalk.red.bold(prefix)} ` : "";
+            const inner = iconStr + prefixStr + _a._chalk.red(text);
+            const block = " ".repeat(indentation) + inner;
+            return padLines(block, padding ?? {});
+        }),
+        debug: ((text, opts) => {
+            const { indentation = 0, padding, icon, prefix } = opts || {};
+            const iconStr = icon ? `${icon} ` : "";
+            const prefixStr = prefix ? `${_a._chalk.magenta.bold(prefix)} ` : "";
+            const inner = iconStr + prefixStr + _a._chalk.magenta(text);
+            const block = " ".repeat(indentation) + inner;
+            return padLines(block, padding ?? {});
+        }),
+        primary: ((text, opts) => {
+            const { indentation = 0, padding, icon, prefix } = opts || {};
+            const iconStr = icon ? `${icon} ` : "";
+            const prefixStr = prefix ? `${_a._chalk.cyan.bold(prefix)} ` : "";
+            const inner = iconStr + prefixStr + _a._chalk.cyan(text);
+            const block = " ".repeat(indentation) + inner;
+            return padLines(block, padding ?? {});
+        }),
+        secondary: ((text, opts) => {
+            const { indentation = 0, padding, icon, prefix } = opts || {};
+            const iconStr = icon ? `${icon} ` : "";
+            const prefixStr = prefix ? `${_a._chalk.gray.bold(prefix)} ` : "";
+            const inner = iconStr + prefixStr + _a._chalk.gray(text);
+            const block = " ".repeat(indentation) + inner;
+            return padLines(block, padding ?? {});
+        }),
+        subtle: ((text, opts) => {
+            const { indentation = 0, padding, icon, prefix } = opts || {};
+            const iconStr = icon ? `${_a._chalk.dim(icon)} ` : "";
+            const prefixStr = prefix ? `${_a._chalk.dim.bold(prefix)} ` : "";
+            const inner = iconStr + prefixStr + _a._chalk.dim(text);
+            const block = " ".repeat(indentation) + inner;
+            return padLines(block, padding ?? {});
+        }),
+    },
+    util: {
+        // Multiline-safe indentation (kept public as method wrapper below)
+        indent: ((text, spaces = 0) => padLines(text, { left: spaces })),
+        // Multiline-safe padding helper (kept public as method wrapper below)
+        padding: ((text, padding) => padLines(text, padding)),
+        // A clean horizontal rule that adapts to terminal width (fallback to 80)
+        hr: ((width) => {
+            const w = width ?? (process.stdout.columns || 80);
+            return "─".repeat(Math.max(16, w)); // ensure some minimum length
+        }),
+    },
+};
+// ----------------------------
+// DOT-PATTERN PROXIES
+// ----------------------------
+// Title proxy: supports `Cli.title("text")` (default) and `Cli.title.box("text")`, etc.
+Cli.title = new Proxy(((text, opts) => _a.resolve("title.default")(text, opts)), {
+    get: (_target, prop) => (text, opts) => _a.resolve(`title.${prop}`)(text, opts),
+});
+// Skip proxy: supports `Cli.skip("...", { reasonLabel: "ignored" })` and `Cli.skip.subtle("...")`
+Cli.skip = new Proxy(((text, opts) => _a.resolve("skip.default")(text, opts)), {
+    get: (_target, prop) => (text, opts) => _a.resolve(`skip.${prop}`)(text, opts),
+});
+// Description proxy: supports `Cli.description("text")` and `Cli.description.info("text")`, etc.
+Cli.description = new Proxy(((text, opts) => _a.resolve("description.default")(text, opts)), {
+    get: (_target, prop) => (text, opts) => _a.resolve(`description.${prop}`)(text, opts),
+});
+export default Cli;

package/dist/bin/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/cli.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+import path from "path";
+import fs from "fs/promises";
+import { fileURLToPath } from "url";
+import { program } from "commander";
+import { ConfigCompiler, SupportedLanguages } from "../index.js";
+import Cli from "./cli-tool.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// interface CLIOptions {
+// 	config: string;
+// 	output: string;
+// 	lang: string;
+// }
+program
+    .name("ondc-code-generator")
+    .description("Ondc Validation Code Generator")
+    .version("0.0.1");
+program
+    .command("ondc-validation-gen")
+    .alias("xval")
+    .option("-c, --config <path>", "Path to build.yaml file")
+    .option("-f, --function-name <name>", "Name of the validation function to generate")
+    .option("-o, --output <directory>", "Output directory for generated code")
+    .option("-l, --lang <language>", "Target programming language (typescript, python, javascript, go)")
+    .description("Generate validation code")
+    .action(async (options) => {
+    const { config, output, lang, functionName } = options;
+    console.log(Cli.title("Ondc Validation Code Generator"));
+    if (!config || !output || !lang) {
+        console.log(Cli.description.error("Please provide all required options: --config, --output, --lang"));
+        process.exit(1);
+    }
+    try {
+        console.log(Cli.description.info(`Generating validation code for language: ${lang}`));
+        const functionName = options.functionName || "L1validations";
+        const language = getSupportedLanguage(lang);
+        const compiler = new ConfigCompiler(language);
+        const buildPath = path.resolve(process.cwd(), config);
+        console.log(Cli.description.info(`Reading build file from ${buildPath}...`));
+        const buildYaml = await fs.readFile(buildPath, "utf-8");
+        console.log(Cli.description.info("Initializing compiler..."));
+        await compiler.initialize(buildYaml);
+        console.log(Cli.description.info("Generating validation code..."));
+        await compiler.generateValidationFromBuild(functionName, output, true);
+        console.log(Cli.description.success(`Validation code generated successfully in ${output} for language ${lang}`));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(Cli.description.error(`Error: ${message}`));
+        process.exit(1);
+    }
+});
+program
+    .command("schema-gen")
+    .alias("schema")
+    .option("-c, --config <path>", "Path to build.yaml file")
+    .option("-o, --output <directory>", "Output directory for generated schema")
+    .option("-f, --format <format>", "Output format (json, yaml,typescript)")
+    .description("Generate L0 schema")
+    .action(async (options) => {
+    console.log(Cli.title("Ondc Schema Generator"));
+    try {
+        const { config, output, format } = options;
+        if (!config || !output || !format) {
+            console.log(Cli.description.error("Please provide all required options: --config, --output, --format"));
+            process.exit(1);
+        }
+        console.log(Cli.description.info(`Generating L0 schema...`));
+        const buildPath = path.resolve(process.cwd(), config);
+        console.log(Cli.description.info(`Reading build file from ${buildPath}...`));
+        const buildYaml = await fs.readFile(buildPath, "utf-8");
+        const compiler = new ConfigCompiler(SupportedLanguages.Typescript);
+        await compiler.initialize(buildYaml);
+        const formatType = getSchemaFormat(format);
+        await compiler.generateL0Schema(output, formatType, true);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(Cli.description.error(`Error: ${message}`));
+        process.exit(1);
+    }
+});
+program.parse();
+function getSupportedLanguage(lang) {
+    switch (lang.toLowerCase()) {
+        case "typescript":
+            return SupportedLanguages.Typescript;
+        case "python":
+            return SupportedLanguages.Python;
+        case "javascript":
+            return SupportedLanguages.Javascript;
+        case "go":
+            return SupportedLanguages.Golang;
+        default:
+            throw new Error(`Unsupported language: ${lang}. Supported languages are: ${getValidLanguageOptions()}`);
+    }
+}
+function getSchemaFormat(format) {
+    switch (format.toLowerCase()) {
+        case "json":
+            return "json";
+        case "typescript":
+            return "typescript";
+        case "yaml":
+            throw new Error("YAML format is not yet supported");
+        default:
+            throw new Error(`Unsupported format: ${format}. Supported formats are: json, typescript`);
+    }
+}
+function getValidLanguageOptions() {
+    return Object.values(SupportedLanguages).join(", ");
+}

package/dist/constants/syntax.js

@@ -168,4 +168,30 @@ export const ReservedKeywords = new Set([
     "match",
     "case",
     "_",
+    // golang keywords
+    "break",
+    "default",
+    "func",
+    "interface",
+    "select",
+    "case",
+    "defer",
+    "go",
+    "map",
+    "struct",
+    "chan",
+    "else",
+    "goto",
+    "package",
+    "switch",
+    "const",
+    "fallthrough",
+    "if",
+    "range",
+    "type",
+    "continue",
+    "for",
+    "import",
+    "return",
+    "var",
 ]);

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

@@ -20,8 +20,9 @@ export declare class ConfigCompiler {
     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) => Promise<void>;
-    generateL0Schema: (outputPath?: string, type?: "json" | "typescript") => Promise<void>;
+    generateCode: (valConfig: ValidationConfig, codeName?: string, minimal?: boolean, outputPath?: string, absolutePath?: boolean) => Promise<void>;
+    generateL0Schema: (outputPath?: string, type?: "json" | "typescript", absolutePath?: boolean) => Promise<void>;
     generateValidPaths: () => Promise<Record<string, string[]>>;
+    generateValidationFromBuild: (codeName: string, outputPath: string, absolutePath?: boolean) => Promise<void>;
 }
 export {};

package/dist/generator/config-compiler.js

@@ -11,7 +11,7 @@ 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";
-import { GolangGenerator } from "./generators/golang/go-generator.js";
+import { GoGenerator } from "./generators/go/go-generator.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const defaultConfig = {
@@ -57,7 +57,7 @@ export class ConfigCompiler {
             // throw new Error("validation failed");
         };
         // };
-        this.generateCode = async (valConfig, codeName = "L1-Validations", minimal = false, outputPath = "./") => {
+        this.generateCode = async (valConfig, codeName = "L1-Validations", minimal = false, outputPath = "./", absolutePath = false) => {
             valConfig = JSON.parse(JSON.stringify(valConfig));
             if (this.generatorConfig?.duplicateVariablesInChildren) {
                 valConfig = duplicateVariablesInChildren(valConfig);
@@ -69,7 +69,9 @@ export class ConfigCompiler {
                 await this.performValidations(valConfig);
             }
             // Generate code based on the language
-            const targetPath = `${outputPath}generated/${codeName}`;
+            const targetPath = absolutePath
+                ? outputPath
+                : `${outputPath}generated/${codeName}`;
             switch (this.language) {
                 case SupportedLanguages.Typescript:
                     await new TypescriptGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode({
@@ -87,7 +89,7 @@ export class ConfigCompiler {
                     });
                     break;
                 case SupportedLanguages.Golang:
-                    await new GolangGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode({
+                    await new GoGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode({
                         codeName: codeName,
                     });
                     break;
@@ -95,11 +97,13 @@ export class ConfigCompiler {
                     throw new Error("Language not supported");
             }
         };
-        this.generateL0Schema = async (outputPath = "./", type = "typescript") => {
+        this.generateL0Schema = async (outputPath = "./", type = "typescript", absolutePath = false) => {
             if (!this.jsonSchemas) {
                 throw new Error("Schemas not initialized");
             }
-            const targetPath = `${outputPath}generated/L0-schemas/`;
+            const targetPath = absolutePath
+                ? outputPath
+                : `${outputPath}generated/L0-schemas/`;
             for (const schema in this.jsonSchemas) {
                 const json = this.jsonSchemas[schema];
                 if (type === "typescript") {
@@ -129,6 +133,14 @@ export class ConfigCompiler {
             // );
             return this.possibleJsonPaths;
         };
+        this.generateValidationFromBuild = async (codeName, outputPath, absolutePath = false) => {
+            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);
+        };
         this.language = language;
         this.SchemaExtractionService = new SchemaExtractionService();
     }

package/dist/generator/generators/{golang → go}/go-ast.js

@@ -43,14 +43,14 @@ function compileToGo(node) {
         const unary = node;
         const func = uniaryFunction[unary.customFunction];
         const varName = unary.expression.name;
-        return `utils.${func}(${varName})`;
+        return `validationutils.${func}(${varName})`;
     }
     if (node.type === "customBinaryFunction") {
         const binary = node;
         const func = binaryFunction[binary.customFunction];
         const lhs = binary.lhs.name;
         const rhs = binary.rhs.name;
-        return `utils.${func}(${lhs}, ${rhs})`;
+        return `validationutils.${func}(${lhs}, ${rhs})`;
     }
     throw new Error("Unknown node type");
 }

package/dist/generator/generators/go/go-generator.d.ts

@@ -0,0 +1,13 @@
+import { CodeGenerator, CodeGeneratorProps } from "../classes/abstract-generator.js";
+export declare class GoGenerator extends CodeGenerator {
+    codeConfig: CodeGeneratorProps | undefined;
+    generateSessionDataCode(): Promise<void>;
+    generateValidationCode(): Promise<void>;
+    generateCode: (codeConfig: CodeGeneratorProps) => Promise<void>;
+    private generateIndexFile;
+    private getExternalKeys;
+    private generateTestFunction;
+    private createVariablesCode;
+    private createValidationLogicCode;
+    private CreateErrorMarkdown;
+}