ondc-code-generator 0.0.1 → 0.0.3

package/src/utils/config-utils/json-schema-utils.ts

@@ -1,150 +0,0 @@
-import { JSONSchema7, JSONSchema7Definition } from "json-schema";
-import { remove } from "winston";
-
-/**
- * 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: JSONSchema7 | boolean,
-	removeEnums: boolean = true,
-	removeRequired: boolean = true
-): JSONSchema7 | boolean {
-	if (typeof schema === "boolean") {
-		// Boolean schemas are returned as is
-		return schema;
-	}
-
-	// Create a shallow copy to avoid mutating the original schema
-	const cleanedSchema: JSONSchema7 = { ...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: JSONSchema7Definition
-	): JSONSchema7Definition => {
-		return removeRequiredAndEnum(subSchema, removeEnums, removeRequired);
-	};
-
-	// Process "properties"
-	if (cleanedSchema.properties) {
-		const newProperties: { [key: string]: JSONSchema7Definition } = {};
-		for (const key in cleanedSchema.properties) {
-			newProperties[key] = processSchema(cleanedSchema.properties[key]);
-		}
-		cleanedSchema.properties = newProperties;
-	}
-
-	// Process "patternProperties"
-	if (cleanedSchema.patternProperties) {
-		const newPatternProperties: { [key: string]: JSONSchema7Definition } = {};
-		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 as keyof JSONSchema7] &&
-			Array.isArray(cleanedSchema[combiner as keyof JSONSchema7])
-		) {
-			// @ts-ignore
-			cleanedSchema[combiner as keyof JSONSchema7] = (
-				cleanedSchema[combiner as keyof JSONSchema7] as JSONSchema7[]
-			).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: { [key: string]: JSONSchema7Definition } = {};
-		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 as keyof JSONSchema7]) {
-			// @ts-ignore
-			cleanedSchema[keyword as keyof JSONSchema7] = removeRequiredAndEnum(
-				cleanedSchema[keyword as keyof JSONSchema7] as JSONSchema7,
-				removeEnums,
-				removeRequired
-			);
-		}
-	});
-
-	// Process "contains"
-	if (cleanedSchema.contains) {
-		cleanedSchema.contains = removeRequiredAndEnum(
-			cleanedSchema.contains,
-			removeEnums,
-			removeRequired
-		);
-	}
-
-	return cleanedSchema;
-}

package/src/utils/config-utils/yaml.ts

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

package/src/utils/fs-utils.ts

@@ -1,32 +0,0 @@
-import fs from "fs-extra";
-import * as path from "path";
-import prettier from "prettier";
-import logger from "./logger.js";
-
-export function writeFileWithFsExtra(
-	rootPath: string,
-	relativeFilePath: string,
-	content: string
-): void {
-	// 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: string, lang: string) {
-	return await prettier.format(code, {
-		parser: lang,
-		tabWidth: 4,
-	});
-}
-
-export async function writeAndFormatCode(
-	rootPath: string,
-	relativeFilePath: string,
-	content: string,
-	lang: string
-) {
-	const formattedCode = await formatCode(content, lang);
-	writeFileWithFsExtra(rootPath, relativeFilePath, formattedCode);
-}

package/src/utils/general-utils/string-utils.ts

@@ -1,76 +0,0 @@
-import {
-	nodeReservedKeywords,
-	TestObjectSyntax,
-} from "../../constants/syntax.js";
-import { TestObject } from "../../types/config-types.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: string): boolean {
-	const snakeCasePattern = /^[a-z0-9A-Z]+(_[a-z0-9A-Z]+)*$/;
-	return snakeCasePattern.test(str);
-}
-
-export function isValidVariableName(input: string): boolean {
-	// 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: string): string {
-	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: TestObject) {
-	const variables = getVariablesFromTest(testObject);
-	const testDuplicate = { ...testObject };
-	const scope = testObject[TestObjectSyntax.Scope];
-	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}]`;
-		} else {
-			if (scope) {
-				const path = testDuplicate[variable] as string;
-				const pathWithoutDollar = path.slice(2);
-				testDuplicate[variable] = `${scope}.${pathWithoutDollar}`;
-			}
-		}
-	}
-	return testDuplicate;
-}
-
-export function ConvertArrayToString(arr: any[]) {
-	let vals = arr.map((v) => `"${v}"`).join(", ");
-	vals = vals.replace(/"/g, `"`);
-	return `[${vals}]`;
-}
-
-export function addTabToMarkdown(markdown: string) {
-	// 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/src/utils/general-utils/test-object-utils.ts

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

package/src/utils/general-utils/validation-utils.ts

@@ -1,30 +0,0 @@
-import { SessionDataApi } from "../../types/config-types.js";
-import { Primitive, ValidVariableLine } from "../../types/general-types.js";
-
-export function isPrimitive(value: unknown): value is Primitive {
-	return (
-		value === null ||
-		["string", "number", "boolean", "symbol", "bigint"].includes(typeof value)
-	);
-}
-
-export function isValidVariableValueType(line: any): line is ValidVariableLine {
-	if (typeof line === "string") {
-		return true;
-	}
-	return Array.isArray(line) && line.every((item) => isPrimitive(item));
-}
-
-export function getExternalVariables(
-	sessionData: Record<string, SessionDataApi>
-) {
-	const variables: string[] = [];
-	Object.values(sessionData).forEach((session) => {
-		Object.keys(session).forEach((key) => {
-			if (!variables.includes(key)) {
-				variables.push(key);
-			}
-		});
-	});
-	return variables;
-}

package/src/utils/json-path-utils/extract-string-paths.ts

@@ -1,139 +0,0 @@
-// Import the JSONSchema7 type from the official types package
-import { JSONSchema7 } from "json-schema";
-
-/**
- * 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: JSONSchema7): string[] {
-	const paths: Set<string> = 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: JSONSchema7, currentPath: string) {
-		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: Array<keyof JSONSchema7> = ["allOf", "anyOf", "oneOf"];
-		for (const comb of combinators) {
-			if (currentSchema[comb]) {
-				// @ts-ignore
-				for (const subSchema of currentSchema[comb]!) {
-					traverse(subSchema as JSONSchema7, 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 as JSONSchema7, 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 as JSONSchema7, 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 as JSONSchema7, 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 as JSONSchema7, newPath);
-				});
-			} else {
-				// List validation: items is a single schema
-				const newPath = `${currentPath}[*]`;
-				traverse(currentSchema.items as JSONSchema7, newPath);
-			}
-		}
-
-		// Define primitive types considered as leaf nodes
-		const primitiveTypes: Array<Extract<JSONSchema7["type"], string>> = [
-			"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 as JSONSchema7, newPath);
-				}
-			}
-			if (currentSchema.items) {
-				const newPath = `${currentPath}[*]`;
-				traverse(currentSchema.items as JSONSchema7, 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/src/utils/json-path-utils/paths.ts

@@ -1,44 +0,0 @@
-import jsonpath from "jsonpath";
-export function isValidJsonPath(jsonPath: string) {
-	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: string): string {
-	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/src/utils/logger.ts

@@ -1,53 +0,0 @@
-import winston from "winston";
-import chalk from "chalk";
-
-const { combine, timestamp, printf, errors } = winston.format;
-
-// Define colors for log levels and messages
-const levelColors: Record<string, chalk.Chalk> = {
-	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: Record<string, chalk.Chalk> = {
-	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/tsconfig.json

@@ -1,17 +0,0 @@
-{
-	"compilerOptions": {
-		"target": "ES2020",
-		"module": "ES2020",
-		"moduleResolution": "node",
-		"outDir": "./dist",
-		"rootDir": "./src",
-		"esModuleInterop": true,
-		"forceConsistentCasingInFileNames": true,
-		"strict": true,
-		"skipLibCheck": true,
-		"allowSyntheticDefaultImports": true,
-		"resolveJsonModule": true
-	},
-	"include": ["src/**/*"],
-	"exclude": ["node_modules", "dist"]
-}