ondc-code-generator 0.0.1

package/src/services/return-complier/ast.ts

@@ -0,0 +1,147 @@
+import { CstNode } from "chevrotain";
+import { ReturnParserInstance } from "./parser.js";
+
+export interface AstNode {
+	type:
+		| "returnStatement"
+		| "binaryOperator"
+		| "notOperator"
+		| "customBinaryFunction"
+		| "customUniaryFunction"
+		| "identifier";
+}
+
+export interface ReturnStatementNode extends AstNode {
+	expression: AstNode;
+}
+
+export interface BinaryOperatorNode extends AstNode {
+	operator: "&&" | "||";
+	lhs: AstNode;
+	rhs: AstNode;
+}
+
+export interface NotOperatorNode extends AstNode {
+	operator: "!";
+	expression: AstNode;
+}
+
+export interface CustomBinaryFunction extends AstNode {
+	customFunction: string;
+	lhs: IdentifierNode;
+	rhs: IdentifierNode;
+}
+
+export interface CustomUniaryFunction extends AstNode {
+	customFunction: string;
+	expression: IdentifierNode;
+}
+
+export interface IdentifierNode extends AstNode {
+	name: string;
+}
+
+export class AstBuilder extends ReturnParserInstance.getBaseCstVisitorConstructor() {
+	constructor() {
+		super();
+		this.validateVisitor();
+	}
+
+	returnStatement(ctx: any): ReturnStatementNode {
+		return {
+			type: "returnStatement",
+			expression: this.visit(ctx.orExpression),
+		};
+	}
+
+	orExpression(ctx: any): BinaryOperatorNode | AstNode {
+		let left = this.visit(ctx.lhs);
+		if (!ctx.operator) return left;
+
+		if (ctx.operator) {
+			for (let i = 0; i < ctx.operator.length; i++) {
+				left = {
+					type: "binaryOperator",
+					operator: ctx.operator[i].image,
+					lhs: left,
+					rhs: this.visit(ctx.rhs[i]),
+				};
+			}
+		}
+		return left;
+	}
+
+	andExpression(ctx: any): BinaryOperatorNode | AstNode {
+		let left = this.visit(ctx.lhs);
+		if (!ctx.operator) return left;
+
+		if (ctx.operator) {
+			for (let i = 0; i < ctx.operator.length; i++) {
+				left = {
+					type: "binaryOperator",
+					operator: ctx.operator[i].image,
+					lhs: left,
+					rhs: this.visit(ctx.rhs[i]),
+				};
+			}
+		}
+		return left;
+	}
+
+	notExpression(ctx: any): NotOperatorNode | AstNode {
+		if (ctx.operator) {
+			return {
+				type: "notOperator",
+				operator: ctx.operator[0].image,
+				expression: this.visit(ctx.parentheisizedExpression),
+			};
+		}
+		return this.visit(ctx.primaryExpression);
+	}
+
+	primaryExpression(
+		ctx: any
+	): ReturnStatementNode | CustomBinaryFunction | CustomUniaryFunction {
+		if (ctx.parentheisizedExpression) {
+			return this.visit(ctx.parentheisizedExpression);
+		}
+		if (ctx.atomicCustomExpression) {
+			return this.visit(ctx.atomicCustomExpression);
+		}
+		throw new Error("Invalid primary expression");
+	}
+
+	parentheisizedExpression(ctx: any): ReturnStatementNode {
+		return this.visit(ctx.returnStatement);
+	}
+
+	atomicCustomExpression(
+		ctx: any
+	): CustomBinaryFunction | CustomUniaryFunction {
+		if (ctx.rhs) {
+			return {
+				type: "customBinaryFunction",
+				customFunction: ctx.function[0].image,
+				lhs: this.visitIdentifier(ctx.lhs[0]),
+				rhs: this.visitIdentifier(ctx.rhs[0]),
+			};
+		}
+		return {
+			type: "customUniaryFunction",
+			customFunction: ctx.function[0].image,
+			expression: this.visitIdentifier(ctx.lhs[0]),
+		};
+	}
+
+	visitIdentifier(token: any): IdentifierNode {
+		return {
+			type: "identifier",
+			name: token.image,
+		};
+	}
+}
+
+export function buildAst(cst: CstNode): AstNode {
+	const astBuilder = new AstBuilder();
+	return astBuilder.visit(cst);
+}

package/src/services/return-complier/combined.ts

@@ -0,0 +1,8 @@
+import { AstNode, buildAst } from "./ast.js";
+import { parseReturnInput } from "./parser.js";
+
+export function buildAstFromInput(input: string): AstNode {
+	const cst = parseReturnInput(input);
+	const ast = buildAst(cst);
+	return ast;
+}

package/src/services/return-complier/parser.ts

@@ -0,0 +1,128 @@
+import { CstNode, CstParser } from "chevrotain";
+import {
+	allTokens,
+	AndOperator,
+	CustomBinaryFunctions,
+	CustomUniaryFunctions,
+	Identifier,
+	LParen,
+	NotOperator,
+	OrOperator,
+	ReturnTokenize,
+	RParen,
+} from "./tokens.js";
+
+class ReturnParser extends CstParser {
+	public returnStatement!: () => CstNode;
+	public orExpression!: () => CstNode;
+	public andExpression!: () => CstNode;
+	public notExpression!: () => CstNode;
+	public primaryExpression!: () => CstNode;
+	public atomicCustomExpression!: () => CstNode;
+	public parentheisizedExpression!: () => CstNode;
+	constructor() {
+		super(allTokens);
+		const $ = this;
+
+		$.RULE("returnStatement", () => {
+			$.SUBRULE($.orExpression);
+		});
+
+		$.RULE("orExpression", () => {
+			$.SUBRULE($.andExpression, { LABEL: "lhs" });
+			$.MANY(() => {
+				$.CONSUME(OrOperator, { LABEL: "operator" });
+				$.SUBRULE2($.andExpression, { LABEL: "rhs" });
+			});
+		});
+
+		$.RULE("andExpression", () => {
+			$.SUBRULE($.notExpression, { LABEL: "lhs" });
+			$.MANY(() => {
+				$.CONSUME(AndOperator, { LABEL: "operator" });
+				$.SUBRULE2($.notExpression, { LABEL: "rhs" });
+			});
+		});
+
+		$.notExpression = $.RULE("notExpression", () => {
+			$.OR([
+				{
+					ALT: () => {
+						$.CONSUME(NotOperator, { LABEL: "operator" });
+						$.SUBRULE($.parentheisizedExpression);
+					},
+				},
+				{
+					ALT: () => {
+						$.SUBRULE($.primaryExpression);
+					},
+				},
+			]);
+		});
+
+		$.RULE("primaryExpression", () => {
+			$.OR([
+				{
+					ALT: () => {
+						$.SUBRULE($.parentheisizedExpression);
+					},
+				},
+				{
+					ALT: () => {
+						$.SUBRULE($.atomicCustomExpression);
+					},
+				},
+			]);
+		});
+
+		$.RULE("parentheisizedExpression", () => {
+			$.CONSUME(LParen);
+			$.SUBRULE($.returnStatement);
+			$.CONSUME(RParen);
+		});
+
+		$.RULE("atomicCustomExpression", () => {
+			$.OR([
+				{
+					ALT: () => {
+						$.CONSUME1(Identifier, { LABEL: "lhs" });
+						$.CONSUME(CustomBinaryFunctions, { LABEL: "function" });
+						$.CONSUME2(Identifier, { LABEL: "rhs" });
+					},
+				},
+				{
+					ALT: () => {
+						$.CONSUME3(Identifier, { LABEL: "lhs" });
+						$.CONSUME(CustomUniaryFunctions, { LABEL: "function" });
+					},
+				},
+			]);
+		});
+
+		$.performSelfAnalysis();
+	}
+}
+
+export const ReturnParserInstance = new ReturnParser();
+
+export function parseReturnInput(inputText: string) {
+	// Step 1: Tokenize the input
+	const lexResult = ReturnTokenize(inputText);
+
+	// Step 3: Set the parser's input
+	ReturnParserInstance.input = lexResult.tokens;
+
+	// Step 4: Parse the input starting from the 'returnStatement' rule
+	const cst = ReturnParserInstance.returnStatement();
+
+	// Step 5: Check for parsing errors
+	if (ReturnParserInstance.errors.length > 0) {
+		const parseErrors = ReturnParserInstance.errors
+			.map((error) => error.message)
+			.join("\n");
+		throw new Error(`Parsing errors detected:\n${parseErrors}`);
+	}
+
+	// If no errors, return the CST
+	return cst;
+}

package/src/services/return-complier/tokens.ts

@@ -0,0 +1,184 @@
+import {
+	createToken,
+	Lexer,
+	ILexerErrorMessageProvider,
+	IToken,
+	ILexingResult,
+} from "chevrotain";
+
+export const Identifier = createToken({
+	name: "Identifier",
+	pattern: /[a-zA-Z_][a-zA-Z0-9_]*/,
+});
+
+export const CustomBinaryFunctions = createToken({
+	name: "CustomFunctions",
+	pattern: Lexer.NA,
+});
+
+export const CustomUniaryFunctions = createToken({
+	name: "CustomUniaryFunctions",
+	pattern: Lexer.NA,
+});
+
+export const AllIn = createToken({
+	name: "AllIn",
+	pattern: /all in/i,
+	categories: CustomBinaryFunctions,
+	label: "all in",
+});
+
+export const AnyIn = createToken({
+	name: "AnyIn",
+	pattern: /any in/i,
+	categories: CustomBinaryFunctions,
+	label: "any in",
+});
+
+export const AreUnique = createToken({
+	name: "AreUnique",
+	pattern: /are unique/i,
+	categories: CustomUniaryFunctions,
+	label: "are unique",
+});
+
+export const ArePresent = createToken({
+	name: "ArePresent",
+	pattern: /are present/i,
+	categories: CustomUniaryFunctions,
+	label: "are present",
+});
+
+export const FollowRegex = createToken({
+	name: "FollowRegex",
+	pattern: /follow regex/i,
+	categories: CustomBinaryFunctions,
+	label: "follow regex",
+});
+
+export const NoneIn = createToken({
+	name: "NoneIn",
+	pattern: /none in/i,
+	categories: CustomBinaryFunctions,
+	label: "none in",
+});
+
+export const EqualTo = createToken({
+	name: "EqualTo",
+	pattern: /equal to/i,
+	categories: CustomBinaryFunctions,
+	label: "equal to",
+});
+
+export const GreaterThan = createToken({
+	name: "GreaterThan",
+	pattern: /greater than/i,
+	categories: CustomBinaryFunctions,
+	label: "greater than",
+});
+
+export const LessThan = createToken({
+	name: "LessThan",
+	pattern: /less than/i,
+	categories: CustomBinaryFunctions,
+	label: "less than",
+});
+
+export const WhiteSpace = createToken({
+	name: "WhiteSpace",
+	pattern: /\s+/,
+	group: Lexer.SKIPPED,
+});
+
+export const LParen = createToken({
+	name: "LParen",
+	pattern: /\(/,
+	label: "(",
+});
+export const RParen = createToken({
+	name: "RParen",
+	pattern: /\)/,
+	label: ")",
+});
+
+export const BinaryOperator = createToken({
+	name: "BinaryOperator",
+	pattern: Lexer.NA,
+});
+
+export const AndOperator = createToken({
+	name: "AndOperator",
+	pattern: /&&/,
+	categories: BinaryOperator,
+	label: "&&",
+});
+
+export const OrOperator = createToken({
+	name: "OrOperator",
+	pattern: /\|\|/,
+	categories: BinaryOperator,
+	label: "||",
+});
+
+export const NotOperator = createToken({
+	name: "NotOperator",
+	pattern: /!/,
+	label: "!",
+});
+
+export const allTokens = [
+	WhiteSpace,
+	LParen,
+	RParen,
+	AndOperator,
+	OrOperator,
+	NotOperator,
+	AreUnique,
+	ArePresent,
+	AllIn,
+	AnyIn,
+	EqualTo,
+	GreaterThan,
+	LessThan,
+	FollowRegex,
+	NoneIn,
+	CustomUniaryFunctions,
+	CustomBinaryFunctions,
+	BinaryOperator,
+	Identifier,
+];
+
+const lexerErrorMessageProvider: ILexerErrorMessageProvider = {
+	buildUnableToPopLexerModeMessage: function (token: IToken): string {
+		return `Unable to pop Lexer Mode at line ${token.startLine}, column ${token.startColumn}. Token: ${token.image}.`;
+	},
+	buildUnexpectedCharactersMessage: function (
+		fullText: string,
+		startOffset: number,
+		length: number,
+		line: number,
+		column: number
+	): string {
+		const unexpectedText = fullText.substring(
+			startOffset,
+			startOffset + length
+		);
+		return `Unexpected character sequence: '${unexpectedText}' at line ${line}, column ${column}.`;
+	},
+};
+const ReturnLexer = new Lexer(allTokens, {
+	errorMessageProvider: lexerErrorMessageProvider,
+	positionTracking: "full",
+});
+
+export function ReturnTokenize(inputText: string) {
+	const lexerResult: ILexingResult = ReturnLexer.tokenize(inputText);
+
+	if (lexerResult.errors.length > 0) {
+		const errorMessages = lexerResult.errors
+			.map((error) => error.message)
+			.join("\n");
+		throw new Error(`Lexing errors encountered:\n${errorMessages}`);
+	}
+	return lexerResult;
+}

package/src/services/schema-service.ts

@@ -0,0 +1,42 @@
+import { JSONSchema7 } from "json-schema";
+import { BUID_TYPE } from "../types/build.js";
+import { removeRequiredAndEnum } from "../utils/config-utils/json-schema-utils.js";
+import { getAllJsonPaths } from "../utils/json-path-utils/extract-string-paths.js";
+
+export class SchemaExtactionService {
+	extractSchemas = async (
+		data: BUID_TYPE,
+		removeRequired: boolean,
+		removeEnums: boolean
+	) => {
+		const paths = data.paths;
+		const apis = Object.keys(paths).map((key) => {
+			return key.split("/")[1];
+		});
+		const output: any = { paths: {} };
+		for (const targetApi of apis) {
+			const existingSchema =
+				paths[`/${targetApi}`].post.requestBody.content["application/json"]
+					.schema;
+			output["response"] =
+				paths[`/${targetApi}`].post.responses.default.content[
+					"application/json"
+				].schema;
+			const filtteredSchema = removeRequiredAndEnum(
+				existingSchema,
+				removeEnums,
+				removeRequired
+			);
+			output[targetApi] = filtteredSchema;
+		}
+		return output as Record<string, JSONSchema7>;
+	};
+
+	extractPossiblePaths = (schemas: Record<string, JSONSchema7>) => {
+		const paths: Record<string, string[]> = {};
+		for (const [key, schema] of Object.entries(schemas)) {
+			paths[key] = getAllJsonPaths(schema);
+		}
+		return paths;
+	};
+}

package/src/types/build.ts

@@ -0,0 +1,51 @@
+import { ErrorDefinition } from "./error-codes";
+
+export interface Xattributes {
+	[key: string]: AttributeSet;
+}
+export interface AttributeSet {
+	attribute_set: AttributeSection;
+}
+export interface Attribute {
+	required?: string;
+	usage?: any;
+	description?: string;
+	owner?: string;
+	type?: string;
+}
+export interface AttributeSection {
+	[key: string]: Attribute | AttributeSection;
+}
+
+export type BuildPath = {
+	[key: string]: {
+		post: {
+			description: string;
+			requestBody: {
+				content: {
+					"application/json": {
+						schema: any;
+					};
+				};
+			};
+			responses: {
+				default: {
+					content: {
+						"application/json": {
+							schema: any;
+						};
+					};
+				};
+			};
+		};
+	};
+};
+
+export interface BUID_TYPE {
+	paths: BuildPath;
+	"x-enum": any;
+	"x-attributes": Xattributes;
+	"x-errorcodes": {
+		code: ErrorDefinition[];
+	};
+}

package/src/types/compiler-types.ts

@@ -0,0 +1,3 @@
+export enum SupportedLanguages {
+	Typescript = "typescript",
+}

package/src/types/config-types.ts

@@ -0,0 +1,27 @@
+import { ConfigSyntax, TestObjectSyntax } from "../constants/syntax.js";
+import { Primitive } from "./general-types.js";
+
+export type TestObject = {
+	[TestObjectSyntax.Name]: string;
+	[TestObjectSyntax.Return]: string | TestObject[];
+	[TestObjectSyntax.Scope]?: string;
+	[TestObjectSyntax.ErrorCode]?: number;
+	[TestObjectSyntax.SuccessCode]?: number;
+	[TestObjectSyntax.Continue]?: string;
+	[key: string]: ConfigVariable | number | TestObject[] | undefined;
+};
+
+export type ConfigVariable = string | Primitive[];
+
+export type TestArray = TestObject[];
+
+export type SessionDataValue = string | Primitive[] | null;
+
+export type SessionDataApi = {
+	[key: string]: SessionDataValue;
+};
+
+export type ValidationConfig = {
+	[ConfigSyntax.Tests]: Record<string, TestArray>;
+	[ConfigSyntax.SessionData]: Record<string, SessionDataApi>;
+};

package/src/types/error-codes.ts

@@ -0,0 +1,6 @@
+export type ErrorDefinition = {
+	code: number;
+	Description: string;
+	From?: string;
+	Event?: string;
+};

package/src/types/general-types.ts

@@ -0,0 +1,2 @@
+export type Primitive = number | string | boolean | null;
+export type ValidVariableLine = string | Primitive[];