ondc-code-generator 0.1.4 → 0.1.6

package/dist/constants/syntax.d.ts

@@ -4,7 +4,8 @@ export declare enum TestObjectSyntax {
     Scope = "_SCOPE_",
     Continue = "_CONTINUE_",
     ErrorCode = "_ERROR_CODE_",
-    SuccessCode = "_SUCCESS_CODE_"
+    SuccessCode = "_SUCCESS_CODE_",
+    Description = "_DESCRIPTION_"
 }
 export declare const ExternalDataSyntax = "_EXTERNAL";
 export declare enum ConfigSyntax {

package/dist/constants/syntax.js

@@ -6,6 +6,7 @@ export var TestObjectSyntax;
     TestObjectSyntax["Continue"] = "_CONTINUE_";
     TestObjectSyntax["ErrorCode"] = "_ERROR_CODE_";
     TestObjectSyntax["SuccessCode"] = "_SUCCESS_CODE_";
+    TestObjectSyntax["Description"] = "_DESCRIPTION_";
 })(TestObjectSyntax || (TestObjectSyntax = {}));
 export const ExternalDataSyntax = "_EXTERNAL";
 export var ConfigSyntax;

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

@@ -4,16 +4,18 @@ import { ErrorDefinition } from "../types/error-codes.js";
 import { ValidationConfig } from "../types/config-types.js";
 import { SupportedLanguages } from "../types/compiler-types.js";
 type CodeGeneratorConfig = {
-    removeRequiredfromSchema: boolean;
-    removeEnumsfromSchema: boolean;
+    removeRequiredFromSchema: boolean;
+    removeEnumsFromSchema: boolean;
+    duplicateVariablesInChildren: boolean;
 };
 export declare class ConfigCompiler {
     buildData: BUILD_TYPE | undefined;
     jsonSchemas: Record<string, JSONSchema7> | undefined;
     possibleJsonPaths: Record<string, string[]> | undefined;
     errorDefinitions: ErrorDefinition[] | undefined;
+    generatorConfig: CodeGeneratorConfig | undefined;
     language: SupportedLanguages;
-    private SchemaExtactionService;
+    private SchemaExtractionService;
     constructor(language: SupportedLanguages);
     initialize: (buildYaml: string, generatorConfig?: Partial<CodeGeneratorConfig>) => Promise<void>;
     performValidations: (valConfig: ValidationConfig) => Promise<void>;

package/dist/generator/config-compiler.js

@@ -1,5 +1,5 @@
 import { loadAndDereferenceYaml } from "../utils/config-utils/yaml.js";
-import { SchemaExtactionService } from "../services/schema-service.js";
+import { SchemaExtactionService as SchemaExtractionService } from "../services/schema-service.js";
 import logger from "../utils/logger.js";
 import { SupportedLanguages } from "../types/compiler-types.js";
 import { TypescriptGenerator } from "./generators/typescript/ts-generator.js";
@@ -9,20 +9,23 @@ import { readFileSync } from "fs";
 import Mustache from "mustache";
 import { fileURLToPath } from "url";
 import path from "path";
+import { duplicateVariablesInChildren } from "../utils/config-utils/duplicateVariables.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const defaultConfig = {
-    removeRequiredfromSchema: true,
-    removeEnumsfromSchema: true,
+    removeRequiredFromSchema: true,
+    removeEnumsFromSchema: true,
+    duplicateVariablesInChildren: true,
 };
 export class ConfigCompiler {
     constructor(language) {
         // 1. extract build, create schemas , extract possible paths , extract errorcodes
         this.initialize = async (buildYaml, generatorConfig = {}) => {
             const finalConfig = { ...defaultConfig, ...generatorConfig };
+            this.generatorConfig = finalConfig;
             this.buildData = await loadAndDereferenceYaml(buildYaml);
-            this.jsonSchemas = await this.SchemaExtactionService.extractSchemas(this.buildData, finalConfig.removeRequiredfromSchema, finalConfig.removeEnumsfromSchema);
-            this.possibleJsonPaths = this.SchemaExtactionService.extractPossiblePaths(this.jsonSchemas);
+            this.jsonSchemas = await this.SchemaExtractionService.extractSchemas(this.buildData, finalConfig.removeRequiredFromSchema, finalConfig.removeEnumsFromSchema);
+            this.possibleJsonPaths = this.SchemaExtractionService.extractPossiblePaths(this.jsonSchemas);
             const errors = this.buildData["x-errorcodes"];
             this.errorDefinitions = errors.code;
         };
@@ -44,6 +47,10 @@ export class ConfigCompiler {
             }
         };
         this.generateCode = async (valConfig, codeName = "L1-Validations") => {
+            if (this.generatorConfig?.duplicateVariablesInChildren) {
+                console.log("Duplicating variables");
+                valConfig = duplicateVariablesInChildren(valConfig);
+            }
             await this.performValidations(valConfig);
             // Generate code based on the language
             switch (this.language) {
@@ -84,6 +91,6 @@ export class ConfigCompiler {
             return this.possibleJsonPaths;
         };
         this.language = language;
-        this.SchemaExtactionService = new SchemaExtactionService();
+        this.SchemaExtractionService = new SchemaExtractionService();
     }
 }

package/dist/generator/generators/documentation/markdown-message-generator.js

@@ -2,9 +2,12 @@ import { CompileToMarkdown } from "../../../services/return-complier/ast-functio
 import { buildAstFromInput } from "../../../services/return-complier/combined.js";
 import Mustache from "mustache";
 import { addBlockquoteToMarkdown, addTabToMarkdown, ConvertArrayToStringsInTestObject, } from "../../../utils/general-utils/string-utils.js";
+import { TestObjectSyntax } from "../../../constants/syntax.js";
 export function markdownMessageGenerator(returnInput, variableValues, startingPointer, skipInput) {
     const ast = buildAstFromInput(returnInput);
-    const returnTemplate = CompileToMarkdown(ast, startingPointer, 0, false);
+    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:`;

package/dist/services/schema-service.js

@@ -11,10 +11,6 @@ export class SchemaExtactionService {
             for (const targetApi of apis) {
                 const existingSchema = paths[`/${targetApi}`].post.requestBody.content["application/json"]
                     .schema;
-                // output["response"] =
-                // 	paths[`/${targetApi}`].post.responses.default.content[
-                // 		"application/json"
-                // 	].schema;
                 const filtteredSchema = removeRequiredAndEnum(existingSchema, removeEnums, removeRequired);
                 output[targetApi] = filtteredSchema;
             }
@@ -23,7 +19,7 @@ export class SchemaExtactionService {
         this.extractPossiblePaths = (schemas) => {
             const paths = {};
             for (const [key, schema] of Object.entries(schemas)) {
-                paths[key] = getAllJsonPaths(schema);
+                paths[key] = getAllJsonPaths(schema).map((p) => p.replace(/\.([\w-]+\/[\w-]+)(?![\w\]])/g, (_, match) => `['${match}']`));
             }
             return paths;
         };

package/dist/types/config-types.d.ts

@@ -7,6 +7,7 @@ export type TestObject = {
     [TestObjectSyntax.ErrorCode]?: number;
     [TestObjectSyntax.SuccessCode]?: number;
     [TestObjectSyntax.Continue]?: string;
+    [TestObjectSyntax.Description]?: string;
     [key: string]: ConfigVariable | number | TestObject[] | undefined;
 };
 export type ConfigVariable = string | Primitive[];

package/dist/utils/config-utils/duplicateVariables.d.ts

@@ -0,0 +1,2 @@
+import { ValidationConfig } from "../../types/config-types.js";
+export declare function duplicateVariablesInChildren(valConfig: ValidationConfig): ValidationConfig;

package/dist/utils/config-utils/duplicateVariables.js

@@ -0,0 +1,42 @@
+import { ConfigSyntax, TestObjectSyntax } from "../../constants/syntax.js";
+import { getVariablesFromTest, mergePathWithScope, } from "../general-utils/test-object-utils.js";
+export function duplicateVariablesInChildren(valConfig) {
+    const tests = valConfig[ConfigSyntax.Tests];
+    for (const key in tests) {
+        const testArray = tests[key];
+        for (const test of testArray) {
+            duplicateVariables(test, {});
+            // console.log(test);
+        }
+    }
+    // console.log(JSON.stringify(valConfig, null, 2));
+    return valConfig;
+}
+function duplicateVariables(test, parentVariables) {
+    const variables = getVariablesFromTest(test);
+    const extractedVariables = {};
+    for (const v of variables) {
+        const value = test[v];
+        if (typeof value === "string") {
+            const scope = test[TestObjectSyntax.Scope];
+            extractedVariables[v] = mergePathWithScope(value, scope);
+        }
+        else if (Array.isArray(value)) {
+            extractedVariables[v] = value;
+        }
+    }
+    if (Array.isArray(test[TestObjectSyntax.Return])) {
+        const returnArray = test[TestObjectSyntax.Return];
+        for (const returnTest of returnArray) {
+            duplicateVariables(returnTest, {
+                ...parentVariables,
+                ...extractedVariables,
+            });
+        }
+    }
+    else {
+        // console.log("adding variables", parentVariables, test);
+        Object.assign(test, parentVariables);
+        console.log(test);
+    }
+}

package/dist/utils/general-utils/string-utils.d.ts

@@ -22,6 +22,7 @@ export declare function ConvertArrayToStringsInTestObject(testObject: TestObject
     _ERROR_CODE_?: number;
     _SUCCESS_CODE_?: number;
     _CONTINUE_?: string;
+    _DESCRIPTION_?: string;
 };
 export declare function ConvertArrayToString(arr: any[]): string;
 export declare function addTabToMarkdown(markdown: string): string;

package/dist/utils/general-utils/test-object-utils.d.ts

@@ -1,2 +1,3 @@
 import { TestObject } from "../../types/config-types.js";
 export declare function getVariablesFromTest(testObject: TestObject): string[];
+export declare function mergePathWithScope(path: string, scope?: string): string;

package/dist/utils/general-utils/test-object-utils.js

@@ -10,3 +10,10 @@ export function getVariablesFromTest(testObject) {
     }
     return variables;
 }
+export function mergePathWithScope(path, scope) {
+    if (scope) {
+        const pathWithoutDollar = path.slice(2);
+        path = `${scope}.${pathWithoutDollar}`;
+    }
+    return path;
+}

package/dist/utils/json-path-utils/paths.js

@@ -19,8 +19,8 @@ export function replaceBracketsWithAsteriskNested(jsonPath) {
     let result = "";
     let i = 0;
     while (i < jsonPath.length) {
-        if (jsonPath[i] === "[") {
-            // Start of bracketed expression
+        if (jsonPath[i] === "[" && jsonPath.substring(i).startsWith("[?(@.")) {
+            // Start of query bracketed expression
             let bracketDepth = 1;
             let j = i + 1;
             while (j < jsonPath.length && bracketDepth > 0) {
@@ -32,7 +32,7 @@ export function replaceBracketsWithAsteriskNested(jsonPath) {
                 }
                 j++;
             }
-            // Replace the content inside the brackets with '*'
+            // Replace the query condition with '*'
             result += "[*]";
             i = j; // Move i to after the closing ']'
         }

package/package.json

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