ondc-code-generator 0.4.5 → 0.4.6

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

@@ -1,36 +1,101 @@
-export default function normalizeKeys(obj: any) {
-	if (Array.isArray(obj)) {
-		// Find all keys across all objects in the array
-		const allKeys = new Set();
-		obj.forEach((item) => {
-			if (typeof item === "object" && item !== null) {
-				Object.keys(item).forEach((key) => allKeys.add(key));
-			}
-		});
-
-		// Add missing keys with null
-		return obj.map((item) => {
-			if (typeof item === "object" && item !== null) {
-				const newItem = { ...item };
-				allKeys.forEach((key: any) => {
-					if (!(key in newItem)) {
-						newItem[key] = null;
-					}
-				});
-				// Recursively normalize nested objects/arrays
-				for (const k in newItem) {
-					newItem[k] = normalizeKeys(newItem[k]);
-				}
-				return newItem;
-			}
-			return item;
-		});
-	} else if (typeof obj === "object" && obj !== null) {
-		const newObj: any = {};
-		for (const key in obj) {
-			newObj[key] = normalizeKeys(obj[key]);
-		}
-		return newObj;
-	}
-	return obj; // primitive values
-}
+type JSONObject = Record<string, any>;
+
+/**
+ * Normalize keys so that:
+ *  - All objects with the same property name (e.g., "price") 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 `null`.
+ */
+export default function normalizeKeys(input: any): any {
+  // 1) Collect templates by property name: e.g., "price" -> Set<"currency" | "value" | ...>
+  const templatesByPropName: Record<string, Set<string>> = Object.create(null);
+
+  const collectTemplates = (node: any): void => {
+    if (Array.isArray(node)) {
+      // Recurse into array items
+      node.forEach(collectTemplates);
+
+      // Also collect a per-array union (used later when applying)
+      // We won't store this globally; we'll recompute per-array on apply.
+      return;
+    }
+    if (node && typeof node === "object") {
+      // For each property: if it's an object (non-array), record its keys under the property name
+      for (const [k, v] of Object.entries(node)) {
+        if (v && typeof v === "object" && !Array.isArray(v)) {
+          const set = (templatesByPropName[k] ||= new Set<string>());
+          Object.keys(v).forEach((childKey) => set.add(childKey));
+        }
+        collectTemplates(v);
+      }
+    }
+  };
+
+  // 2) Apply templates and within-array unions
+  const applyTemplates = (node: any): any => {
+    if (Array.isArray(node)) {
+      // Compute union of keys across all object elements for this array level
+      const arrayUnion = new Set<string>();
+      for (const item of node) {
+        if (item && typeof item === "object" && !Array.isArray(item)) {
+          Object.keys(item).forEach((k) => arrayUnion.add(k));
+        }
+      }
+
+      return node.map((item) => {
+        if (item && typeof item === "object" && !Array.isArray(item)) {
+          // Ensure array-level union keys
+          const next: JSONObject = { ...item };
+          arrayUnion.forEach((k) => {
+            if (!(k in next)) next[k] = null;
+          });
+
+          // Now apply templates per property name for nested objects
+          for (const [k, v] of Object.entries(next)) {
+            // If this property holds an object, align it to the template for that property name
+            if (v && typeof v === "object" && !Array.isArray(v)) {
+              next[k] = fillFromTemplate(k, v);
+            } else {
+              next[k] = applyTemplates(v);
+            }
+          }
+          return next;
+        }
+        return applyTemplates(item);
+      });
+    }
+
+    if (node && typeof node === "object") {
+      const out: JSONObject = {};
+      for (const [k, v] of Object.entries(node)) {
+        if (v && typeof v === "object" && !Array.isArray(v)) {
+          // Align object to the template for this property name (k)
+          out[k] = fillFromTemplate(k, v);
+        } else {
+          out[k] = applyTemplates(v);
+        }
+      }
+      return out;
+    }
+
+    return node; // primitives unchanged
+  };
+
+  // Helper: apply the template for a given property name `prop`
+  const fillFromTemplate = (prop: string, obj: any): any => {
+    const templ = templatesByPropName[prop];
+    // Recurse first on children so nested arrays/objects also normalize
+    const base: JSONObject = applyTemplates(obj);
+    if (!templ) return base; // no known template keys for this prop
+
+    const filled: JSONObject = { ...base };
+    templ.forEach((k) => {
+      if (!(k in filled)) filled[k] = null;
+    });
+    return filled;
+  };
+
+  // Run passes
+  collectTemplates(input);
+  return applyTemplates(input);
+}

package/dist/generator/generators/typescript/ts-generator.js

@@ -163,7 +163,7 @@ export class TypescriptGenerator extends CodeGenerator {
             .join("\n");
         const masterFunction = `
 				export function perform${functionName}(action: string, payload: any,allErrors = false, externalData : any = {}) {
-				const normalizedPayload = normalizeKeys(payload);
+				const normalizedPayload = normalizeKeys(JSON.parse(JSON.stringify(payload)));
 				externalData._SELF = normalizedPayload;
 					switch (action) {
 						${apis

package/package.json

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