ondc-code-generator 0.0.2 → 0.0.4

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

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

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

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

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

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

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

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

package/src/types/config-types.ts

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

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