ondc-code-generator 0.0.3 → 0.0.5

package/dist/constants/operations.d.ts

@@ -0,0 +1,6 @@
+export declare const LOGICAL_OPERATORS: string[];
+export declare const COMPARISON_OPERATORS: string[];
+export declare const ARITHMETIC_OPERATORS: string[];
+export declare const UNARY_OPERATORS: string[];
+export declare const PREDEFINED_CONDITIONS: string[];
+export declare const OPERATORS: string[];

package/dist/constants/syntax.d.ts

@@ -0,0 +1,15 @@
+export declare enum TestObjectSyntax {
+    Name = "_NAME_",
+    Return = "_RETURN_",
+    Scope = "_SCOPE_",
+    Continue = "_CONTINUE_",
+    ErrorCode = "_ERROR_CODE_",
+    SuccessCode = "_SUCCESS_CODE_"
+}
+export declare const ExternalDataSyntax = "_EXTERNAL";
+export declare enum ConfigSyntax {
+    Tests = "_TESTS_",
+    SessionData = "_SESSION_DATA_"
+}
+export declare const ConfigKeyWords: (TestObjectSyntax | ConfigSyntax)[];
+export declare const nodeReservedKeywords: Set<string>;

package/dist/generator/config-compiler.d.ts

@@ -0,0 +1,23 @@
+import { JSONSchema7 } from "json-schema";
+import { BUILD_TYPE } from "../types/build.js";
+import { ErrorDefinition } from "../types/error-codes.js";
+import { ValidationConfig } from "../types/config-types.js";
+import { SupportedLanguages } from "../types/compiler-types.js";
+type CodeGeneratorConfig = {
+    removeRequiredfromSchema: boolean;
+    removeEnumsfromSchema: boolean;
+};
+export declare class ConfigCompiler {
+    buildData: BUILD_TYPE | undefined;
+    jsonSchemas: Record<string, JSONSchema7> | undefined;
+    possibleJsonPaths: Record<string, string[]> | undefined;
+    errorDefinitions: ErrorDefinition[] | undefined;
+    language: SupportedLanguages;
+    private SchemaExtactionService;
+    constructor(language: SupportedLanguages);
+    initialize: (buildYaml: string, generatorConfig?: Partial<CodeGeneratorConfig>) => Promise<void>;
+    performValidations: (valConfig: ValidationConfig) => Promise<void>;
+    generateCode: (valConfig: ValidationConfig) => Promise<void>;
+    generateL0Schema: () => Promise<void>;
+}
+export {};

package/dist/generator/generators/classes/abstract-generator.d.ts

@@ -0,0 +1,11 @@
+import { ValidationConfig } from "../../../types/config-types";
+import { ErrorDefinition } from "../../../types/error-codes";
+export declare abstract class CodeGenerator {
+    validationConfig: ValidationConfig;
+    rootPath: string;
+    errorCodes: ErrorDefinition[];
+    constructor(validationConfig: ValidationConfig, errorCodes: ErrorDefinition[], rootPath?: string);
+    abstract generateSessionDataCode(): Promise<void>;
+    abstract generateValidationCode(): Promise<void>;
+    abstract generateCode(): Promise<void>;
+}

package/dist/generator/generators/documentation/markdown-message-generator.d.ts

@@ -0,0 +1,2 @@
+import { TestObject } from "../../../types/config-types.js";
+export declare function markdownMessageGenerator(returnInput: string, variableValues: TestObject, startingPointer: string, skipInput?: string[]): string;

package/dist/generator/generators/documentation/md-generator.d.ts

@@ -0,0 +1,9 @@
+import { TestObject } from "../../../types/config-types.js";
+import { CodeGenerator } from "../classes/abstract-generator.js";
+export declare class MarkdownDocGenerator extends CodeGenerator {
+    generateSessionDataCode(): Promise<void>;
+    generateValidationCode: () => Promise<void>;
+    generateCode: () => Promise<void>;
+    generateMarkdownForTest: (testObject: TestObject) => string;
+    generateHtmlCode: (markdownData: string) => Promise<string>;
+}

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

@@ -0,0 +1,5 @@
+declare function getJsonPath(payload: any, path: string): any[];
+declare const _default: {
+    getJsonPath: typeof getJsonPath;
+};
+export default _default;

package/dist/generator/generators/typescript/templates/validation-utils.d.ts

@@ -0,0 +1,21 @@
+declare function areUnique(operand: string[]): boolean;
+declare function arePresent(operand: string[]): boolean;
+declare function allIn(left: string[], right: string[]): boolean;
+declare function anyIn(left: string[], right: string[]): boolean;
+declare function noneIn(left: string[], right: string[]): boolean;
+declare function equalTo(left: string[], right: string[]): boolean;
+declare function greaterThan(left: string[], right: string[]): boolean;
+declare function lessThan(left: string[], right: string[]): boolean;
+declare function followRegex(left: string[], regexArray: string[]): boolean;
+declare const _default: {
+    areUnique: typeof areUnique;
+    arePresent: typeof arePresent;
+    allIn: typeof allIn;
+    anyIn: typeof anyIn;
+    noneIn: typeof noneIn;
+    equalTo: typeof equalTo;
+    followRegex: typeof followRegex;
+    greaterThan: typeof greaterThan;
+    lessThan: typeof lessThan;
+};
+export default _default;

package/dist/generator/generators/typescript/ts-ast.d.ts

@@ -0,0 +1 @@
+export declare const compileInputToTs: (input: string) => string;

package/dist/generator/generators/typescript/ts-generator.d.ts

@@ -0,0 +1,17 @@
+import { TestObject } from "../../../types/config-types.js";
+import { CodeGenerator } from "../classes/abstract-generator.js";
+export declare class TypescriptGenerator extends CodeGenerator {
+    generateSessionDataCode: () => Promise<never>;
+    generateValidationCode: () => Promise<void>;
+    generateCode: () => Promise<void>;
+    generateTestFunction: (testObject: TestObject) => Promise<{
+        funcName: string;
+        code: string;
+    }>;
+    private CreateErrorMarkdown;
+    private createVariablesCode;
+    private createValidationLogicCode;
+    private generateErrorFile;
+    private getExternalKeys;
+    private generateIndexFile;
+}

package/dist/generator/validators/abstract-validator.d.ts

@@ -0,0 +1,17 @@
+import { TestObject } from "../../types/config-types";
+import { ErrorDefinition } from "../../types/error-codes";
+export interface IValidator {
+    validationPath: string;
+    validate(): Promise<void>;
+}
+export declare abstract class TestObjectValidator implements IValidator {
+    targetObject: TestObject;
+    validationPath: string;
+    abstract validate(): Promise<void>;
+    constructor(testObject: TestObject, path: string);
+}
+export interface TestsValidatorDependencies {
+    stringJsonPaths: string[];
+    errorDefinitions: ErrorDefinition[];
+    externalVariables: string[];
+}

package/dist/generator/validators/config-validator.d.ts

@@ -0,0 +1,11 @@
+import { ValidationConfig } from "../../types/config-types.js";
+import { ErrorDefinition } from "../../types/error-codes.js";
+import { IValidator } from "./abstract-validator.js";
+export declare 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[]);
+    validate: () => Promise<void>;
+}

package/dist/generator/validators/session-data-config/session-data-validator.d.ts

@@ -0,0 +1,9 @@
+import { SessionDataApi } from "../../../types/config-types.js";
+import { IValidator } from "../abstract-validator.js";
+export declare class SessionDataValidator implements IValidator {
+    validationPath: string;
+    sessionData: Record<string, SessionDataApi>;
+    constructor(validtionPath: string, sessionData: Record<string, SessionDataApi>);
+    validate: () => Promise<void>;
+    private validateSessionData;
+}

package/dist/generator/validators/tests-config/sub-validations.d.ts

@@ -0,0 +1,38 @@
+import { TestObject } from "../../../types/config-types.js";
+import { ErrorDefinition } from "../../../types/error-codes.js";
+import { TestObjectValidator, TestsValidatorDependencies } from "../abstract-validator.js";
+export declare class RequiredFieldsValidator extends TestObjectValidator {
+    validate: () => Promise<void>;
+}
+export declare class NameValidator extends TestObjectValidator {
+    validate: () => Promise<void>;
+}
+export declare class ScopeValidator extends TestObjectValidator {
+    impossiblePaths: string[];
+    constructor(testObject: TestObject, path: string, impossiblePaths: string[]);
+    validate: () => Promise<void>;
+}
+export declare class ErrorCodeValidator extends TestObjectValidator {
+    possibleErrorCodes: ErrorDefinition[];
+    constructor(testObject: TestObject, path: string, possibleErrorCodes: ErrorDefinition[]);
+    validate: () => Promise<void>;
+}
+export declare class VariableValidator extends TestObjectValidator {
+    possibleJsonPaths: string[];
+    externalVariables: string[];
+    constructor(testObject: TestObject, path: string, posibleJsonPaths: string[], externalVariables: string[]);
+    validate: () => Promise<void>;
+    validateKey(key: string): void;
+    validateExternalData(path: string, definedExternalValues: string[]): void;
+}
+export declare class ContinueValidator extends TestObjectValidator {
+    definedVariables: string[];
+    constructor(testObject: TestObject, path: string);
+    validate: () => Promise<void>;
+}
+export declare class ReturnValidator extends TestObjectValidator {
+    definedVariables: string[];
+    dependencies: TestsValidatorDependencies;
+    constructor(testObject: TestObject, path: string, dependencies: TestsValidatorDependencies);
+    validate: () => Promise<void>;
+}

package/dist/generator/validators/tests-config/test-list-validator.d.ts

@@ -0,0 +1,10 @@
+import { TestObject } from "../../../types/config-types.js";
+import { IValidator, TestsValidatorDependencies } from "../abstract-validator.js";
+export declare class TestsValidator implements IValidator {
+    tests: TestObject[];
+    validationPath: string;
+    dependencies: TestsValidatorDependencies;
+    constructor(tests: TestObject[], configPath: string, dependencies: TestsValidatorDependencies);
+    validate: () => Promise<void>;
+    validateDuplicateNames: () => void;
+}

package/dist/generator/validators/tests-config/test-validator.d.ts

@@ -0,0 +1,7 @@
+import { TestObject } from "../../../types/config-types.js";
+import { TestObjectValidator, TestsValidatorDependencies } from "../abstract-validator.js";
+export declare class CompleteTestObjectValidator extends TestObjectValidator {
+    dependencies: TestsValidatorDependencies;
+    constructor(testObject: TestObject, path: string, dependencies: TestsValidatorDependencies);
+    validate: () => Promise<void>;
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -1,2 +1,40 @@
+import { readFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { SupportedLanguages } from "./types/compiler-types.js";
 import { ConfigCompiler } from "./generator/config-compiler.js";
-export { ConfigCompiler };
+// Get __dirname equivalent
+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);
+    // await compiler.generateL0Schema();
+    // await compiler.performValidations(valConfig);
+    // const inputs = [
+    // 	"a are unique && b are unique",
+    // 	"a are unique",
+    // 	"(a are unique && b are unique) || c are unique",
+    // 	"a are unique && b are unique || c are unique",
+    // 	"a are unique && (b are unique || c are unique)",
+    // 	"a are unique && b are unique && c are unique && d are unique",
+    // 	"a are unique && !(b are unique || !(c are unique))",
+    // 	"a are unique && (b are unique || !(!(c are unique))) && !(d are unique)",
+    // ];
+    // let output = "";
+    // for (const input of inputs) {
+    // 	const cst = parseReturnInput(input);
+    // 	const ast = buildAst(cst);
+    // 	const out = CompileToMarkdown(ast, "A", 0, false);
+    // 	output += `\n## ${input}\n\n${out}\n`;
+    // }
+    // writeFileSync(path.resolve(__dirname, "../samples/output.md"), output);
+};
+(async () => {
+    await main();
+})();

package/dist/services/return-complier/ast-functions/compile-to-markdown.d.ts

@@ -0,0 +1,2 @@
+import { AstNode } from "../ast.js";
+export declare function CompileToMarkdown(ast: AstNode, pointer: string, depth: number | undefined, forNot: boolean): string;

package/dist/services/return-complier/ast-functions/semantic-validations.d.ts

@@ -0,0 +1,2 @@
+import { AstNode } from "../ast";
+export declare function checkValidVariables(ast: AstNode, validVariables: string[], path?: string): void;

package/dist/services/return-complier/ast.d.ts

@@ -0,0 +1,42 @@
+import { CstNode } from "chevrotain";
+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;
+}
+declare const AstBuilder_base: new (...args: any[]) => import("chevrotain").ICstVisitor<any, any>;
+export declare class AstBuilder extends AstBuilder_base {
+    constructor();
+    returnStatement(ctx: any): ReturnStatementNode;
+    orExpression(ctx: any): BinaryOperatorNode | AstNode;
+    andExpression(ctx: any): BinaryOperatorNode | AstNode;
+    notExpression(ctx: any): NotOperatorNode | AstNode;
+    primaryExpression(ctx: any): ReturnStatementNode | CustomBinaryFunction | CustomUniaryFunction;
+    parentheisizedExpression(ctx: any): ReturnStatementNode;
+    atomicCustomExpression(ctx: any): CustomBinaryFunction | CustomUniaryFunction;
+    visitIdentifier(token: any): IdentifierNode;
+}
+export declare function buildAst(cst: CstNode): AstNode;
+export {};

package/dist/services/return-complier/combined.d.ts

@@ -0,0 +1,2 @@
+import { AstNode } from "./ast.js";
+export declare function buildAstFromInput(input: string): AstNode;

package/dist/services/return-complier/parser.d.ts

@@ -0,0 +1,14 @@
+import { CstNode, CstParser } from "chevrotain";
+declare class ReturnParser extends CstParser {
+    returnStatement: () => CstNode;
+    orExpression: () => CstNode;
+    andExpression: () => CstNode;
+    notExpression: () => CstNode;
+    primaryExpression: () => CstNode;
+    atomicCustomExpression: () => CstNode;
+    parentheisizedExpression: () => CstNode;
+    constructor();
+}
+export declare const ReturnParserInstance: ReturnParser;
+export declare function parseReturnInput(inputText: string): CstNode;
+export {};

package/dist/services/return-complier/tokens.d.ts

@@ -0,0 +1,22 @@
+import { ILexingResult } from "chevrotain";
+export declare const Identifier: import("chevrotain").TokenType;
+export declare const CustomBinaryFunctions: import("chevrotain").TokenType;
+export declare const CustomUniaryFunctions: import("chevrotain").TokenType;
+export declare const AllIn: import("chevrotain").TokenType;
+export declare const AnyIn: import("chevrotain").TokenType;
+export declare const AreUnique: import("chevrotain").TokenType;
+export declare const ArePresent: import("chevrotain").TokenType;
+export declare const FollowRegex: import("chevrotain").TokenType;
+export declare const NoneIn: import("chevrotain").TokenType;
+export declare const EqualTo: import("chevrotain").TokenType;
+export declare const GreaterThan: import("chevrotain").TokenType;
+export declare const LessThan: import("chevrotain").TokenType;
+export declare const WhiteSpace: import("chevrotain").TokenType;
+export declare const LParen: import("chevrotain").TokenType;
+export declare const RParen: import("chevrotain").TokenType;
+export declare const BinaryOperator: import("chevrotain").TokenType;
+export declare const AndOperator: import("chevrotain").TokenType;
+export declare const OrOperator: import("chevrotain").TokenType;
+export declare const NotOperator: import("chevrotain").TokenType;
+export declare const allTokens: import("chevrotain").TokenType[];
+export declare function ReturnTokenize(inputText: string): ILexingResult;

package/dist/services/schema-service.d.ts

@@ -0,0 +1,6 @@
+import { JSONSchema7 } from "json-schema";
+import { BUILD_TYPE } from "../types/build.js";
+export declare class SchemaExtactionService {
+    extractSchemas: (data: BUILD_TYPE, removeRequired: boolean, removeEnums: boolean) => Promise<Record<string, JSONSchema7>>;
+    extractPossiblePaths: (schemas: Record<string, JSONSchema7>) => Record<string, string[]>;
+}

package/dist/types/build.d.ts

@@ -0,0 +1,48 @@
+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 BUILD_TYPE {
+    paths: BuildPath;
+    "x-enum": any;
+    "x-attributes": Xattributes;
+    "x-errorcodes": {
+        code: ErrorDefinition[];
+    };
+}

package/dist/types/compiler-types.d.ts

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

package/dist/types/config-types.d.ts

@@ -0,0 +1,21 @@
+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/dist/types/error-codes.d.ts

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

package/dist/types/general-types.d.ts

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

package/dist/utils/config-utils/json-schema-utils.d.ts

@@ -0,0 +1,7 @@
+import { JSONSchema7 } from "json-schema";
+/**
+ * Recursively removes all "required" and "enum" properties from a JSON Schema.
+ * @param schema - The JSON Schema object to process.
+ * @returns A new JSON Schema object with "required" and "enum" properties removed.
+ */
+export declare function removeRequiredAndEnum(schema: JSONSchema7 | boolean, removeEnums?: boolean, removeRequired?: boolean): JSONSchema7 | boolean;

package/dist/utils/config-utils/yaml.d.ts

@@ -0,0 +1 @@
+export declare function loadAndDereferenceYaml<T>(yamlData: string): Promise<T>;

package/dist/utils/fs-utils.d.ts

@@ -0,0 +1,3 @@
+export declare function writeFileWithFsExtra(rootPath: string, relativeFilePath: string, content: string): void;
+export declare function formatCode(code: string, lang: string): Promise<string>;
+export declare function writeAndFormatCode(rootPath: string, relativeFilePath: string, content: string, lang: string): Promise<void>;

package/dist/utils/general-utils/string-utils.d.ts

@@ -0,0 +1,27 @@
+import { TestObject } from "../../types/config-types.js";
+/**
+ * 	Check if the string matches the pattern: lowercase letters and underscores only, no leading or trailing underscores
+ *
+ * @param str
+ * @returns true if the string is in snake_case, false otherwise
+ */
+export declare function isSnakeCase(str: string): boolean;
+export declare function isValidVariableName(input: string): boolean;
+/**
+ * Adds '>' at the beginning of each line in the given Markdown string.
+ *
+ * @param {string} markdown - The input Markdown string.
+ * @returns {string} - The modified Markdown string with '>' added to each line.
+ */
+export declare function addBlockquoteToMarkdown(markdown: string): string;
+export declare function ConvertArrayToStringsInTestObject(testObject: TestObject): {
+    [x: string]: number | TestObject[] | import("../../types/config-types.js").ConfigVariable | undefined;
+    _NAME_: string;
+    _RETURN_: string | TestObject[];
+    _SCOPE_?: string;
+    _ERROR_CODE_?: number;
+    _SUCCESS_CODE_?: number;
+    _CONTINUE_?: string;
+};
+export declare function ConvertArrayToString(arr: any[]): string;
+export declare function addTabToMarkdown(markdown: string): string;

package/dist/utils/general-utils/test-object-utils.d.ts

@@ -0,0 +1,2 @@
+import { TestObject } from "../../types/config-types.js";
+export declare function getVariablesFromTest(testObject: TestObject): string[];

package/dist/utils/general-utils/validation-utils.d.ts

@@ -0,0 +1,5 @@
+import { SessionDataApi } from "../../types/config-types.js";
+import { Primitive, ValidVariableLine } from "../../types/general-types.js";
+export declare function isPrimitive(value: unknown): value is Primitive;
+export declare function isValidVariableValueType(line: any): line is ValidVariableLine;
+export declare function getExternalVariables(sessionData: Record<string, SessionDataApi>): string[];

package/dist/utils/json-path-utils/extract-string-paths.d.ts

@@ -0,0 +1,8 @@
+import { JSONSchema7 } from "json-schema";
+/**
+ * Extracts all possible JSON paths from a given JSON Schema Draft-07.
+ *
+ * @param schema - The JSON Schema Draft-07 object.
+ * @returns An array of JSON paths as strings.
+ */
+export declare function getAllJsonPaths(schema: JSONSchema7): string[];

package/dist/utils/json-path-utils/paths.d.ts

@@ -0,0 +1,9 @@
+export declare function isValidJsonPath(jsonPath: string): boolean;
+/**
+ * Replaces all content inside square brackets in a JSONPath with an asterisk '*',
+ * handling nested brackets if they occur.
+ *
+ * @param jsonPath - The JSONPath string to transform.
+ * @returns The transformed JSONPath string with contents inside brackets replaced by '*'.
+ */
+export declare function replaceBracketsWithAsteriskNested(jsonPath: string): string;

package/dist/utils/logger.d.ts

@@ -0,0 +1,3 @@
+import winston from "winston";
+declare const logger: winston.Logger;
+export default logger;

package/package.json

@@ -1,9 +1,9 @@
 {
 	"name": "ondc-code-generator",
-	"version": "0.0.3",
+	"version": "0.0.5",
 	"description": "generate code from build.yaml ",
 	"main": "dist/index.js",
-	"types": "dist/index.d.ts",
+	"type": "module",
 	"scripts": {
 		"build": "tsc",
 		"start": "node ./dist/index.js",