ondc-code-generator 0.0.2 → 0.0.4

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

@@ -1,302 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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/services/return-complier/ast-functions/compile-to-markdown.ts

@@ -1,152 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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);
-	}
-}