ondc-code-generator 0.0.1

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

@@ -0,0 +1,113 @@
+/**
+ * Extracts all possible JSON paths from a given JSON Schema Draft-07.
+ *
+ * @param schema - The JSON Schema Draft-07 object.
+ * @returns An array of JSON paths as strings.
+ */
+export function getAllJsonPaths(schema) {
+    const paths = new Set();
+    /**
+     * Recursively traverses the JSON schema to extract paths.
+     *
+     * @param currentSchema - The current schema node being traversed.
+     * @param currentPath - The JSON path accumulated so far.
+     */
+    function traverse(currentSchema, currentPath) {
+        if (!currentSchema)
+            return;
+        // Normalize the 'type' property to an array for consistent processing
+        const schemaTypes = Array.isArray(currentSchema.type)
+            ? currentSchema.type
+            : currentSchema.type
+                ? [currentSchema.type]
+                : [];
+        // Handle combinators: allOf, anyOf, oneOf
+        const combinators = ["allOf", "anyOf", "oneOf"];
+        for (const comb of combinators) {
+            if (currentSchema[comb]) {
+                // @ts-ignore
+                for (const subSchema of currentSchema[comb]) {
+                    traverse(subSchema, currentPath);
+                }
+            }
+        }
+        // Handle 'not' by skipping as it signifies exclusion
+        if (currentSchema.not) {
+            // Skipping 'not' schemas as they represent negations
+        }
+        // If the schema is of type 'object', traverse its properties
+        if (schemaTypes.includes("object") && currentSchema.properties) {
+            for (const [propName, propSchema] of Object.entries(currentSchema.properties)) {
+                const newPath = currentPath === "$" ? `$.${propName}` : `${currentPath}.${propName}`;
+                traverse(propSchema, newPath);
+            }
+            // Handle 'additionalProperties' if it's a schema
+            if (currentSchema.additionalProperties &&
+                typeof currentSchema.additionalProperties === "object") {
+                const newPath = `${currentPath}.*`; // Using '*' to denote any additional property
+                traverse(currentSchema.additionalProperties, newPath);
+            }
+            // Handle 'patternProperties'
+            if (currentSchema.patternProperties) {
+                for (const [pattern, patternSchema] of Object.entries(currentSchema.patternProperties)) {
+                    const newPath = `${currentPath}.*`; // Using '*' as a placeholder for any matching pattern
+                    traverse(patternSchema, newPath);
+                }
+            }
+        }
+        // If the schema is of type 'array', traverse its items
+        if (schemaTypes.includes("array") && currentSchema.items) {
+            if (Array.isArray(currentSchema.items)) {
+                // Tuple validation: items is an array of schemas
+                currentSchema.items.forEach((itemSchema, index) => {
+                    const newPath = `${currentPath}[*]`; // Using [*] to denote any index
+                    traverse(itemSchema, newPath);
+                });
+            }
+            else {
+                // List validation: items is a single schema
+                const newPath = `${currentPath}[*]`;
+                traverse(currentSchema.items, newPath);
+            }
+        }
+        // Define primitive types considered as leaf nodes
+        const primitiveTypes = [
+            "string",
+            "number",
+            "integer",
+            "boolean",
+            "null",
+        ];
+        // If the schema defines a primitive type, record the path
+        if (schemaTypes.some((type) => primitiveTypes.includes(type))) {
+            paths.add(currentPath);
+        }
+        // If 'enum' is present without a specific type, consider it as a leaf node
+        if (currentSchema.enum) {
+            paths.add(currentPath);
+        }
+        // If 'const' is present, consider it as a leaf node
+        if (currentSchema.const !== undefined) {
+            paths.add(currentPath);
+        }
+        // Handle cases where 'type' is not specified but 'properties' or 'items' are present
+        if (!currentSchema.type) {
+            if (currentSchema.properties) {
+                for (const [propName, propSchema] of Object.entries(currentSchema.properties)) {
+                    const newPath = currentPath === "$"
+                        ? `$.${propName}`
+                        : `${currentPath}.${propName}`;
+                    traverse(propSchema, newPath);
+                }
+            }
+            if (currentSchema.items) {
+                const newPath = `${currentPath}[*]`;
+                traverse(currentSchema.items, newPath);
+            }
+        }
+    }
+    // Initialize traversal with the root schema and the root path symbol '$'
+    traverse(schema, "$");
+    // Convert the Set to an array and return
+    return Array.from(paths);
+}

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

@@ -0,0 +1,46 @@
+import jsonpath from "jsonpath";
+export function isValidJsonPath(jsonPath) {
+    try {
+        jsonpath.query({}, jsonPath);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Replaces all content inside square brackets in a JSONPath with an asterisk '*',
+ * handling nested brackets if they occur.
+ *
+ * @param jsonPath - The JSONPath string to transform.
+ * @returns The transformed JSONPath string with contents inside brackets replaced by '*'.
+ */
+export function replaceBracketsWithAsteriskNested(jsonPath) {
+    let result = "";
+    let i = 0;
+    while (i < jsonPath.length) {
+        if (jsonPath[i] === "[") {
+            // Start of bracketed expression
+            let bracketDepth = 1;
+            let j = i + 1;
+            while (j < jsonPath.length && bracketDepth > 0) {
+                if (jsonPath[j] === "[") {
+                    bracketDepth++;
+                }
+                else if (jsonPath[j] === "]") {
+                    bracketDepth--;
+                }
+                j++;
+            }
+            // Replace the content inside the brackets with '*'
+            result += "[*]";
+            i = j; // Move i to after the closing ']'
+        }
+        else {
+            // Copy character as-is
+            result += jsonPath[i];
+            i++;
+        }
+    }
+    return result;
+}

package/dist/utils/logger.js

@@ -0,0 +1,41 @@
+import winston from "winston";
+import chalk from "chalk";
+const { combine, timestamp, printf, errors } = winston.format;
+// Define colors for log levels and messages
+const levelColors = {
+    error: chalk.bold.red, // Bright red for errors
+    warn: chalk.hex("#FFA500"), // Orange for warnings
+    info: chalk.blue, // Blue for information
+    debug: chalk.green, // Green for debugging
+    default: chalk.white, // Default color for others
+};
+const messageColors = {
+    error: chalk.redBright, // Highlight error messages
+    warn: chalk.yellowBright, // Bright yellow for warnings
+    info: chalk.cyan, // Cyan for information messages
+    debug: chalk.magentaBright, // Bright magenta for debugging
+    default: chalk.gray, // Default gray for fallback
+};
+// Custom log format
+const logFormat = printf(({ level, message, timestamp, stack }) => {
+    const levelColor = levelColors[level] || levelColors.default; // Colorize level
+    const messageColor = messageColors[level] || messageColors.default; // Colorize message
+    const coloredLevel = levelColor(`[${level.toUpperCase()}]`); // Apply color to log level
+    const coloredTimestamp = chalk.dim(timestamp); // Dim timestamp
+    const coloredMessage = messageColor(message); // Apply message-specific color
+    const coloredStack = stack ? chalk.dim(stack) : ""; // Dim stack trace if present
+    return `${coloredTimestamp} ${coloredLevel}: ${coloredMessage} ${coloredStack}`;
+});
+// Determine log level based on environment
+const logLevel = process.env.NODE_ENV === "production" ? "info" : "debug";
+// Configure Winston logger
+const logger = winston.createLogger({
+    level: logLevel,
+    format: combine(timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), errors({ stack: true }), // Include stack trace in error messages
+    logFormat),
+    transports: [
+        // Console transport with colorized output
+        new winston.transports.Console(),
+    ],
+});
+export default logger;

package/docs/error-gen.md

@@ -0,0 +1,33 @@
+<!-- request failed the api requirements:
+
+- **Api Condition** all of the following sub conditions must be met _(condition1 **and** condition2)_:
+
+  - **condition 1**: none of the "context.action" should be one of ['null']
+  - **condition 2**: any one of the sub conditions must be met (condition 2.1 or condition 2.2):
+
+    - **condition 2.1**: all of "ids" must be unique
+    - **condition 2.2**: categories must follow all regex in :['^\\w+$']
+
+---
+
+> _**Note**_: the **api condition** can be skipped if any of the skip conditions are met
+>
+> - **Skip Condition**:
+
+
+ -->
+
+**Search** api condtions: 
+
+all of the following sub conditions must pass as per the api specifications: 
+
+- **condition 1**: none of the "context.action" should be one of ['null']
+- **condition 2**: any one of the sub conditions must be met (condition 2.1 or condition 2.2):
+
+  - **condition 2.1**: all of "ids" must be unique
+  - **condition 2.2**: categories must follow all regex in :['^\\w+$']
+
+  > _**Note**_: the **api condition** can be skipped if any of the skip conditions 
+  > are met
+  >
+  > - **Skip Condition**:

package/docs/return-grammer.md

@@ -0,0 +1,23 @@
+#### **Grammar in EBNF:**
+
+```ebnf
+Expression          ::= OrExpression
+
+OrExpression        ::= AndExpression ( '||' AndExpression )*
+
+AndExpression       ::= NotExpression ( '&&' NotExpression )*
+
+NotExpression       ::= '!'? PrimaryExpression
+
+PrimaryExpression   ::= '(' Expression ')' | BinaryFunctionExpression | UnaryFunctionExpression
+
+BinaryFunctionExpression ::= Identifier BinaryFunction ( Identifier  )
+
+UnaryFunctionExpression  ::= Identifier UnaryFunction
+
+BinaryFunction      ::= 'all in' | 'none in' | 'follow regex'
+
+UnaryFunction       ::= 'are unique'
+
+Identifier          ::= /* as defined in the lexer */
+```

package/docs/sampleConfig.md

@@ -0,0 +1,39 @@
+```
+{
+    "search": {
+        "_SESSION_DATA_": {
+            "transId" : $.json.path,
+            "constValue": ["value"]
+            "some_external_var": null, // to make config believe something with this name will be instered after the code is generated
+        },
+        "_TESTS_": {
+            {
+                "_NAME_": "any-name",
+                "_SCOPE_": "$.json.path.for.array.of.object",
+                "var-names": "$.json.path.for.array.of.strings",
+                "_CONTINUE_": boolean operation using vars string
+                "_RETURN_" : a array of more test objects or boolean operation using var string
+                "_ERROR_CODE_" :
+            }
+        }
+    }
+}
+```
+
+```
+    "_TESTS_":{
+        search: {
+
+        }
+    },
+    "_SESSION_DATA_":{
+        search: {
+            "transId" : $.json.path,
+            "constValue": ["value"]
+            "some_external_var": null, // to make config believe something with this name will be instered after the code is generated
+        }
+    }
+```
+
+// session data is combined all keys and will be null in starting
+// and session data gets updates as the requests are recived