ondc-code-generator 0.0.2 → 0.0.4

package/src/generator/generators/typescript/templates/test-config.mustache

@@ -1,28 +0,0 @@
-
-export interface ValidationConfig {
-    runAllValidations: boolean;
-}
-
-export type validationOutput = {
-	valid: boolean;
-	code: number;
-	description?: string;
-}[];
-
-/*
-{% comment %} export type ExternalData = {
-    {{#externalData}}
-    {{name}}?: string[];
-    {{/externalData}}
-}; {% endcomment %}
-*/
-
-export type ExternalData = {}
-
-export type validationInput = {
-	payload: any;
-	externalData: ExternalData;
-	config: ValidationConfig
-};
-
-export type testFunctionArray = Array<(input: validationInput) => validationOutput>;

package/src/generator/generators/typescript/templates/test-object.mustache

@@ -1,20 +0,0 @@
-function {{name}}(input: validationInput): validationOutput {
-    const scope = payloadUtils.getJsonPath(input.payload,"{{{scopePath}}}");
-    let subResults: validationOutput = [];
-    let valid = true;
-    for(const testObj of scope){
-        testObj._EXTERNAL = input.externalData;
-        {{#variables}}
-        const {{name}} = {{{value}}}
-        {{/variables}}
-        
-        {{#hasContinue}}
-            const skipCheck = {{{skipCheckStatement}}};
-            if(skipCheck) continue;
-        {{/hasContinue}}
-
-        {{{validationCode}}}
-        delete testObj._EXTERNAL;
-    }
-    return [{valid: valid,code: {{successCode}} },...subResults];
-}

package/src/generator/generators/typescript/templates/validation-code.mustache

@@ -1,39 +0,0 @@
-
-{{#isNested}}
-
-{{{nestedFunctions}}}
-
-const testFunctions: testFunctionArray = [
-    {{#names}}
-    {{name}},
-    {{/names}}
-];
-
-let invalidResults: validationOutput = [];
-for (const fn of testFunctions) {
-    const subResult = fn(input);
-    // .filter(r => !r.valid);
-    invalidResults = [...invalidResults, ...subResult];
-    if(!input.config.runAllValidations && invalidResults.length > 0) {
-        return invalidResults;
-    }
-}
-if(invalidResults.length > 0) {
-    // return invalidResults;
-    subResults = invalidResults;
-    valid = subResults.every(r => r.valid);
-}
-
-{{/isNested}}
-
-{{^isNested}}
-const validate = {{{returnStatement}}}
-
-if(!validate){
-    return [{
-        valid: false,
-        code: {{errorCode}},
-        description: `{{{errorDescription}}}`
-    }]
-}
-{{/isNested}}

package/src/generator/generators/typescript/templates/validation-utils.ts

@@ -1,117 +0,0 @@
-function areUnique(operand: string[]) {
-	const valuesSet = new Set(operand);
-	return valuesSet.size === operand.length;
-}
-
-function arePresent(operand: string[]) {
-
-	return noneIn(operand, ["", "null", "undefined"]) && operand.length > 0;
-}
-
-function allIn(left: string[], right: string[]) {
-	return left.every((v) => right.includes(v));
-}
-
-function anyIn(left: string[], right: string[]) {
-	return left.some((v) => right.includes(v));
-}
-
-function noneIn(left: string[], right: string[]) {
-	return left.every((v) => !right.includes(v));
-}
-
-function equalTo(left: string[], right: string[]) {
-	if (left.length !== right.length) return false;
-	return left.every((v, i) => v === right[i]);
-}
-
-function greaterThan(left: string[], right: string[]): boolean {
-	// Check if all elements in an array are ISO 8601 dates
-	const areAllISO = (arr: string[]) => arr.every((v) => isISO8601(v));
-	// Check if all elements in an array are numbers
-	const areAllNumbers = (arr: string[]) =>
-		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: string[], right: string[]): boolean {
-	// Check if all elements in an array are ISO 8601 dates
-	const areAllISO = (arr: string[]) => arr.every((v) => isISO8601(v));
-	// Check if all elements in an array are numbers
-	const areAllNumbers = (arr: string[]) =>
-		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: string[], regexArray: string[]) {
-	for (const regex of regexArray) {
-		const re = new RegExp(regex);
-		if (left.some((v) => !re.test(v))) return false;
-	}
-	return true;
-}
-
-function isISO8601(str: string): boolean {
-	// 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/src/generator/generators/typescript/ts-ast.ts

@@ -1,72 +0,0 @@
-import {
-	AstNode,
-	BinaryOperatorNode,
-	CustomBinaryFunction,
-	CustomUniaryFunction,
-	NotOperatorNode,
-	ReturnStatementNode,
-} from "../../../services/return-complier/ast.js";
-import { buildAstFromInput } from "../../../services/return-complier/combined.js";
-import { parseReturnInput } from "../../../services/return-complier/parser.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: AstNode): string {
-	if (node.type === "returnStatement") {
-		const returnNode = node as ReturnStatementNode;
-		return compileToTs(returnNode.expression);
-	}
-	if (node.type === "binaryOperator") {
-		const binaryNode = node as BinaryOperatorNode;
-		const lhs = compileToTs(binaryNode.lhs);
-		const rhs = compileToTs(binaryNode.rhs);
-		return `(${lhs}) ${binaryNode.operator} (${rhs})`;
-	}
-	if (node.type === "notOperator") {
-		const notNode = node as NotOperatorNode;
-		const expression = compileToTs(notNode.expression);
-		return `!(${expression})`;
-	}
-	if (node.type === "customUniaryFunction") {
-		const unary = node as CustomUniaryFunction;
-		const func = uniaryFunction[unary.customFunction];
-		const varName = unary.expression.name;
-		return `validations.${func}(${varName})`;
-	}
-	if (node.type === "customBinaryFunction") {
-		const binary = node as CustomBinaryFunction;
-		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: string) => {
-	const ast = buildAstFromInput(input);
-	return compileToTs(ast);
-};

package/src/generator/generators/typescript/ts-generator.ts

@@ -1,275 +0,0 @@
-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 { ConfigVariable, TestObject } from "../../../types/config-types.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 { ErrorDefinition } from "../../../types/error-codes.js";
-import { MarkdownDocGenerator } from "../documentation/md-generator.js";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-export class TypescriptGenerator extends CodeGenerator {
-	generateSessionDataCode = async () => {
-		throw new Error("Method not implemented.");
-	};
-	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"
-			);
-		}
-	};
-	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();
-	};
-
-	generateTestFunction = async (testObject: TestObject) => {
-		const template = readFileSync(
-			path.resolve(__dirname, "./templates/test-object.mustache"),
-			"utf-8"
-		);
-
-		const view: mustachRequirements = {
-			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),
-			successCode: testObject[TestObjectSyntax.SuccessCode] ?? 200,
-		};
-		return {
-			funcName: testObject[TestObjectSyntax.Name],
-			code: Mustache.render(template, view),
-		};
-	};
-
-	private CreateErrorMarkdown(
-		testObject: TestObject,
-		skipList: string[] | undefined
-	) {
-		return markdownMessageGenerator(
-			testObject[TestObjectSyntax.Return] as string,
-			testObject,
-			testObject[TestObjectSyntax.Name],
-			skipList
-		);
-	}
-
-	private createVariablesCode(testObject: TestObject) {
-		const variables: { name: string; value: string }[] = [];
-		const varNames = extractVariablesFromText(testObject);
-		for (const name of varNames) {
-			const value = testObject[name] as ConfigVariable;
-			const final =
-				typeof value === "string"
-					? `payloadUtils.getJsonPath(testObj, "${value}")`
-					: ConvertArrayToString(value);
-			variables.push({
-				name: name,
-				value: final,
-			});
-		}
-		return variables;
-	}
-
-	private createValidationLogicCode = async (testObject: 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: {
-				funcName: string;
-				code: string;
-			}[] = [];
-			for (const subObject of subObjects) {
-				const func = await this.generateTestFunction(subObject);
-				functionCodes.push(func);
-			}
-			const names = functionCodes.map((f) => {
-				return { name: f.funcName };
-			});
-			return Mustache.render(template, {
-				isNested: true,
-				nestedFunctions: functionCodes.map((f) => f.code).join("\n"),
-				names: names,
-			});
-		}
-	};
-
-	private generateErrorFile(errors: ErrorDefinition[]): string {
-		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}`;
-	}
-	private getExternalKeys() {
-		const apis = Object.keys(this.validationConfig[ConfigSyntax.SessionData]);
-		const result: { name: string }[] = [];
-		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;
-	}
-	private generateIndexFile(apis: string[]) {
-		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}
-			`;
-	}
-}
-
-interface mustachRequirements {
-	name: string;
-	scopePath: string;
-	variables: {
-		name: string;
-		value: string;
-	}[];
-	hasContinue: boolean;
-	skipCheckStatement?: string;
-	validationCode: string;
-	successCode: number;
-}

package/src/generator/validators/abstract-validator.ts

@@ -1,23 +0,0 @@
-import { TestObject } from "../../types/config-types";
-import { ErrorDefinition } from "../../types/error-codes";
-
-export interface IValidator {
-	validationPath: string;
-	validate(): Promise<void>;
-}
-
-export abstract class TestObjectValidator implements IValidator {
-	targetObject: TestObject;
-	validationPath: string;
-	abstract validate(): Promise<void>;
-	constructor(testObject: TestObject, path: string) {
-		this.targetObject = testObject;
-		this.validationPath = path;
-	}
-}
-
-export interface TestsValidatorDependencies {
-	stringJsonPaths: string[];
-	errorDefinitions: ErrorDefinition[];
-	externalVariables: string[];
-}

package/src/generator/validators/config-validator.ts

@@ -1,55 +0,0 @@
-import { ConfigSyntax } from "../../constants/syntax.js";
-import { ValidationConfig } from "../../types/config-types.js";
-import { ErrorDefinition } from "../../types/error-codes.js";
-import { getExternalVariables } from "../../utils/general-utils/validation-utils.js";
-import {
-	IValidator,
-	TestsValidatorDependencies,
-} from "./abstract-validator.js";
-import { SessionDataValidator } from "./session-data-config/session-data-validator.js";
-import { TestsValidator } from "./tests-config/test-list-validator.js";
-
-export class ConfigValidator implements IValidator {
-	validationPath: string;
-	config: ValidationConfig;
-	stringJsonPaths: Record<string, string[]>;
-	errorDefinitions: ErrorDefinition[];
-	constructor(
-		validationPath: string,
-		config: ValidationConfig,
-		stringJsonPaths: Record<string, string[]>,
-		errorDefinitions: ErrorDefinition[]
-	) {
-		this.validationPath = validationPath;
-		this.config = config;
-		this.stringJsonPaths = stringJsonPaths;
-		this.errorDefinitions = errorDefinitions;
-	}
-	validate = async () => {
-		if (!this.config[ConfigSyntax.Tests])
-			throw new Error(`Tests not found in config`);
-		if (!this.config[ConfigSyntax.SessionData])
-			throw new Error(`SessionData not found in config`);
-
-		const sessionData = this.config[ConfigSyntax.SessionData];
-		const tests = this.config[ConfigSyntax.Tests];
-
-		await new SessionDataValidator(
-			`${this.validationPath}/${ConfigSyntax.SessionData}`,
-			sessionData
-		).validate();
-
-		const externalVariables = getExternalVariables(sessionData);
-
-		for (const api in tests) {
-			const testList = tests[api];
-			const path = `${this.validationPath}/${ConfigSyntax.Tests}/${api}`;
-			const dependencies: TestsValidatorDependencies = {
-				stringJsonPaths: this.stringJsonPaths[api],
-				errorDefinitions: this.errorDefinitions,
-				externalVariables: externalVariables,
-			};
-			await new TestsValidator(testList, path, dependencies).validate();
-		}
-	};
-}

package/src/generator/validators/session-data-config/session-data-validator.ts

@@ -1,58 +0,0 @@
-import { SessionDataApi } from "../../../types/config-types.js";
-import { isPrimitive } from "../../../utils/general-utils/validation-utils.js";
-
-import { IValidator } from "../abstract-validator.js";
-
-export class SessionDataValidator implements IValidator {
-	validationPath: string;
-	sessionData: Record<string, SessionDataApi>;
-	constructor(
-		validtionPath: string,
-		sessionData: Record<string, SessionDataApi>
-	) {
-		this.validationPath = validtionPath;
-		this.sessionData = sessionData;
-	}
-	validate = async () => {
-		Object.entries(this.sessionData).forEach(([key, value]) => {
-			const newPath = `${this.validationPath}/${key}`;
-			this.validateSessionData(value, newPath);
-		});
-	};
-
-	private validateSessionData(variable: any, path: string): void {
-		if (typeof variable !== "object" || variable === null) {
-			throw new Error(
-				`Invalid SessionData at ${path}: Expected an object, got ${typeof variable}`
-			);
-		}
-
-		Object.entries(variable).forEach(([key, value]) => {
-			const currentPath = `${path}.${key}`;
-
-			if (typeof key !== "string") {
-				throw new Error(
-					`Invalid key at ${currentPath}: Expected a string key, got ${typeof key}`
-				);
-			}
-
-			if (
-				value !== null &&
-				typeof value !== "string" &&
-				(!Array.isArray(value) ||
-					!value.every((item, index) => {
-						if (!isPrimitive(item)) {
-							throw new Error(
-								`Invalid array value at ${currentPath}[${index}]: Expected a primitive, got ${typeof item}`
-							);
-						}
-						return true;
-					}))
-			) {
-				throw new Error(
-					`Invalid value at ${currentPath}: ${JSON.stringify(value)}`
-				);
-			}
-		});
-	}
-}