ondc-code-generator 0.0.1

package/.idea/code-generator.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
+      <excludeFolder url="file://$MODULE_DIR$/temp" />
+      <excludeFolder url="file://$MODULE_DIR$/tmp" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/code-generator.iml" filepath="$PROJECT_DIR$/.idea/code-generator.iml" />
+    </modules>
+  </component>
+</project>

package/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 ONDC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/custom-loader.js

@@ -0,0 +1,4 @@
+import { register } from "node:module";
+import { pathToFileURL } from "node:url";
+
+register("ts-node/esm", pathToFileURL("./"));

package/dist/Generator/config-compiler.js

@@ -0,0 +1,53 @@
+import { loadAndDereferenceYaml } from "../utils/config-utils/yaml.js";
+import { SchemaExtactionService } 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";
+import { ConfigValidator } from "./validators/config-validator.js";
+const defaultConfig = {
+    removeRequiredfromSchema: true,
+    removeEnumsfromSchema: 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.buildData = await loadAndDereferenceYaml(buildYaml);
+            this.jsonSchemas = await this.SchemaExtactionService.extractSchemas(this.buildData, finalConfig.removeRequiredfromSchema, finalConfig.removeEnumsfromSchema);
+            this.possibleJsonPahts = this.SchemaExtactionService.extractPossiblePaths(this.jsonSchemas);
+            const errors = this.buildData["x-errorcodes"];
+            this.errorDefinitions = errors.code;
+        };
+        this.performValidations = async (valConfig) => {
+            try {
+                if (!this.buildData)
+                    throw new Error("Build data not initialized");
+                if (!this.jsonSchemas)
+                    throw new Error("Schemas not initialized");
+                if (!this.possibleJsonPahts)
+                    throw new Error("Possible paths not initialized");
+                if (!this.errorDefinitions)
+                    throw new Error("Error definitions not initialized");
+                await new ConfigValidator("", valConfig, this.possibleJsonPahts, this.errorDefinitions).validate();
+            }
+            catch (e) {
+                logger.error(e);
+                throw new Error("Validation failed");
+            }
+        };
+        this.generateCode = async (valConfig) => {
+            await this.performValidations(valConfig);
+            // Generate code based on the language
+            switch (this.language) {
+                case SupportedLanguages.Typescript:
+                    await new TypescriptGenerator(valConfig, this.errorDefinitions ?? [], "./L1-validations").generateCode();
+                    break;
+                default:
+                    throw new Error("Language not supported");
+            }
+        };
+        this.language = language;
+        this.SchemaExtactionService = new SchemaExtactionService();
+    }
+}

package/dist/Generator/config-validator.js

@@ -0,0 +1,21 @@
+/*
+    validations:
+        a single test object validations:
+            1. name validations
+            2. scope validation
+            3. variable validation
+            4. continue and return validations
+            5. errorcode validations
+            6. json path validations
+            7. external data validations
+
+        upper validations:
+            1. unique names
+            2. _session_data_ are valid
+            3. _tests_ are valid
+        
+        x-errorcode validations:
+            1. all codes are unique
+*/
+export class ConfigValidator {
+}

package/dist/Generator/generators/classes/abstract-generator.js

@@ -0,0 +1,16 @@
+/*
+    1. generate code for session_data
+        1. a function take in payload and update the session_data in cache
+        2. get function which returns the session_data object
+    2. generate code for test-objects
+        1. single test object generation
+            1. handle nested
+        2. combine all the tests
+*/
+export class CodeGenerator {
+    constructor(validationConfig, errorCodes, rootPath = "./") {
+        this.validationConfig = validationConfig;
+        this.rootPath = rootPath;
+        this.errorCodes = errorCodes;
+    }
+}

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

@@ -0,0 +1,37 @@
+import { CompileToMarkdown } from "../../../services/return-complier/ast-functions/compile-to-markdown.js";
+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";
+export function markdownMessageGenerator(returnInput, variableValues, startingPointer, skipInput) {
+    const ast = buildAstFromInput(returnInput);
+    const returnTemplate = CompileToMarkdown(ast, startingPointer, 0, false);
+    if (variableValues[TestObjectSyntax.Scope]) {
+        const scope = variableValues[TestObjectSyntax.Scope];
+        for (const key in variableValues) {
+            if (Object.values(TestObjectSyntax).includes(key)) {
+                continue;
+            }
+            const path = variableValues[key];
+            const pathWithoutDollar = path.slice(2);
+            variableValues[key] = `${scope}.${pathWithoutDollar}`;
+        }
+    }
+    let finalReturn = Mustache.render(returnTemplate, ConvertArrayToStringsInTestObject(variableValues));
+    console.log(finalReturn);
+    if (skipInput) {
+        let skipMarkdown = `Note: **Condition ${startingPointer}** can be skipped if the following conditions are met:`;
+        const letters = "BCDEFGHIJKLMNOPQRSTUVWXYZ";
+        let index = 0;
+        for (const skip of skipInput) {
+            const skipAst = buildAstFromInput(skip);
+            const skipTemplate = CompileToMarkdown(skipAst, letters[index], 0, false);
+            const finalSkip = Mustache.render(skipTemplate, ConvertArrayToStringsInTestObject(variableValues));
+            skipMarkdown += `\n\n${finalSkip}`;
+            index++;
+        }
+        const blockSkip = addTabToMarkdown(addBlockquoteToMarkdown(skipMarkdown));
+        finalReturn += `\n\n${blockSkip}`;
+    }
+    return finalReturn;
+}

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

@@ -0,0 +1,57 @@
+import { ConfigSyntax, TestObjectSyntax } from "../../../constants/syntax.js";
+import { CodeGenerator } from "../classes/abstract-generator.js";
+import { markdownMessageGenerator } from "./markdown-message-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";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export class MarkdownDocGenerator extends CodeGenerator {
+    constructor() {
+        super(...arguments);
+        this.generateValidationCode = async () => {
+            const testConfig = this.validationConfig[ConfigSyntax.Tests];
+            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}`;
+            }
+            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),
+            }));
+            writeFileWithFsExtra(this.rootPath, "./page/style.css", cssData);
+        };
+        this.generateCode = async () => {
+            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/markdown-message-generator.js

@@ -0,0 +1,25 @@
+import { CompileToMarkdown } from "../../services/return-complier/ast-functions/compile-to-markdown.js";
+import { buildAstFromInput } from "../../services/return-complier/combined.js";
+import Mustache from "mustache";
+import { addBlockquoteToMarkdown, ConvertArrayToStringsInTestObject, } from "../../utils/general-utils/string-utils.js";
+export function markdownMessageGenerator(returnInput, variableValues, startingPointer, skipInput) {
+    const ast = buildAstFromInput(returnInput);
+    const returnTemplate = CompileToMarkdown(ast, startingPointer, 0, false);
+    let finalReturn = Mustache.render(returnTemplate, ConvertArrayToStringsInTestObject(variableValues));
+    console.log(finalReturn);
+    if (skipInput) {
+        let skipMarkdown = `Note: **Condition ${startingPointer}** can be skipped if the following conditions are met:`;
+        const letters = "BCDEFGHIJKLMNOPQRSTUVWXYZ";
+        let index = 0;
+        for (const skip of skipInput) {
+            const skipAst = buildAstFromInput(skip);
+            const skipTemplate = CompileToMarkdown(skipAst, letters[index], 0, false);
+            const finalSkip = Mustache.render(skipTemplate, ConvertArrayToStringsInTestObject(variableValues));
+            skipMarkdown += `\n\n${finalSkip}`;
+            index++;
+        }
+        const blockSkip = addBlockquoteToMarkdown(skipMarkdown);
+        finalReturn += `\n###\n${blockSkip}`;
+    }
+    return finalReturn;
+}

package/dist/Generator/generators/python/py-generator.js

@@ -0,0 +1 @@
+"use strict";

package/dist/Generator/generators/typescript/templates/json-path-utils.js

@@ -0,0 +1,15 @@
+import jsonpath from "jsonpath";
+function getJsonPath(payload, path) {
+    let output = jsonpath.query(payload, path);
+    if (isListOfStringsOrNull(output)) {
+        output = output.map((o) => (o === null ? "null" : o));
+    }
+    return output.length === 0 ? [] : output;
+}
+function isListOfStringsOrNull(variable) {
+    return (Array.isArray(variable) &&
+        variable.every((item) => item === null || typeof item === "string"));
+}
+export default {
+    getJsonPath,
+};

package/dist/Generator/generators/typescript/templates/validation-utils.js

@@ -0,0 +1,91 @@
+function areUnique(operand) {
+    const valuesSet = new Set(operand);
+    return valuesSet.size === operand.length;
+}
+function arePresent(operand) {
+    return noneIn(operand, ["", "null", "undefined"]) && operand.length > 0;
+}
+function allIn(left, right) {
+    return left.every((v) => right.includes(v));
+}
+function anyIn(left, right) {
+    return left.some((v) => right.includes(v));
+}
+function noneIn(left, right) {
+    return left.every((v) => !right.includes(v));
+}
+function equalTo(left, right) {
+    if (left.length !== right.length)
+        return false;
+    return left.every((v, i) => v === right[i]);
+}
+function greaterThan(left, right) {
+    // Check if all elements in an array are ISO 8601 dates
+    const areAllISO = (arr) => arr.every((v) => isISO8601(v));
+    // Check if all elements in an array are numbers
+    const areAllNumbers = (arr) => arr.every((v) => !isNaN(Number(v)));
+    if (areAllISO(left) && areAllISO(right)) {
+        // Compare ISO 8601 dates
+        const leftDates = left.map((date) => new Date(date).getTime());
+        const rightDates = right.map((date) => new Date(date).getTime());
+        return leftDates.every((ld, index) => ld > rightDates[index] || index >= rightDates.length);
+    }
+    else if (areAllNumbers(left) && areAllNumbers(right)) {
+        // Compare numbers
+        const leftNumbers = left.map(Number);
+        const rightNumbers = right.map(Number);
+        return leftNumbers.every((ln, index) => ln > rightNumbers[index] || index >= rightNumbers.length);
+    }
+    // If neither condition is met, return false
+    return false;
+}
+function lessThan(left, right) {
+    // Check if all elements in an array are ISO 8601 dates
+    const areAllISO = (arr) => arr.every((v) => isISO8601(v));
+    // Check if all elements in an array are numbers
+    const areAllNumbers = (arr) => arr.every((v) => !isNaN(Number(v)));
+    if (areAllISO(left) && areAllISO(right)) {
+        // Compare ISO 8601 dates
+        const leftDates = left.map((date) => new Date(date).getTime());
+        const rightDates = right.map((date) => new Date(date).getTime());
+        return leftDates.every((ld, index) => ld < rightDates[index] || index >= rightDates.length);
+    }
+    else if (areAllNumbers(left) && areAllNumbers(right)) {
+        // Compare numbers
+        const leftNumbers = left.map(Number);
+        const rightNumbers = right.map(Number);
+        return leftNumbers.every((ln, index) => ln < rightNumbers[index] || index >= rightNumbers.length);
+    }
+    // If neither condition is met, return false
+    return false;
+}
+function followRegex(left, regexArray) {
+    for (const regex of regexArray) {
+        const re = new RegExp(regex);
+        if (left.some((v) => !re.test(v)))
+            return false;
+    }
+    return true;
+}
+function isISO8601(str) {
+    // Regular expression to match ISO 8601 format
+    const iso8601Regex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
+    // Check if the string matches the ISO 8601 format
+    if (!iso8601Regex.test(str)) {
+        return false;
+    }
+    // Check if the string is a valid date
+    const date = new Date(str);
+    return !isNaN(date.getTime());
+}
+export default {
+    areUnique,
+    arePresent,
+    allIn,
+    anyIn,
+    noneIn,
+    equalTo,
+    followRegex,
+    greaterThan,
+    lessThan,
+};

package/dist/Generator/generators/typescript/ts-ast.js

@@ -0,0 +1,50 @@
+import { buildAstFromInput } from "../../../services/return-complier/combined.js";
+import { AllIn, AnyIn, AreUnique, EqualTo, FollowRegex, GreaterThan, LessThan, NoneIn, ArePresent, } from "../../../services/return-complier/tokens.js";
+const uniaryFunction = {
+    [AreUnique.LABEL ?? "are unique"]: "areUnique",
+    [ArePresent.LABEL ?? "are present"]: "arePresent",
+};
+const binaryFunction = {
+    [AllIn.LABEL ?? "all in"]: "allIn",
+    [AnyIn.LABEL ?? "any in"]: "anyIn",
+    [FollowRegex.LABEL ?? "follow regex"]: "followRegex",
+    [NoneIn.LABEL ?? "none in"]: "noneIn",
+    [EqualTo.LABEL ?? "equal to"]: "equalTo",
+    [GreaterThan.LABEL ?? "greater than"]: "greaterThan",
+    [LessThan.LABEL ?? "less than"]: "lessThan",
+};
+function compileToTs(node) {
+    if (node.type === "returnStatement") {
+        const returnNode = node;
+        return compileToTs(returnNode.expression);
+    }
+    if (node.type === "binaryOperator") {
+        const binaryNode = node;
+        const lhs = compileToTs(binaryNode.lhs);
+        const rhs = compileToTs(binaryNode.rhs);
+        return `(${lhs}) ${binaryNode.operator} (${rhs})`;
+    }
+    if (node.type === "notOperator") {
+        const notNode = node;
+        const expression = compileToTs(notNode.expression);
+        return `!(${expression})`;
+    }
+    if (node.type === "customUniaryFunction") {
+        const unary = node;
+        const func = uniaryFunction[unary.customFunction];
+        const varName = unary.expression.name;
+        return `validations.${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 `validations.${func}(${lhs}, ${rhs})`;
+    }
+    throw new Error("Unknown node type");
+}
+export const compileInputToTs = (input) => {
+    const ast = buildAstFromInput(input);
+    return compileToTs(ast);
+};

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

@@ -0,0 +1,184 @@
+import { readFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { ConfigSyntax, TestObjectSyntax } from "../../../constants/syntax.js";
+import Mustache from "mustache";
+import { markdownMessageGenerator } from "../documentation/markdown-message-generator.js";
+import { getVariablesFromTest as extractVariablesFromText } from "../../../utils/general-utils/test-object-utils.js";
+import { ConvertArrayToString } from "../../../utils/general-utils/string-utils.js";
+import { compileInputToTs } from "./ts-ast.js";
+import { CodeGenerator } from "../classes/abstract-generator.js";
+import { writeAndFormatCode } from "../../../utils/fs-utils.js";
+import logger from "../../../utils/logger.js";
+import { MarkdownDocGenerator } from "../documentation/md-generator.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export class TypescriptGenerator extends CodeGenerator {
+    constructor() {
+        super(...arguments);
+        this.generateSessionDataCode = async () => {
+            throw new Error("Method not implemented.");
+        };
+        this.generateValidationCode = async () => {
+            const testConfig = this.validationConfig[ConfigSyntax.Tests];
+            for (const key in testConfig) {
+                const testObjects = testConfig[key];
+                const betaConfig = {
+                    [TestObjectSyntax.Name]: key,
+                    [TestObjectSyntax.Return]: testObjects,
+                };
+                const testFunction = await this.generateTestFunction(betaConfig);
+                const apiTestTemplate = readFileSync(path.resolve(__dirname, "./templates/api-test.mustache"), "utf-8");
+                const finalCode = Mustache.render(apiTestTemplate, {
+                    functionCode: testFunction.code,
+                });
+                await writeAndFormatCode(this.rootPath, `./api-tests/${key}.ts`, finalCode, "typescript");
+            }
+        };
+        this.generateCode = async () => {
+            const jsonPathUtilsCode = readFileSync(path.resolve(__dirname, "./templates/json-path-utils.ts"), "utf-8");
+            const validtionUtils = readFileSync(path.resolve(__dirname, "./templates/validation-utils.ts"), "utf-8");
+            const typesTemplate = readFileSync(path.resolve(__dirname, "./templates/test-config.mustache"), "utf-8");
+            const typesCode = Mustache.render(typesTemplate, {
+                externalData: this.getExternalKeys(),
+            });
+            writeAndFormatCode(this.rootPath, "./utils/json-path-utils.ts", jsonPathUtilsCode, "typescript");
+            writeAndFormatCode(this.rootPath, "./utils/validation-utils.ts", validtionUtils, "typescript");
+            writeAndFormatCode(this.rootPath, "./types/test-config.ts", typesCode, "typescript");
+            await this.generateValidationCode();
+            await writeAndFormatCode(this.rootPath, "error.ts", this.generateErrorFile(this.errorCodes), "typescript");
+            await writeAndFormatCode(this.rootPath, "index.ts", this.generateIndexFile(Object.keys(this.validationConfig[ConfigSyntax.Tests])), "typescript");
+            await new MarkdownDocGenerator(this.validationConfig, this.errorCodes, this.rootPath).generateCode();
+        };
+        this.generateTestFunction = async (testObject) => {
+            const template = readFileSync(path.resolve(__dirname, "./templates/test-object.mustache"), "utf-8");
+            const view = {
+                name: testObject[TestObjectSyntax.Name],
+                scopePath: testObject[TestObjectSyntax.Scope] ?? "$",
+                variables: this.createVariablesCode(testObject),
+                hasContinue: testObject[TestObjectSyntax.Continue] ? true : false,
+                skipCheckStatement: testObject[TestObjectSyntax.Continue]
+                    ? compileInputToTs(testObject[TestObjectSyntax.Continue])
+                    : undefined,
+                validationCode: await this.createValidationLogicCode(testObject),
+            };
+            return {
+                funcName: testObject[TestObjectSyntax.Name],
+                code: Mustache.render(template, view),
+            };
+        };
+        this.createValidationLogicCode = async (testObject) => {
+            const template = readFileSync(path.resolve(__dirname, "./templates/validation-code.mustache"), "utf-8");
+            const skip = testObject[TestObjectSyntax.Continue];
+            const skipList = skip ? [skip] : undefined;
+            if (typeof testObject[TestObjectSyntax.Return] === "string") {
+                const returnStatement = compileInputToTs(testObject[TestObjectSyntax.Return]);
+                return Mustache.render(template, {
+                    isNested: false,
+                    returnStatement: returnStatement,
+                    errorCode: testObject[TestObjectSyntax.ErrorCode] ?? 30000,
+                    errorDescription: this.CreateErrorMarkdown(testObject, skipList),
+                });
+            }
+            else {
+                const subObjects = testObject[TestObjectSyntax.Return];
+                const functionCodes = [];
+                for (const subObject of subObjects) {
+                    const func = await this.generateTestFunction(subObject);
+                    functionCodes.push(func);
+                }
+                const names = functionCodes.map((f) => {
+                    return { name: f.funcName };
+                });
+                logger.debug(JSON.stringify(names));
+                return Mustache.render(template, {
+                    isNested: true,
+                    nestedFunctions: functionCodes.map((f) => f.code).join("\n"),
+                    names: names,
+                });
+            }
+        };
+    }
+    CreateErrorMarkdown(testObject, skipList) {
+        return markdownMessageGenerator(testObject[TestObjectSyntax.Return], testObject, "A", skipList);
+    }
+    createVariablesCode(testObject) {
+        const variables = [];
+        const varNames = extractVariablesFromText(testObject);
+        for (const name of varNames) {
+            const value = testObject[name];
+            const final = typeof value === "string"
+                ? `payloadUtils.getJsonPath(testObj, '${value}')`
+                : ConvertArrayToString(value);
+            variables.push({
+                name: name,
+                value: final,
+            });
+        }
+        return variables;
+    }
+    generateErrorFile(errors) {
+        console.log(errors);
+        const allCodes = errors.map((error) => error.code);
+        if (allCodes.length !== new Set(allCodes).size) {
+            throw new Error("Duplicate error codes found");
+        }
+        errors.push({
+            code: 20006,
+            Description: "Invalid response does not meet API contract specifications",
+        });
+        errors.push({
+            code: 30000,
+            Description: "Invalid request does not meet API contract specifications",
+        });
+        const errorConstant = `
+	const errors = [
+		${errors.map((error) => `{code: ${error.code}, message: "${error.Description}"}`).join(",\n")}
+	];
+		`;
+        const errorFunction = `export function getError(code: number) {
+		const error = errors.find((error) => error.code === code);
+		if (!error) {
+			throw new Error(\`Error code \${code} not found\`);
+		}
+		return error;
+		}`;
+        return `${errorConstant}\n${errorFunction}`;
+    }
+    getExternalKeys() {
+        const apis = Object.keys(this.validationConfig[ConfigSyntax.SessionData]);
+        const result = [];
+        for (const api of apis) {
+            const keys = Object.keys(this.validationConfig[ConfigSyntax.SessionData][api]);
+            for (const key of keys) {
+                result.push({ name: key });
+            }
+        }
+        return result;
+    }
+    generateIndexFile(apis) {
+        const importsCode = apis
+            .map((api) => `import ${api} from "./api-tests/${api}";`)
+            .join("\n");
+        const masterFunction = `
+				export function performL1Validations(action: string, payload: any,allErrors = false, externalData = {}) {
+					switch (action) {
+						${apis
+            .map((api) => `case "${api}": return ${api}({
+				payload: payload,
+				externalData: externalData,
+				config: {
+					runAllValidations: allErrors,
+				},
+			});`)
+            .join("\n")}
+						default:
+							throw new Error("Action not found");
+					}
+			}`;
+        return `
+				${importsCode}
+				${masterFunction}
+			`;
+    }
+}

package/dist/Generator/pipline.js

@@ -0,0 +1 @@
+"use strict";

package/dist/Generator/validators/abstract-validator.js

@@ -0,0 +1,6 @@
+export class TestObjectValidator {
+    constructor(testObject, path) {
+        this.targetObject = testObject;
+        this.validtionPath = path;
+    }
+}