ondc-code-generator 0.7.3 → 0.7.4

package/dist/bin/cli.js

@@ -41,7 +41,7 @@ program
         console.log(Cli.description.info("Initializing compiler..."));
         await compiler.initialize(buildYaml);
         console.log(Cli.description.info("Generating validation code..."));
-        await compiler.generateValidationFromBuild(functionName, output);
+        await compiler.generateValidationFromBuild(functionName, output, true);
         console.log(Cli.description.success(`Validation code generated successfully in ${output} for language ${lang}`));
     }
     catch (error) {
@@ -57,8 +57,28 @@ program
     .option("-o, --output <directory>", "Output directory for generated schema")
     .option("-f, --format <format>", "Output format (json, yaml,typescript)")
     .description("Generate L0 schema")
-    .action(async () => {
-    console.log("Schema generation command invoked");
+    .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) {
@@ -75,6 +95,18 @@ function getSupportedLanguage(lang) {
             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,9 +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) => Promise<void>;
+    generateValidationFromBuild: (codeName: string, outputPath: string, absolutePath?: boolean) => Promise<void>;
 }
 export {};

package/dist/generator/config-compiler.js

@@ -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({
@@ -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,13 +133,13 @@ export class ConfigCompiler {
             // );
             return this.possibleJsonPaths;
         };
-        this.generateValidationFromBuild = async (codeName, outputPath) => {
+        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);
+            await this.generateCode(valConfig, codeName, false, outputPath, absolutePath);
         };
         this.language = language;
         this.SchemaExtractionService = new SchemaExtractionService();

package/dist/generator/generators/go/templates/json-normalizer.mustache

@@ -3,13 +3,13 @@
 package validationutils
 
 import (
-	"encoding/json"
+	"github.com/bytedance/sonic"
 )
 
 // NormalizeKeys normalizes JSON structures so that:
-//  - All objects with the same property name share the union of keys seen anywhere
-//  - All objects inside the same array share the union of keys at that array level
-//  - Missing keys are filled with nil
+//   - All objects with the same property name share the union of keys seen anywhere
+//   - All objects inside the same array share the union of keys at that array level
+//   - Missing keys are filled with nil
 func NormalizeKeys(input interface{}) interface{} {
 	// Step 1: Collect templates by property name
 	templatesByPropName := make(map[string]map[string]struct{})
@@ -67,12 +67,12 @@ func applyTemplates(node interface{}, templates map[string]map[string]struct{})
 			if obj, ok := item.(map[string]interface{}); ok {
 				// Create new object with array union keys
 				next := make(map[string]interface{})
-				
+
 				// Copy existing keys
 				for k, val := range obj {
 					next[k] = val
 				}
-				
+
 				// Add missing keys from array union
 				for key := range arrayUnion {
 					if _, exists := next[key]; !exists {
@@ -141,14 +141,14 @@ func fillFromTemplate(propName string, obj map[string]interface{}, templates map
 	return filled
 }
 
-// DeepCloneJSON creates a deep clone of a JSON-serializable structure
+// DeepCloneJSON creates a deep clone of a JSON-serializable structure using sonic
 func DeepCloneJSON(v interface{}) interface{} {
-	b, err := json.Marshal(v)
+	b, err := sonic.Marshal(v)
 	if err != nil {
 		panic(err) // or handle error
 	}
 	var out interface{}
-	if err := json.Unmarshal(b, &out); err != nil {
+	if err := sonic.Unmarshal(b, &out); err != nil {
 		panic(err)
 	}
 	return out

package/package.json

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