ondc-code-generator 0.0.1

package/src/constants/operations.ts

@@ -0,0 +1,19 @@
+export const LOGICAL_OPERATORS = ["&&", "||"];
+export const COMPARISON_OPERATORS = ["==", "!=", ">", ">=", "<", "<="];
+export const ARITHMETIC_OPERATORS = ["+", "-", "*", "/"];
+export const UNARY_OPERATORS = ["!"];
+
+export const PREDEFINED_CONDITIONS = [
+	"ALL_IN",
+	"ANY_IN",
+	"NONE_IN",
+	"ARE_UNIQUE",
+	"FOLLOW_REGEX",
+];
+
+export const OPERATORS = [
+	...LOGICAL_OPERATORS,
+	...COMPARISON_OPERATORS,
+	...ARITHMETIC_OPERATORS,
+	...UNARY_OPERATORS,
+];

package/src/constants/syntax.ts

@@ -0,0 +1,81 @@
+export enum TestObjectSyntax {
+	Name = "_NAME_",
+	Return = "_RETURN_",
+	Scope = "_SCOPE_",
+	Continue = "_CONTINUE_",
+	ErrorCode = "_ERROR_CODE_",
+	SuccessCode = "_SUCCESS_CODE_",
+}
+
+export const ExternalDataSyntax = "_EXTERNAL";
+
+export enum ConfigSyntax {
+	Tests = "_TESTS_",
+	SessionData = "_SESSION_DATA_",
+}
+
+export const ConfigKeyWords = [
+	TestObjectSyntax.Name,
+	TestObjectSyntax.Return,
+	TestObjectSyntax.Scope,
+	TestObjectSyntax.Continue,
+	TestObjectSyntax.ErrorCode,
+	TestObjectSyntax.SuccessCode,
+	ConfigSyntax.Tests,
+	ConfigSyntax.SessionData,
+];
+
+// JavaScript/Node.js keywords
+export const nodeReservedKeywords = new Set([
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"export",
+	"extends",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"import",
+	"in",
+	"instanceof",
+	"let",
+	"new",
+	"return",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with",
+	"yield",
+
+	// Additional Node.js/ECMAScript-specific keywords
+	"async",
+	"await",
+	"arguments",
+	"eval",
+	"of",
+
+	// Reserved but may not yet be used in JavaScript
+	"enum",
+	"implements",
+	"interface",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"static",
+]);

package/src/example.ts

@@ -0,0 +1,25 @@
+// import { readFileSync } from "fs";
+
+// import path from "path";
+// import { fileURLToPath } from "url";
+// import { SupportedLanguages } from "./types/compiler-types.js";
+
+// const __filename = fileURLToPath(import.meta.url);
+// const __dirname = path.dirname(__filename);
+
+// const main = async () => {
+// 	const compiler = new ConfigCompiler(SupportedLanguages.Typescript);
+// 	const buildPath = path.resolve(__dirname, "../samples/build.yaml");
+// 	const valConfigPath = path.resolve(
+// 		__dirname,
+// 		"../samples/validation-config.json"
+// 	);
+// 	const buildYaml = readFileSync(buildPath, "utf-8");
+// 	const valConfig = JSON.parse(readFileSync(valConfigPath, "utf-8"));
+// 	await compiler.initialize(buildYaml);
+// 	await compiler.generateCode(valConfig);
+// };
+
+// (async () => {
+// 	await main();
+// })();

package/src/generator/config-compiler.ts

@@ -0,0 +1,122 @@
+import { JSONSchema7 } from "json-schema";
+import { BUID_TYPE } from "../types/build.js";
+import { loadAndDereferenceYaml } from "../utils/config-utils/yaml.js";
+import { SchemaExtactionService } from "../services/schema-service.js";
+import { ErrorDefinition } from "../types/error-codes.js";
+import { ValidationConfig } from "../types/config-types.js";
+import logger from "../utils/logger.js";
+import { SupportedLanguages } from "../types/compiler-types.js";
+
+import { TypescriptGenerator } from "./generators/typescript/ts-generator.js";
+import { ConfigValidator } from "./validators/config-validator.js";
+import { writeAndFormatCode } from "../utils/fs-utils.js";
+import { readFileSync } from "fs";
+import path from "path";
+import Mustache from "mustache";
+
+type CodeGeneratorConfig = {
+	removeRequiredfromSchema: boolean;
+	removeEnumsfromSchema: boolean;
+};
+
+const defaultConfig: CodeGeneratorConfig = {
+	removeRequiredfromSchema: true,
+	removeEnumsfromSchema: true,
+};
+
+export class ConfigCompiler {
+	buildData: BUID_TYPE | undefined;
+	jsonSchemas: Record<string, JSONSchema7> | undefined;
+	possibleJsonPaths: Record<string, string[]> | undefined;
+	errorDefinitions: ErrorDefinition[] | undefined;
+	language: SupportedLanguages;
+	private SchemaExtactionService: SchemaExtactionService;
+	constructor(language: SupportedLanguages) {
+		this.language = language;
+		this.SchemaExtactionService = new SchemaExtactionService();
+	}
+	// 1. extract build, create schemas , extract possible paths , extract errorcodes
+	initialize = async (
+		buildYaml: string,
+		generatorConfig: Partial<CodeGeneratorConfig> = {}
+	) => {
+		const finalConfig = { ...defaultConfig, ...generatorConfig };
+		this.buildData = await loadAndDereferenceYaml<BUID_TYPE>(buildYaml);
+		this.jsonSchemas = await this.SchemaExtactionService.extractSchemas(
+			this.buildData,
+			finalConfig.removeRequiredfromSchema,
+			finalConfig.removeEnumsfromSchema
+		);
+		this.possibleJsonPaths = this.SchemaExtactionService.extractPossiblePaths(
+			this.jsonSchemas
+		);
+		const errors = this.buildData["x-errorcodes"];
+		this.errorDefinitions = errors.code;
+	};
+
+	performValidations = async (valConfig: ValidationConfig) => {
+		try {
+			if (!this.buildData) throw new Error("Build data not initialized");
+			if (!this.jsonSchemas) throw new Error("Schemas not initialized");
+			if (!this.possibleJsonPaths)
+				throw new Error("Possible paths not initialized");
+			if (!this.errorDefinitions)
+				throw new Error("Error definitions not initialized");
+
+			await new ConfigValidator(
+				"",
+				valConfig,
+				this.possibleJsonPaths,
+				this.errorDefinitions
+			).validate();
+		} catch (e) {
+			logger.error(e);
+			throw new Error("Validation failed");
+		}
+	};
+
+	generateCode = async (valConfig: ValidationConfig) => {
+		await this.performValidations(valConfig);
+		// Generate code based on the language
+		switch (this.language) {
+			case SupportedLanguages.Typescript:
+				await new TypescriptGenerator(
+					valConfig,
+					this.errorDefinitions ?? [],
+					"./generated/L1-validations"
+				).generateCode();
+				break;
+			default:
+				throw new Error("Language not supported");
+		}
+	};
+
+	generateL0Schema = async () => {
+		if (!this.jsonSchemas) {
+			throw new Error("Schemas not initialized");
+		}
+
+		for (const schema in this.jsonSchemas) {
+			const json = this.jsonSchemas[schema];
+			writeAndFormatCode(
+				`./generated/L0-schemas`,
+				`${schema}.ts`,
+				`export const ${schema} = ${JSON.stringify(json, null, 2)}`,
+				"typescript"
+			);
+		}
+
+		const actions = Object.keys(this.jsonSchemas).map((schema) => {
+			return {
+				action: schema,
+			};
+		});
+		const template = readFileSync(
+			"/Users/rudranshsinghal/ondc/automation-utility/official-code/code-generator/src/generator/generators/typescript/templates/schema-template.mustache",
+			"utf-8"
+		);
+		console.log(actions);
+		const l0 = Mustache.render(template, { actions });
+		writeAndFormatCode(`./generated/L0-schemas`, `index.ts`, l0, "typescript");
+	};
+}

package/src/generator/generators/classes/abstract-generator.ts

@@ -0,0 +1,29 @@
+import { ValidationConfig } from "../../../types/config-types";
+import { ErrorDefinition } from "../../../types/error-codes";
+
+/*
+    1. generate code for session_data 
+        1. a function take in payload and update the session_data in cache
+        2. get function which returns the session_data object 
+    2. generate code for test-objects
+        1. single test object generation
+            1. handle nested 
+        2. combine all the tests
+*/
+export abstract class CodeGenerator {
+	validationConfig: ValidationConfig;
+	rootPath: string;
+	errorCodes: ErrorDefinition[];
+	constructor(
+		validationConfig: ValidationConfig,
+		errorCodes: ErrorDefinition[],
+		rootPath = "./"
+	) {
+		this.validationConfig = validationConfig;
+		this.rootPath = rootPath;
+		this.errorCodes = errorCodes;
+	}
+	abstract generateSessionDataCode(): Promise<void>;
+	abstract generateValidationCode(): Promise<void>;
+	abstract generateCode(): Promise<void>;
+}

package/src/generator/generators/documentation/markdown-message-generator.ts

@@ -0,0 +1,43 @@
+import { CompileToMarkdown } from "../../../services/return-complier/ast-functions/compile-to-markdown.js";
+import { buildAstFromInput } from "../../../services/return-complier/combined.js";
+import { TestObject } from "../../../types/config-types.js";
+import Mustache from "mustache";
+import {
+	addBlockquoteToMarkdown,
+	addTabToMarkdown,
+	ConvertArrayToStringsInTestObject,
+} from "../../../utils/general-utils/string-utils.js";
+
+export function markdownMessageGenerator(
+	returnInput: string,
+	variableValues: TestObject,
+	startingPointer: string,
+	skipInput?: string[]
+) {
+	const ast = buildAstFromInput(returnInput);
+	const returnTemplate = CompileToMarkdown(ast, startingPointer, 0, false);
+
+	let finalReturn = Mustache.render(
+		returnTemplate,
+		ConvertArrayToStringsInTestObject(variableValues)
+	);
+	if (skipInput) {
+		let skipMarkdown = `Note: **Condition ${startingPointer}** can be skipped if the following conditions are met:`;
+		const letters = "BCDEFGHIJKLMNOPQRSTUVWXYZ";
+		let index = 0;
+		for (const skip of skipInput) {
+			const skipAst = buildAstFromInput(skip);
+			const skipTemplate = CompileToMarkdown(skipAst, letters[index], 0, false);
+			const finalSkip = Mustache.render(
+				skipTemplate,
+				ConvertArrayToStringsInTestObject(variableValues)
+			);
+			skipMarkdown += `\n\n${finalSkip}`;
+			index++;
+		}
+		const blockSkip = addTabToMarkdown(addBlockquoteToMarkdown(skipMarkdown));
+		finalReturn += `\n\n${blockSkip}`;
+	}
+
+	return finalReturn;
+}

package/src/generator/generators/documentation/md-generator.ts

@@ -0,0 +1,76 @@
+import { ConfigSyntax, TestObjectSyntax } from "../../../constants/syntax.js";
+import { TestObject } from "../../../types/config-types.js";
+import { CodeGenerator } from "../classes/abstract-generator.js";
+import { markdownMessageGenerator } from "./markdown-message-generator.js";
+import { writeFileWithFsExtra } from "../../../utils/fs-utils.js";
+import { marked } from "marked";
+
+import Mustache from "mustache";
+
+import { readFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { addTabToMarkdown } from "../../../utils/general-utils/string-utils.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export class MarkdownDocGenerator extends CodeGenerator {
+	generateSessionDataCode(): Promise<void> {
+		throw new Error("Method not implemented.");
+	}
+	generateValidationCode = async () => {
+		const testConfig = this.validationConfig[ConfigSyntax.Tests];
+		let finalMarkdown = "";
+		for (const key in testConfig) {
+			const testObjects = testConfig[key];
+			const betaConfig = {
+				[TestObjectSyntax.Name]: key,
+				[TestObjectSyntax.Return]: testObjects,
+			};
+			const md = this.generateMarkdownForTest(betaConfig);
+			finalMarkdown += `\n\n${md}`;
+		}
+		const cssData = readFileSync(
+			path.resolve(__dirname, "./templates/style.css"),
+			"utf-8"
+		);
+		const htmlTemplate = readFileSync(
+			path.resolve(__dirname, "./templates/index.mustache"),
+			"utf-8"
+		);
+		writeFileWithFsExtra(this.rootPath, "./readme.md", finalMarkdown);
+		writeFileWithFsExtra(
+			this.rootPath,
+			"./page/index.html",
+			Mustache.render(htmlTemplate, {
+				content: await this.generateHtmlCode(finalMarkdown),
+			})
+		);
+		writeFileWithFsExtra(this.rootPath, "./page/style.css", cssData);
+	};
+	generateCode = async () => {
+		await this.generateValidationCode();
+	};
+
+	generateMarkdownForTest = (testObject: TestObject): string => {
+		const ret = testObject[TestObjectSyntax.Return];
+		if (typeof ret === "string") {
+			const skip = testObject[TestObjectSyntax.Continue];
+			return markdownMessageGenerator(
+				ret,
+				testObject,
+				testObject[TestObjectSyntax.Name],
+				skip ? [skip] : undefined
+			);
+		}
+		const subMardowns = ret.map((r) => {
+			return this.generateMarkdownForTest(r);
+		});
+
+		return `- **${testObject[TestObjectSyntax.Name]}** : All the following sub conditions must pass as per the api requirement\n\n${addTabToMarkdown(subMardowns.join("\n\n"))}`;
+	};
+
+	generateHtmlCode = async (markdownData: string) => {
+		return await marked(markdownData);
+	};
+}

package/src/generator/generators/documentation/templates/index.mustache

@@ -0,0 +1,36 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>API SERVICE VALIDATIONS</title>
+    <!-- Link to the CSS file -->
+    <link rel="stylesheet" href="./style.css">
+</head>
+<body>
+    <div id="content">
+        <h2>List of validations of api</h2>
+        {{{content}}}
+    </div>
+</body>
+<script>
+    document.addEventListener('DOMContentLoaded', function() {
+        // Select all list items that have a nested <ul> (collapsible items)
+        const collapsibleItems = document.querySelectorAll('li > ul');
+
+        collapsibleItems.forEach(function(nestedList) {
+            const parentLi = nestedList.parentElement;
+            parentLi.classList.add('collapsible', 'collapsed');
+
+            // Add click event listener to the <p> inside the list item
+            const clickableArea = parentLi.querySelector('p');
+            clickableArea.addEventListener('click', function(e) {
+                // Prevent click events on links inside the <p>
+                if (e.target.tagName !== 'A') {
+                    parentLi.classList.toggle('collapsed');
+                }
+            });
+        });
+    });
+</script>
+</html>

package/src/generator/generators/documentation/templates/style.css

@@ -0,0 +1,204 @@
+/* RESET DEFAULT STYLES */
+body, ul, li, p, blockquote {
+	margin: 0;
+	padding: 0;
+}
+ul, li {
+	list-style: none;
+}
+
+/* BODY STYLES */
+body {
+	font-family: "Helvetica Neue", Arial, sans-serif;
+	background-color: #ffffff; /* Light background */
+	color: #333333; /* Dark text */
+	line-height: 1.8;
+	padding: 20px;
+}
+
+/* LIST STYLES */
+ul {
+	padding-left: 20px;
+}
+
+li {
+	margin-bottom: 16px;
+	position: relative;
+}
+
+li > p {
+	margin-bottom: 8px;
+	background-color: #f7f7f7; /* Light background */
+	color: #555555; /* Dark text */
+	padding: 10px 15px;
+	border: 1px solid #ddd;
+	border-radius: 5px;
+	box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+	transition: background-color 0.3s, border 0.3s, box-shadow 0.3s;
+}
+
+li > p:hover {
+	background-color: #e8e8e8;
+	border-color: #1296d9; /* Updated to blue accent color */
+	box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2);
+}
+
+/* NESTED LIST ITEMS */
+ul ul li > p {
+	background-color: #f0f0f0; /* Slightly darker than parent */
+}
+
+ul ul li > p:hover {
+	background-color: #e0e0e0;
+}
+
+/* HEADINGS AND EMPHASIS TEXT */
+h2,
+li > p > strong {
+	color: #1296d9; /* Changed header color to match blue theme */
+	font-weight: 600;
+}
+
+li > p > strong {
+	font-size: 1.1em;
+}
+
+/* BLOCKQUOTE STYLES */
+blockquote {
+	margin: 15px 0;
+	padding: 15px 20px;
+	background-color: #f7f7f7;
+	border-left: 5px solid #1296d9; /* Updated border to blue */
+	color: #555555;
+	font-style: italic;
+	box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+	transition: background-color 0.3s, border-left-color 0.3s, box-shadow 0.3s;
+}
+
+blockquote:hover {
+	background-color: #e8e8e8;
+	border-left-color: #1296d9; /* Updated hover border to blue */
+	box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2);
+}
+
+/* BLOCKQUOTE INTERNAL ELEMENTS */
+blockquote > p {
+	margin-bottom: 12px;
+	padding: 10px 15px;
+	background-color: #f7f7f7;
+	border-radius: 5px;
+	font-size: 1em;
+	box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+	transition: background-color 0.3s, border 0.3s, box-shadow 0.3s;
+}
+
+blockquote > p:hover {
+	background-color: #e8e8e8;
+	border: 1px solid #1296d9; /* Updated border to blue on hover */
+	box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2);
+}
+
+blockquote > ul {
+	padding-left: 20px;
+	margin-top: 10px;
+}
+
+blockquote > ul > li {
+	margin-bottom: 16px;
+	position: relative;
+	background-color: #f7f7f7;
+	padding: 10px 15px;
+	border: 1px solid #ddd;
+	border-radius: 5px;
+	box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+	transition: background-color 0.3s, border 0.3s, box-shadow 0.3s;
+}
+
+blockquote > ul > li:hover {
+	background-color: #e8e8e8;
+	border-color: #1296d9; /* Updated border to blue on hover */
+	box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2);
+}
+
+blockquote > ul > li > strong {
+	color: #1296d9; /* Changed to blue for emphasis */
+	font-weight: 600;
+	font-size: 1.1em;
+}
+
+blockquote > ul > li > ul {
+	padding-left: 20px;
+	margin-top: 8px;
+}
+
+blockquote > ul > li > ul > li {
+	background-color: #f0f0f0;
+	padding: 8px 12px;
+	border: 1px solid #ccc;
+	border-radius: 4px;
+	box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+	transition: background-color 0.3s, border 0.3s, box-shadow 0.3s;
+}
+
+blockquote > ul > li > ul > li:hover {
+	background-color: #e0e0e0;
+	border-color: #1296d9; /* Updated border to blue on hover */
+	box-shadow: 0 2px 5px rgba(0, 0, 0, 0.2);
+}
+
+/* COLLAPSIBLE INDICATORS */
+li.collapsible > p {
+	cursor: pointer;
+}
+
+li.collapsible > p::before {
+	content: "▼";
+	display: inline-block;
+	margin-right: 8px;
+	transition: transform 0.3s, color 0.3s;
+	color: #1296d9; /* Updated color to blue */
+}
+
+li.collapsible.collapsed > p::before {
+	transform: rotate(-90deg);
+}
+
+li.collapsible > p:hover::before {
+	color: #1296d9; /* Lighter blue on hover */
+}
+
+/* Hide nested lists by default */
+li.collapsible.collapsed > ul {
+	display: none;
+}
+
+/* RESPONSIVE DESIGN */
+@media only screen and (max-width: 768px) {
+	body {
+		padding: 15px;
+	}
+	ul {
+		padding-left: 15px;
+	}
+	li > p,
+	blockquote > p,
+	blockquote > ul > li {
+		font-size: 0.95em;
+		padding: 8px 12px;
+	}
+}
+
+/* CUSTOM SCROLLBAR */
+::-webkit-scrollbar {
+	width: 8px;
+	background-color: #ffffff;
+}
+
+::-webkit-scrollbar-thumb {
+	background-color: #ccc;
+	border-radius: 10px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+	background-color: #bbb;
+}

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

@@ -0,0 +1,7 @@
+import payloadUtils from "../utils/json-path-utils";
+import validations from "../utils/validation-utils";
+import { testFunctionArray, validationInput, validationOutput } from "../types/test-config";
+
+
+
+export default {{{functionCode}}}

package/src/generator/generators/typescript/templates/json-path-utils.ts

@@ -0,0 +1,17 @@
+import jsonpath from "jsonpath";
+function getJsonPath(payload: any, path: string) {
+	let output = jsonpath.query(payload, path);
+	if (isListOfStringsOrNull(output)) {
+		output = output.map((o) => (o === null ? "null" : o));
+	}
+	return output.length === 0 ? [] : output;
+}
+function isListOfStringsOrNull(variable: any): boolean {
+	return (
+		Array.isArray(variable) &&
+		variable.every((item) => item === null || typeof item === "string")
+	);
+}
+export default {
+	getJsonPath,
+};

package/src/generator/generators/typescript/templates/schema-template.mustache

@@ -0,0 +1,18 @@
+
+
+{{#actions}}
+import { {{{action}}} } from './{{{action}}}'
+{{/actions}}
+
+
+export default function getSchema(action : string){
+    switch(action){
+        {{#actions}}
+        case '{{{action}}}':
+            return {{{action}}};
+        {{/actions}}
+        default:
+            throw new Error('Action not found');
+    }
+}
+