ondc-code-generator 0.0.1

package/dist/services/return-complier/ast.js

@@ -0,0 +1,92 @@
+import { ReturnParserInstance } from "./parser.js";
+export class AstBuilder extends ReturnParserInstance.getBaseCstVisitorConstructor() {
+    constructor() {
+        super();
+        this.validateVisitor();
+    }
+    returnStatement(ctx) {
+        return {
+            type: "returnStatement",
+            expression: this.visit(ctx.orExpression),
+        };
+    }
+    orExpression(ctx) {
+        let left = this.visit(ctx.lhs);
+        if (!ctx.operator)
+            return left;
+        if (ctx.operator) {
+            for (let i = 0; i < ctx.operator.length; i++) {
+                left = {
+                    type: "binaryOperator",
+                    operator: ctx.operator[i].image,
+                    lhs: left,
+                    rhs: this.visit(ctx.rhs[i]),
+                };
+            }
+        }
+        return left;
+    }
+    andExpression(ctx) {
+        let left = this.visit(ctx.lhs);
+        if (!ctx.operator)
+            return left;
+        if (ctx.operator) {
+            for (let i = 0; i < ctx.operator.length; i++) {
+                left = {
+                    type: "binaryOperator",
+                    operator: ctx.operator[i].image,
+                    lhs: left,
+                    rhs: this.visit(ctx.rhs[i]),
+                };
+            }
+        }
+        return left;
+    }
+    notExpression(ctx) {
+        if (ctx.operator) {
+            return {
+                type: "notOperator",
+                operator: ctx.operator[0].image,
+                expression: this.visit(ctx.parentheisizedExpression),
+            };
+        }
+        return this.visit(ctx.primaryExpression);
+    }
+    primaryExpression(ctx) {
+        if (ctx.parentheisizedExpression) {
+            return this.visit(ctx.parentheisizedExpression);
+        }
+        if (ctx.atomicCustomExpression) {
+            return this.visit(ctx.atomicCustomExpression);
+        }
+        throw new Error("Invalid primary expression");
+    }
+    parentheisizedExpression(ctx) {
+        return this.visit(ctx.returnStatement);
+    }
+    atomicCustomExpression(ctx) {
+        if (ctx.rhs) {
+            return {
+                type: "customBinaryFunction",
+                customFunction: ctx.function[0].image,
+                lhs: this.visitIdentifier(ctx.lhs[0]),
+                rhs: this.visitIdentifier(ctx.rhs[0]),
+            };
+        }
+        return {
+            type: "customUniaryFunction",
+            customFunction: ctx.function[0].image,
+            expression: this.visitIdentifier(ctx.lhs[0]),
+        };
+    }
+    visitIdentifier(token) {
+        return {
+            type: "identifier",
+            name: token.image,
+        };
+    }
+}
+export function buildAst(cst) {
+    const astBuilder = new AstBuilder();
+    return astBuilder.visit(cst);
+}

package/dist/services/return-complier/combined.js

@@ -0,0 +1,7 @@
+import { buildAst } from "./ast.js";
+import { parseReturnInput } from "./parser.js";
+export function buildAstFromInput(input) {
+    const cst = parseReturnInput(input);
+    const ast = buildAst(cst);
+    return ast;
+}

package/dist/services/return-complier/parser.js

@@ -0,0 +1,95 @@
+import { CstParser } from "chevrotain";
+import { allTokens, AndOperator, CustomBinaryFunctions, CustomUniaryFunctions, Identifier, LParen, NotOperator, OrOperator, ReturnTokenize, RParen, } from "./tokens.js";
+class ReturnParser extends CstParser {
+    constructor() {
+        super(allTokens);
+        const $ = this;
+        $.RULE("returnStatement", () => {
+            $.SUBRULE($.orExpression);
+        });
+        $.RULE("orExpression", () => {
+            $.SUBRULE($.andExpression, { LABEL: "lhs" });
+            $.MANY(() => {
+                $.CONSUME(OrOperator, { LABEL: "operator" });
+                $.SUBRULE2($.andExpression, { LABEL: "rhs" });
+            });
+        });
+        $.RULE("andExpression", () => {
+            $.SUBRULE($.notExpression, { LABEL: "lhs" });
+            $.MANY(() => {
+                $.CONSUME(AndOperator, { LABEL: "operator" });
+                $.SUBRULE2($.notExpression, { LABEL: "rhs" });
+            });
+        });
+        $.notExpression = $.RULE("notExpression", () => {
+            $.OR([
+                {
+                    ALT: () => {
+                        $.CONSUME(NotOperator, { LABEL: "operator" });
+                        $.SUBRULE($.parentheisizedExpression);
+                    },
+                },
+                {
+                    ALT: () => {
+                        $.SUBRULE($.primaryExpression);
+                    },
+                },
+            ]);
+        });
+        $.RULE("primaryExpression", () => {
+            $.OR([
+                {
+                    ALT: () => {
+                        $.SUBRULE($.parentheisizedExpression);
+                    },
+                },
+                {
+                    ALT: () => {
+                        $.SUBRULE($.atomicCustomExpression);
+                    },
+                },
+            ]);
+        });
+        $.RULE("parentheisizedExpression", () => {
+            $.CONSUME(LParen);
+            $.SUBRULE($.returnStatement);
+            $.CONSUME(RParen);
+        });
+        $.RULE("atomicCustomExpression", () => {
+            $.OR([
+                {
+                    ALT: () => {
+                        $.CONSUME1(Identifier, { LABEL: "lhs" });
+                        $.CONSUME(CustomBinaryFunctions, { LABEL: "function" });
+                        $.CONSUME2(Identifier, { LABEL: "rhs" });
+                    },
+                },
+                {
+                    ALT: () => {
+                        $.CONSUME3(Identifier, { LABEL: "lhs" });
+                        $.CONSUME(CustomUniaryFunctions, { LABEL: "function" });
+                    },
+                },
+            ]);
+        });
+        $.performSelfAnalysis();
+    }
+}
+export const ReturnParserInstance = new ReturnParser();
+export function parseReturnInput(inputText) {
+    // Step 1: Tokenize the input
+    const lexResult = ReturnTokenize(inputText);
+    // Step 3: Set the parser's input
+    ReturnParserInstance.input = lexResult.tokens;
+    // Step 4: Parse the input starting from the 'returnStatement' rule
+    const cst = ReturnParserInstance.returnStatement();
+    // Step 5: Check for parsing errors
+    if (ReturnParserInstance.errors.length > 0) {
+        const parseErrors = ReturnParserInstance.errors
+            .map((error) => error.message)
+            .join("\n");
+        throw new Error(`Parsing errors detected:\n${parseErrors}`);
+    }
+    // If no errors, return the CST
+    return cst;
+}

package/dist/services/return-complier/tokens.js

@@ -0,0 +1,144 @@
+import { createToken, Lexer, } from "chevrotain";
+export const Identifier = createToken({
+    name: "Identifier",
+    pattern: /[a-zA-Z_][a-zA-Z0-9_]*/,
+});
+export const CustomBinaryFunctions = createToken({
+    name: "CustomFunctions",
+    pattern: Lexer.NA,
+});
+export const CustomUniaryFunctions = createToken({
+    name: "CustomUniaryFunctions",
+    pattern: Lexer.NA,
+});
+export const AllIn = createToken({
+    name: "AllIn",
+    pattern: /all in/i,
+    categories: CustomBinaryFunctions,
+    label: "all in",
+});
+export const AnyIn = createToken({
+    name: "AnyIn",
+    pattern: /any in/i,
+    categories: CustomBinaryFunctions,
+    label: "any in",
+});
+export const AreUnique = createToken({
+    name: "AreUnique",
+    pattern: /are unique/i,
+    categories: CustomUniaryFunctions,
+    label: "are unique",
+});
+export const ArePresent = createToken({
+    name: "ArePresent",
+    pattern: /are present/i,
+    categories: CustomUniaryFunctions,
+    label: "are present",
+});
+export const FollowRegex = createToken({
+    name: "FollowRegex",
+    pattern: /follow regex/i,
+    categories: CustomBinaryFunctions,
+    label: "follow regex",
+});
+export const NoneIn = createToken({
+    name: "NoneIn",
+    pattern: /none in/i,
+    categories: CustomBinaryFunctions,
+    label: "none in",
+});
+export const EqualTo = createToken({
+    name: "EqualTo",
+    pattern: /equal to/i,
+    label: "equal to",
+});
+export const GreaterThan = createToken({
+    name: "GreaterThan",
+    pattern: /greater than/i,
+    label: "greater than",
+});
+export const LessThan = createToken({
+    name: "LessThan",
+    pattern: /less than/i,
+    label: "less than",
+});
+export const WhiteSpace = createToken({
+    name: "WhiteSpace",
+    pattern: /\s+/,
+    group: Lexer.SKIPPED,
+});
+export const LParen = createToken({
+    name: "LParen",
+    pattern: /\(/,
+    label: "(",
+});
+export const RParen = createToken({
+    name: "RParen",
+    pattern: /\)/,
+    label: ")",
+});
+export const BinaryOperator = createToken({
+    name: "BinaryOperator",
+    pattern: Lexer.NA,
+});
+export const AndOperator = createToken({
+    name: "AndOperator",
+    pattern: /&&/,
+    categories: BinaryOperator,
+    label: "&&",
+});
+export const OrOperator = createToken({
+    name: "OrOperator",
+    pattern: /\|\|/,
+    categories: BinaryOperator,
+    label: "||",
+});
+export const NotOperator = createToken({
+    name: "NotOperator",
+    pattern: /!/,
+    label: "!",
+});
+export const allTokens = [
+    WhiteSpace,
+    LParen,
+    RParen,
+    AndOperator,
+    OrOperator,
+    NotOperator,
+    AreUnique,
+    ArePresent,
+    AllIn,
+    AnyIn,
+    EqualTo,
+    GreaterThan,
+    LessThan,
+    FollowRegex,
+    NoneIn,
+    CustomUniaryFunctions,
+    CustomBinaryFunctions,
+    BinaryOperator,
+    Identifier,
+];
+const lexerErrorMessageProvider = {
+    buildUnableToPopLexerModeMessage: function (token) {
+        return `Unable to pop Lexer Mode at line ${token.startLine}, column ${token.startColumn}. Token: ${token.image}.`;
+    },
+    buildUnexpectedCharactersMessage: function (fullText, startOffset, length, line, column) {
+        const unexpectedText = fullText.substring(startOffset, startOffset + length);
+        return `Unexpected character sequence: '${unexpectedText}' at line ${line}, column ${column}.`;
+    },
+};
+const ReturnLexer = new Lexer(allTokens, {
+    errorMessageProvider: lexerErrorMessageProvider,
+    positionTracking: "full",
+});
+export function ReturnTokenize(inputText) {
+    const lexerResult = ReturnLexer.tokenize(inputText);
+    if (lexerResult.errors.length > 0) {
+        const errorMessages = lexerResult.errors
+            .map((error) => error.message)
+            .join("\n");
+        throw new Error(`Lexing errors encountered:\n${errorMessages}`);
+    }
+    return lexerResult;
+}

package/dist/services/schema-service.js

@@ -0,0 +1,29 @@
+import { removeRequiredAndEnum } from "../utils/config-utils/json-schema-utils.js";
+import { getAllJsonPaths } from "../utils/json-path-utils/extract-string-paths.js";
+export class SchemaExtactionService {
+    constructor() {
+        this.extractSchemas = async (data, removeRequired, removeEnums) => {
+            const paths = data.paths;
+            const apis = Object.keys(paths).map((key) => {
+                return key.split("/")[1];
+            });
+            const output = { paths: {} };
+            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;
+            }
+            return output;
+        };
+        this.extractPossiblePaths = (schemas) => {
+            const paths = {};
+            for (const [key, schema] of Object.entries(schemas)) {
+                paths[key] = getAllJsonPaths(schema);
+            }
+            return paths;
+        };
+    }
+}

package/dist/types/build.js

@@ -0,0 +1 @@
+export {};

package/dist/types/compiler-types.js

@@ -0,0 +1,4 @@
+export var SupportedLanguages;
+(function (SupportedLanguages) {
+    SupportedLanguages["Typescript"] = "typescript";
+})(SupportedLanguages || (SupportedLanguages = {}));

package/dist/types/config-types.js

@@ -0,0 +1 @@
+import { ConfigSyntax, TestObjectSyntax } from "../constants/syntax.js";

package/dist/types/error-codes.js

@@ -0,0 +1 @@
+export {};

package/dist/types/general-types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/config-utils/json-schema-utils.js

@@ -0,0 +1,91 @@
+/**
+ * Recursively removes all "required" and "enum" properties from a JSON Schema.
+ * @param schema - The JSON Schema object to process.
+ * @returns A new JSON Schema object with "required" and "enum" properties removed.
+ */
+export function removeRequiredAndEnum(schema, removeEnums = true, removeRequired = true) {
+    if (typeof schema === "boolean") {
+        // Boolean schemas are returned as is
+        return schema;
+    }
+    // Create a shallow copy to avoid mutating the original schema
+    const cleanedSchema = { ...schema };
+    // Remove "required" and "enum" properties
+    if (removeRequired) {
+        delete cleanedSchema.required;
+    }
+    if (removeEnums) {
+        delete cleanedSchema.enum;
+    }
+    // Helper function to process child schemas
+    const processSchema = (subSchema) => {
+        return removeRequiredAndEnum(subSchema, removeEnums, removeRequired);
+    };
+    // Process "properties"
+    if (cleanedSchema.properties) {
+        const newProperties = {};
+        for (const key in cleanedSchema.properties) {
+            newProperties[key] = processSchema(cleanedSchema.properties[key]);
+        }
+        cleanedSchema.properties = newProperties;
+    }
+    // Process "patternProperties"
+    if (cleanedSchema.patternProperties) {
+        const newPatternProperties = {};
+        for (const key in cleanedSchema.patternProperties) {
+            newPatternProperties[key] = processSchema(cleanedSchema.patternProperties[key]);
+        }
+        cleanedSchema.patternProperties = newPatternProperties;
+    }
+    // Process "additionalProperties"
+    if (typeof cleanedSchema.additionalProperties === "object" &&
+        cleanedSchema.additionalProperties !== null) {
+        cleanedSchema.additionalProperties = removeRequiredAndEnum(cleanedSchema.additionalProperties, removeEnums, removeRequired);
+    }
+    // Process "items"
+    if (cleanedSchema.items) {
+        if (Array.isArray(cleanedSchema.items)) {
+            cleanedSchema.items = cleanedSchema.items.map((item) => removeRequiredAndEnum(item, removeEnums, removeRequired));
+        }
+        else {
+            cleanedSchema.items = removeRequiredAndEnum(cleanedSchema.items, removeEnums, removeRequired);
+        }
+    }
+    // Process "additionalItems"
+    if (typeof cleanedSchema.additionalItems === "object" &&
+        cleanedSchema.additionalItems !== null) {
+        cleanedSchema.additionalItems = removeRequiredAndEnum(cleanedSchema.additionalItems, removeEnums, removeRequired);
+    }
+    // Process combiners: "allOf", "anyOf", "oneOf"
+    ["allOf", "anyOf", "oneOf"].forEach((combiner) => {
+        if (cleanedSchema[combiner] &&
+            Array.isArray(cleanedSchema[combiner])) {
+            // @ts-ignore
+            cleanedSchema[combiner] = cleanedSchema[combiner].map((subSchema) => removeRequiredAndEnum(subSchema, removeEnums, removeRequired));
+        }
+    });
+    // Process "not"
+    if (cleanedSchema.not) {
+        cleanedSchema.not = removeRequiredAndEnum(cleanedSchema.not, removeEnums, removeRequired);
+    }
+    // Process "definitions"
+    if (cleanedSchema.definitions) {
+        const newDefinitions = {};
+        for (const key in cleanedSchema.definitions) {
+            newDefinitions[key] = processSchema(cleanedSchema.definitions[key]);
+        }
+        cleanedSchema.definitions = newDefinitions;
+    }
+    // Process "if", "then", "else"
+    ["if", "then", "else"].forEach((keyword) => {
+        if (cleanedSchema[keyword]) {
+            // @ts-ignore
+            cleanedSchema[keyword] = removeRequiredAndEnum(cleanedSchema[keyword], removeEnums, removeRequired);
+        }
+    });
+    // Process "contains"
+    if (cleanedSchema.contains) {
+        cleanedSchema.contains = removeRequiredAndEnum(cleanedSchema.contains, removeEnums, removeRequired);
+    }
+    return cleanedSchema;
+}

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

@@ -0,0 +1,16 @@
+import yaml from "js-yaml";
+import RefParser from "@apidevtools/json-schema-ref-parser";
+export async function loadAndDereferenceYaml(yamlData) {
+    const raw = yaml.load(yamlData);
+    const data = (await dereferenceSchema(raw));
+    return data;
+}
+async function dereferenceSchema(schema) {
+    try {
+        const dereferencedSchema = await RefParser.dereference(schema);
+        return dereferencedSchema;
+    }
+    catch (error) {
+        console.error("Error dereferencing schema:", error);
+    }
+}

package/dist/utils/file-system.js

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

package/dist/utils/fs-utils.js

@@ -0,0 +1,20 @@
+import fs from "fs-extra";
+import * as path from "path";
+import prettier from "prettier";
+import logger from "./logger.js";
+export function writeFileWithFsExtra(rootPath, relativeFilePath, content) {
+    // Resolve the full file path
+    const filePath = path.resolve(rootPath, relativeFilePath);
+    logger.debug(`Writing file to ${filePath}`);
+    fs.outputFileSync(filePath, content);
+}
+export async function formatCode(code, lang) {
+    return await prettier.format(code, {
+        parser: lang,
+        tabWidth: 4,
+    });
+}
+export async function writeAndFormatCode(rootPath, relativeFilePath, content, lang) {
+    const formattedCode = await formatCode(content, lang);
+    writeFileWithFsExtra(rootPath, relativeFilePath, formattedCode);
+}

package/dist/utils/general-utils/string-utils.js

@@ -0,0 +1,56 @@
+import { nodeReservedKeywords } from "../../constants/syntax.js";
+import { getVariablesFromTest } from "./test-object-utils.js";
+/**
+ * 	Check if the string matches the pattern: lowercase letters and underscores only, no leading or trailing underscores
+ *
+ * @param str
+ * @returns true if the string is in snake_case, false otherwise
+ */
+export function isSnakeCase(str) {
+    const snakeCasePattern = /^[a-z0-9]+(_[a-z0-9]+)*$/;
+    return snakeCasePattern.test(str);
+}
+export function isValidVariableName(input) {
+    // Regular expression to match valid variable names
+    const validVariableNameRegex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+    // Check if input matches the regex
+    const matchesPattern = validVariableNameRegex.test(input);
+    const isNotReservedKeyword = !nodeReservedKeywords.has(input);
+    return matchesPattern && isNotReservedKeyword;
+}
+/**
+ * Adds '>' at the beginning of each line in the given Markdown string.
+ *
+ * @param {string} markdown - The input Markdown string.
+ * @returns {string} - The modified Markdown string with '>' added to each line.
+ */
+export function addBlockquoteToMarkdown(markdown) {
+    return markdown
+        .split("\n") // Split the input string into an array of lines.
+        .map((line) => ">" + (line.trim() !== "" ? " " + line : "")) // Add '>' in front of each line.
+        .join("\n"); // Join the array of lines back into a single string.
+}
+export function ConvertArrayToStringsInTestObject(testObject) {
+    const variables = getVariablesFromTest(testObject);
+    const testDuplicate = { ...testObject };
+    for (const variable of variables) {
+        if (Array.isArray(testObject[variable])) {
+            let vals = testObject[variable].map((v) => `"${v}"`).join(", ");
+            vals = vals.replace(/"/g, `"`);
+            testDuplicate[variable] = `[${vals}]`;
+        }
+    }
+    return testDuplicate;
+}
+export function ConvertArrayToString(arr) {
+    let vals = arr.map((v) => `"${v}"`).join(", ");
+    vals = vals.replace(/"/g, `"`);
+    return `[${vals}]`;
+}
+export function addTabToMarkdown(markdown) {
+    // Split the markdown into lines, add a tab to each line, and rejoin
+    return markdown
+        .split("\n") // Split the input into individual lines
+        .map((line) => `\t${line}`) // Add a tab character at the beginning of each line
+        .join("\n"); // Rejoin the lines into a single string
+}

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

@@ -0,0 +1,12 @@
+import { TestObjectSyntax } from "../../constants/syntax.js";
+export function getVariablesFromTest(testObject) {
+    const variables = [];
+    const keys = Object.keys(testObject);
+    for (const key of keys) {
+        if (Object.values(TestObjectSyntax).includes(key)) {
+            continue;
+        }
+        variables.push(key);
+    }
+    return variables;
+}

package/dist/utils/general-utils/validation-utils.js

@@ -0,0 +1,21 @@
+export function isPrimitive(value) {
+    return (value === null ||
+        ["string", "number", "boolean", "symbol", "bigint"].includes(typeof value));
+}
+export function isValidVariableValueType(line) {
+    if (typeof line === "string") {
+        return true;
+    }
+    return Array.isArray(line) && line.every((item) => isPrimitive(item));
+}
+export function getExternalVariables(sessionData) {
+    const variables = [];
+    Object.values(sessionData).forEach((session) => {
+        Object.keys(session).forEach((key) => {
+            if (!variables.includes(key)) {
+                variables.push(key);
+            }
+        });
+    });
+    return variables;
+}