ondc-code-generator 0.0.1

package/src/generator/validators/tests-config/sub-validations.ts

@@ -0,0 +1,302 @@
+import {
+	TestObjectSyntax,
+	nodeReservedKeywords,
+	ExternalDataSyntax,
+	ConfigSyntax,
+} from "../../../constants/syntax.js";
+import { buildAst } from "../../../services/return-complier/ast.js";
+import { checkValidVariables } from "../../../services/return-complier/ast-functions/semantic-validations.js";
+import { parseReturnInput } from "../../../services/return-complier/parser.js";
+import { TestObject } from "../../../types/config-types.js";
+import { ErrorDefinition } from "../../../types/error-codes.js";
+import {
+	isSnakeCase,
+	isValidVariableName,
+} from "../../../utils/general-utils/string-utils.js";
+import { isValidVariableValueType } from "../../../utils/general-utils/validation-utils.js";
+import {
+	isValidJsonPath,
+	replaceBracketsWithAsteriskNested,
+} from "../../../utils/json-path-utils/paths.js";
+import {
+	TestObjectValidator,
+	TestsValidatorDependencies,
+} from "../abstract-validator.js";
+import { TestsValidator } from "./test-list-validator.js";
+import logger from "../../../utils/logger.js";
+
+export class RequiredFieldsValidator extends TestObjectValidator {
+	validate = async () => {
+		if (!this.targetObject[TestObjectSyntax.Name]) {
+			throw new Error(
+				`${TestObjectSyntax.Name} is required at path ${this.validationPath}`
+			);
+		}
+		if (!this.targetObject[TestObjectSyntax.Return]) {
+			throw new Error(
+				`${TestObjectSyntax.Return} is required at path ${this.validationPath}`
+			);
+		}
+	};
+}
+
+export class NameValidator extends TestObjectValidator {
+	validate = async () => {
+		if (typeof this.targetObject[TestObjectSyntax.Name] !== "string") {
+			throw new Error(
+				`${TestObjectSyntax.Name} should be a string at path ${this.validationPath}`
+			);
+		}
+		const name = this.targetObject[TestObjectSyntax.Name];
+		if (name.length < 1) {
+			throw new Error(
+				`${TestObjectSyntax.Name} can't be a non-empty string at path ${this.validationPath}`
+			);
+		}
+		if (nodeReservedKeywords.has(name)) {
+			throw new Error(
+				`${TestObjectSyntax.Name} can't be a reserved keyword at path ${this.validationPath}`
+			);
+		}
+		if (!isSnakeCase(name)) {
+			throw new Error(
+				`${TestObjectSyntax.Name} must be in snake_case at path ${this.validationPath}`
+			);
+		}
+	};
+}
+
+export class ScopeValidator extends TestObjectValidator {
+	impossiblePaths: string[];
+	constructor(testObject: TestObject, path: string, impossiblePaths: string[]) {
+		super(testObject, path);
+		this.impossiblePaths = impossiblePaths;
+	}
+	validate = async () => {
+		const path = this.targetObject[TestObjectSyntax.Scope];
+		if (typeof path !== "string") {
+			throw new Error(
+				`${TestObjectSyntax.Scope} should be a string at path ${this.validationPath}`
+			);
+		}
+		if (!isValidJsonPath(path)) {
+			throw new Error(
+				`${TestObjectSyntax.Scope} should be a valid json path at path ${this.validationPath}`
+			);
+		}
+		if (!path.startsWith(`$.`)) {
+			throw new Error(
+				`${TestObjectSyntax.Scope} json path should start with $. at ${this.validationPath}`
+			);
+		}
+		if (
+			this.impossiblePaths.includes(replaceBracketsWithAsteriskNested(path))
+		) {
+			throw new Error(
+				`${TestObjectSyntax.Scope} can't be a path that returns a array of string it must be a json path which returns a array of objects at path ${this.validationPath}`
+			);
+		}
+	};
+}
+
+export class ErrorCodeValidator extends TestObjectValidator {
+	possibleErrorCodes: ErrorDefinition[];
+	constructor(
+		testObject: TestObject,
+		path: string,
+		possibleErrorCodes: ErrorDefinition[]
+	) {
+		super(testObject, path);
+		this.possibleErrorCodes = possibleErrorCodes;
+	}
+	validate = async () => {
+		if (!this.targetObject[TestObjectSyntax.ErrorCode]) {
+			return;
+		}
+
+		if (typeof this.targetObject[TestObjectSyntax.Return] !== "string") {
+			throw new Error(
+				`You can't define a ${TestObjectSyntax.ErrorCode} with nested ${TestObjectSyntax.Return} at path ${this.validationPath}`
+			);
+		}
+
+		if (typeof this.targetObject[TestObjectSyntax.ErrorCode] !== "number") {
+			throw new Error(
+				`${TestObjectSyntax.ErrorCode} should be a number at path ${this.validationPath}`
+			);
+		}
+		const errorCode = this.targetObject[TestObjectSyntax.ErrorCode];
+		if (!this.possibleErrorCodes.some((code) => code.code === errorCode)) {
+			throw new Error(
+				`${TestObjectSyntax.ErrorCode} don't exist in error codes at path ${this.validationPath}`
+			);
+		}
+
+		if (!this.targetObject[TestObjectSyntax.SuccessCode]) {
+			return;
+		}
+		if (typeof this.targetObject[TestObjectSyntax.SuccessCode] !== "number") {
+			throw new Error(
+				`${TestObjectSyntax.SuccessCode} should be a number at path ${this.validationPath}`
+			);
+		}
+	};
+}
+
+export class VariableValidator extends TestObjectValidator {
+	possibleJsonPaths: string[];
+	externalVariables: string[];
+	constructor(
+		testObject: TestObject,
+		path: string,
+		posibleJsonPaths: string[],
+		externalVariables: string[]
+	) {
+		super(testObject, path);
+		this.externalVariables = externalVariables;
+		this.possibleJsonPaths = posibleJsonPaths;
+	}
+	validate = async () => {
+		for (const key in this.targetObject) {
+			if (Object.values(TestObjectSyntax).includes(key as TestObjectSyntax)) {
+				continue;
+			}
+			this.validateKey(key);
+			const value = this.targetObject[key];
+			console.log(value);
+			if (!isValidVariableValueType(value)) {
+				throw new Error(
+					`Variable: ${key} should be a string or array of primitives at path ${this.validationPath}`
+				);
+			}
+			if (typeof value === "string") {
+				if (!isValidJsonPath(value)) {
+					throw new Error(
+						`Variable: ${key} should be a valid jsonPath at ${this.validationPath}`
+					);
+				}
+				if (!value.startsWith(`$.`)) {
+					throw new Error(
+						`Variable: ${key} should start with $. at ${this.validationPath}`
+					);
+				}
+				if (value.startsWith(`$.${ExternalDataSyntax}`)) {
+					this.validateExternalData(value, this.externalVariables);
+					return;
+				}
+
+				let path = value;
+				if (this.targetObject[TestObjectSyntax.Scope]) {
+					const scope = this.targetObject[TestObjectSyntax.Scope];
+					const pathWithoutDollar = path.slice(2);
+					path = `${scope}.${pathWithoutDollar}`;
+				}
+				const replaced = replaceBracketsWithAsteriskNested(path);
+				if (!this.possibleJsonPaths.includes(replaced)) {
+					throw new Error(
+						`Variable: ${key} should be a jsonPath that returns a array of strings or the path don't exist in the schema, at ${this.validationPath} found original ${path} replaces: ${replaced}`
+					);
+				}
+			}
+		}
+	};
+
+	validateKey(key: string) {
+		if (nodeReservedKeywords.has(key)) {
+			throw new Error(
+				`${key} can't be a reserved keyword at path ${this.validationPath}`
+			);
+		}
+		if (key.includes(" ")) {
+			throw new Error(
+				`${key} can't contain spaces at path ${this.validationPath}`
+			);
+		}
+		if (key === this.targetObject[TestObjectSyntax.Name]) {
+			throw new Error(
+				`${key} can't be the same as ${TestObjectSyntax.Name} at path ${this.validationPath}`
+			);
+		}
+		if (!isValidVariableName(key)) {
+			throw new Error(
+				`${key} is not a valid variable name at path ${this.validationPath}`
+			);
+		}
+	}
+	validateExternalData(path: string, definedExternalValues: string[]) {
+		const externalData = path.split(".")[2];
+		if (!definedExternalValues.includes(externalData)) {
+			throw new Error(
+				`${externalData} is not defined in ${ConfigSyntax.SessionData} data at path ${this.validationPath}`
+			);
+		}
+	}
+}
+
+export class ContinueValidator extends TestObjectValidator {
+	definedVariables: string[];
+	constructor(testObject: TestObject, path: string) {
+		super(testObject, path);
+		this.definedVariables = Object.keys(testObject).filter(
+			(key) =>
+				!Object.values(TestObjectSyntax).includes(key as TestObjectSyntax)
+		);
+	}
+	validate = async () => {
+		try {
+			const contStatement = this.targetObject[TestObjectSyntax.Continue];
+			if (typeof contStatement === "string") {
+				const cst = parseReturnInput(contStatement);
+				const ast = buildAst(cst);
+				checkValidVariables(ast, this.definedVariables, this.validationPath);
+				return;
+			}
+			throw new Error(
+				`${TestObjectSyntax.Continue} should be a string at path ${this.validationPath}`
+			);
+		} catch (err: any) {
+			throw new Error(err.message + " at path " + this.validationPath);
+		}
+	};
+}
+
+export class ReturnValidator extends TestObjectValidator {
+	definedVariables: string[];
+	dependencies: TestsValidatorDependencies;
+	constructor(
+		testObject: TestObject,
+		path: string,
+		dependencies: TestsValidatorDependencies
+	) {
+		super(testObject, path);
+		this.definedVariables = Object.keys(testObject).filter(
+			(key) =>
+				!Object.values(TestObjectSyntax).includes(key as TestObjectSyntax)
+		);
+		this.dependencies = dependencies;
+	}
+	validate = async () => {
+		try {
+			const returnStatement = this.targetObject[TestObjectSyntax.Return];
+			if (typeof returnStatement === "string") {
+				const cst = parseReturnInput(returnStatement);
+				const ast = buildAst(cst);
+				checkValidVariables(ast, this.definedVariables, this.validationPath);
+				return;
+			}
+			if (Array.isArray(returnStatement)) {
+				await new TestsValidator(
+					returnStatement,
+					this.validationPath,
+					this.dependencies
+				).validate();
+				return;
+			}
+			throw new Error(
+				`${TestObjectSyntax.Return} should be a string or arrays`
+			);
+		} catch (err: any) {
+			throw new Error(err.message + " at path " + this.validationPath);
+		}
+	};
+}

package/src/generator/validators/tests-config/test-list-validator.ts

@@ -0,0 +1,59 @@
+import { TestObjectSyntax } from "../../../constants/syntax.js";
+import { TestObject } from "../../../types/config-types.js";
+import {
+	IValidator,
+	TestsValidatorDependencies,
+} from "../abstract-validator.js";
+import { CompleteTestObjectValidator } from "./test-validator.js";
+
+export class TestsValidator implements IValidator {
+	tests: TestObject[];
+	validationPath: string;
+	dependencies: TestsValidatorDependencies;
+	constructor(
+		tests: TestObject[],
+		configPath: string,
+		dependencies: TestsValidatorDependencies
+	) {
+		this.tests = tests;
+		this.validationPath = configPath;
+		this.dependencies = dependencies;
+	}
+	validate = async () => {
+		this.validateDuplicateNames();
+		let i = 0;
+		for (const test of this.tests) {
+			const newPath = `${this.validationPath}/${i}/${TestObjectSyntax.Name} = ${
+				test[TestObjectSyntax.Name]
+			}`;
+			await new CompleteTestObjectValidator(
+				test,
+				newPath,
+				this.dependencies
+			).validate();
+			i++;
+		}
+	};
+
+	validateDuplicateNames = () => {
+		const seen = new Set();
+		const duplicates = new Set();
+
+		this.tests.forEach((test) => {
+			const name = test[TestObjectSyntax.Name];
+			if (seen.has(name)) {
+				duplicates.add(name); // Add to duplicates if already seen
+			} else {
+				seen.add(name); // Track seen names
+			}
+		});
+
+		if (duplicates.size > 0) {
+			throw new Error(
+				`Duplicate test names found at ${this.validationPath}: ${[
+					...duplicates,
+				].join(", ")}`
+			);
+		}
+	};
+}

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

@@ -0,0 +1,69 @@
+import { TestObjectSyntax } from "../../../constants/syntax.js";
+import { TestObject } from "../../../types/config-types.js";
+
+import {
+	TestObjectValidator,
+	TestsValidatorDependencies,
+} from "../abstract-validator.js";
+import {
+	RequiredFieldsValidator,
+	NameValidator,
+	ScopeValidator,
+	ErrorCodeValidator,
+	VariableValidator,
+	ContinueValidator,
+	ReturnValidator,
+} from "./sub-validations.js";
+
+export class CompleteTestObjectValidator extends TestObjectValidator {
+	dependencies: TestsValidatorDependencies;
+	constructor(
+		testObject: TestObject,
+		path: string,
+		dependencies: TestsValidatorDependencies
+	) {
+		super(testObject, path);
+		this.dependencies = dependencies;
+	}
+	validate = async () => {
+		await new RequiredFieldsValidator(
+			this.targetObject,
+			this.validationPath
+		).validate();
+		await new NameValidator(this.targetObject, this.validationPath).validate();
+
+		if (this.targetObject[TestObjectSyntax.Scope]) {
+			await new ScopeValidator(
+				this.targetObject,
+				this.validationPath,
+				this.dependencies.stringJsonPaths
+			).validate();
+		}
+
+		if (this.targetObject[TestObjectSyntax.ErrorCode]) {
+			await new ErrorCodeValidator(
+				this.targetObject,
+				this.validationPath,
+				this.dependencies.errorDefinitions
+			).validate();
+		}
+
+		await new VariableValidator(
+			this.targetObject,
+			this.validationPath,
+			this.dependencies.stringJsonPaths,
+			this.dependencies.externalVariables
+		).validate();
+		if (this.targetObject[TestObjectSyntax.Continue]) {
+			await new ContinueValidator(
+				this.targetObject,
+				this.validationPath
+			).validate();
+		}
+		await new ReturnValidator(
+			this.targetObject,
+			this.validationPath,
+			this.dependencies
+		).validate();
+	};
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+import { ConfigCompiler } from "./generator/config-compiler.js";
+export { ConfigCompiler };

package/src/services/return-complier/ast-functions/compile-to-markdown.ts

@@ -0,0 +1,152 @@
+import logger from "../../../utils/logger.js";
+import {
+	AstNode,
+	BinaryOperatorNode,
+	CustomBinaryFunction,
+	CustomUniaryFunction,
+	NotOperatorNode,
+	ReturnStatementNode,
+} from "../ast.js";
+import {
+	AllIn,
+	AnyIn,
+	AreUnique,
+	ArePresent,
+	EqualTo,
+	FollowRegex,
+	GreaterThan,
+	LessThan,
+	NoneIn,
+} from "../tokens.js";
+
+const uniaryMessages = {
+	[AreUnique.LABEL ?? "are unique"]: (variable: string, forNot: boolean) =>
+		`all values of {{{${variable}}}} must${forNot ? " **not**" : ""} be unique`,
+	[ArePresent.LABEL ?? "are present"]: (variable: string, forNot: boolean) =>
+		`{{{${variable}}}} must${forNot ? " **not**" : ""} be present in the payload`,
+};
+const binaryMessages = {
+	[AllIn.LABEL ?? "all in"]: (lhs: string, rhs: string, forNot: boolean) =>
+		`every element of {{{${lhs}}}} must${
+			forNot ? " **not**" : ""
+		} be in {{{${rhs}}}}`,
+	[AnyIn.LABEL ?? "any in"]: (lhs: string, rhs: string, forNot: boolean) =>
+		`at least one element of {{{${lhs}}}} must${
+			forNot ? " **not**" : ""
+		} be in {{{${rhs}}}}`,
+	[FollowRegex.LABEL ?? "follow regex"]: (
+		lhs: string,
+		rhs: string,
+		forNot: boolean
+	) =>
+		`all elements of {{{${lhs}}}} must${
+			forNot ? " **not**" : ""
+		} follow every regex in {{{${rhs}}}}`,
+	[NoneIn.LABEL ?? "none in"]: (lhs: string, rhs: string, forNot: boolean) =>
+		`no element of {{{${lhs}}}} must${
+			forNot ? " **not**" : ""
+		} be in {{{${rhs}}}}`,
+	[EqualTo.LABEL ?? "equal to"]: (lhs: string, rhs: string, forNot: boolean) =>
+		`{{{${lhs}}}} must${forNot ? " **not**" : ""} be equal to {{{${rhs}}}}`,
+	[GreaterThan.LABEL ?? "greater than"]: (
+		lhs: string,
+		rhs: string,
+		forNot: boolean
+	) =>
+		`{{{${lhs}}}} must${forNot ? " **not**" : ""} be greater than {{{${rhs}}}}`,
+	[LessThan.LABEL ?? "less than"]: (
+		lhs: string,
+		rhs: string,
+		forNot: boolean
+	) => `{{{${lhs}}}} must${forNot ? " **not**" : ""} be less than {{{${rhs}}}}`,
+};
+
+export function CompileToMarkdown(
+	ast: AstNode,
+	pointer: string,
+	depth = 0,
+	forNot: boolean
+): string {
+	const indent = "  ".repeat(depth); // 2 spaces per depth level
+
+	// Helper function to indent multi-line strings
+	function indentMultilineString(str: string, indentLevel: number): string {
+		const subIndent = "  ".repeat(indentLevel);
+		return str
+			.split("\n")
+			.map((line) => subIndent + line)
+			.join("\n");
+	}
+
+	if (ast.type === "returnStatement") {
+		const returnStatement = ast as ReturnStatementNode;
+		const generated = CompileToMarkdown(
+			returnStatement.expression,
+			`${pointer}`,
+			depth,
+			forNot
+		);
+		return `${generated}`;
+	}
+	if (ast.type === "binaryOperator") {
+		const binary = ast as BinaryOperatorNode;
+		const subMdLhs = CompileToMarkdown(
+			binary.lhs,
+			getNextPointer(pointer, 1),
+			depth + 1,
+			forNot
+		);
+		const subMdRhs = CompileToMarkdown(
+			binary.rhs,
+			getNextPointer(pointer, 2),
+			depth + 1,
+			forNot
+		);
+
+		const indentedSubMdLhs = indentMultilineString(subMdLhs, 0); // LHS already indented
+		const indentedSubMdRhs = indentMultilineString(subMdRhs, 0); // RHS already indented
+
+		if (binary.operator === "&&") {
+			return `${indent}- **condition ${pointer}**: all of the following sub conditions must${
+				forNot ? "**not**" : ""
+			} be met:\n\n${indentedSubMdLhs}\n${indentedSubMdRhs}`;
+		}
+		if (binary.operator === "||") {
+			return `${indent}- **condition ${pointer}**: any one of the following sub conditions must${
+				forNot ? "**not**" : ""
+			} be met:\n\n${indentedSubMdLhs}\n${indentedSubMdRhs}`;
+		}
+	}
+	if (ast.type === "notOperator") {
+		const not = ast as NotOperatorNode;
+		return CompileToMarkdown(not.expression, pointer, depth, !forNot);
+	}
+	if (ast.type === "customUniaryFunction") {
+		const customFunction = ast as CustomUniaryFunction;
+		const func = customFunction.customFunction;
+		const messageFunction = uniaryMessages[func as keyof typeof uniaryMessages];
+		const lhs = customFunction.expression;
+		return `${indent}- **condition ${pointer}**: ${messageFunction(
+			lhs.name,
+			forNot
+		)}`;
+	}
+	if (ast.type === "customBinaryFunction") {
+		const customFunction = ast as CustomBinaryFunction;
+		const func = customFunction.customFunction;
+		const messageFunction = binaryMessages[func as keyof typeof binaryMessages];
+		const lhs = customFunction.lhs;
+		const rhs = customFunction.rhs;
+		return `${indent}- **condition ${pointer}**: ${messageFunction(
+			lhs.name,
+			rhs.name,
+			forNot
+		)}`;
+	}
+
+	throw new Error("Invalid AST node:" + JSON.stringify(ast));
+}
+
+function getNextPointer(currentPointer: string, nextIndex: number): string {
+	return `${currentPointer}.${nextIndex}`;
+}

package/src/services/return-complier/ast-functions/semantic-validations.ts

@@ -0,0 +1,44 @@
+import {
+	AstNode,
+	BinaryOperatorNode,
+	CustomBinaryFunction,
+	CustomUniaryFunction,
+	IdentifierNode,
+	NotOperatorNode,
+	ReturnStatementNode,
+} from "../ast";
+
+export function checkValidVariables(
+	ast: AstNode,
+	validVariables: string[],
+	path?: string
+): void {
+	if (ast.type === "identifier") {
+		const identifier = ast as IdentifierNode;
+		if (!validVariables.includes(identifier.name)) {
+			throw new Error(`Invalid variable ${identifier.name} at path ${path}`);
+		}
+	}
+	if (ast.type === "returnStatement") {
+		const returnStatement = ast as ReturnStatementNode;
+		checkValidVariables(returnStatement.expression, validVariables, path);
+	}
+	if (ast.type === "binaryOperator") {
+		const binaryOperator = ast as BinaryOperatorNode;
+		checkValidVariables(binaryOperator.lhs, validVariables, path);
+		checkValidVariables(binaryOperator.rhs, validVariables, path);
+	}
+	if (ast.type === "notOperator") {
+		const notOperator = ast as NotOperatorNode;
+		checkValidVariables(notOperator.expression, validVariables, path);
+	}
+	if (ast.type === "customBinaryFunction") {
+		const customBinaryFunction = ast as CustomBinaryFunction;
+		checkValidVariables(customBinaryFunction.lhs, validVariables, path);
+		checkValidVariables(customBinaryFunction.rhs, validVariables, path);
+	}
+	if (ast.type === "customUniaryFunction") {
+		const customUniaryFunction = ast as CustomUniaryFunction;
+		checkValidVariables(customUniaryFunction.expression, validVariables, path);
+	}
+}