ondc-code-generator 0.0.1 → 0.0.3

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)}`
-				);
-			}
-		});
-	}
-}