ondc-code-generator 0.5.4 → 0.5.42

package/dist/generator/config-compiler.js

@@ -10,6 +10,7 @@ import { fileURLToPath } from "url";
 import path from "path";
 import { duplicateVariablesInChildren } from "../utils/config-utils/duplicateVariables.js";
 import { PythonGenerator } from "./generators/python/py-generator.js";
+import { JavascriptGenerator } from "./generators/javascript/js-generator.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const defaultConfig = {
@@ -58,7 +59,6 @@ export class ConfigCompiler {
         this.generateCode = async (valConfig, codeName = "L1-Validations", minimal = false, outputPath = "./") => {
             valConfig = JSON.parse(JSON.stringify(valConfig));
             if (this.generatorConfig?.duplicateVariablesInChildren) {
-                console.log("Duplicating variables");
                 valConfig = duplicateVariablesInChildren(valConfig);
             }
             if (minimal) {
@@ -80,6 +80,11 @@ export class ConfigCompiler {
                         codeName: codeName,
                     });
                     break;
+                case SupportedLanguages.Javascript:
+                    await new JavascriptGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode({
+                        codeName: codeName,
+                    });
+                    break;
                 default:
                     throw new Error("Language not supported");
             }
@@ -105,9 +110,8 @@ export class ConfigCompiler {
                     };
                 });
                 const template = readFileSync(path.resolve(__dirname, "../generator/generators/typescript/templates/schema-template.mustache"), "utf-8");
-                console.log(actions);
                 const l0 = Mustache.render(template, { actions });
-                await writeAndFormatCode(`./generated/L0-schemas`, `index.ts`, l0, "typescript");
+                await writeAndFormatCode(targetPath, `index.ts`, l0, "typescript");
             }
         };
         this.generateValidPaths = async () => {

package/dist/generator/generators/javascript/js-generator.d.ts

@@ -0,0 +1,19 @@
+import { CodeGenerator, CodeGeneratorProps } from "../classes/abstract-generator.js";
+export declare class JavascriptGenerator extends CodeGenerator {
+    private tempTsPath;
+    constructor(validationConfig: any, errorCodes: any[], rootPath?: string);
+    generateSessionDataCode: () => Promise<never>;
+    generateValidationCode: () => Promise<void>;
+    generateCode: (codeConfig: CodeGeneratorProps) => Promise<void>;
+    private createTsConfig;
+    private compileToJavaScript;
+    private processGeneratedFiles;
+    private copyAndProcessJsFiles;
+    private copyTypeDefinitions;
+    private processJavaScriptImports;
+    private processTypeDefinitionImports;
+    private getAllFiles;
+    private generatePackageJson;
+    private runCommand;
+    private cleanup;
+}

package/dist/generator/generators/javascript/js-generator.js

@@ -0,0 +1,215 @@
+import path from "path";
+import { fileURLToPath } from "url";
+import { CodeGenerator, } from "../classes/abstract-generator.js";
+import { writeAndFormatCode } from "../../../utils/fs-utils.js";
+import { TypescriptGenerator } from "../typescript/ts-generator.js";
+import logger from "../../../utils/logger.js";
+import fs from "fs-extra";
+import { MarkdownDocGenerator } from "../documentation/md-generator.js";
+import { exec } from "child_process";
+import { promisify } from "util";
+const execAsync = promisify(exec);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export class JavascriptGenerator extends CodeGenerator {
+    constructor(validationConfig, errorCodes, rootPath = "./") {
+        super(validationConfig, errorCodes, rootPath);
+        this.generateSessionDataCode = async () => {
+            throw new Error("Method not implemented.");
+        };
+        this.generateValidationCode = async () => {
+            // This will be handled by the TypeScript generator in generateCode
+        };
+        this.generateCode = async (codeConfig) => {
+            try {
+                logger.info("Generating JavaScript code using TypeScript compilation...");
+                // Step 1: Generate TypeScript code in a temporary directory
+                logger.debug("Step 1: Generating TypeScript code in temp directory");
+                await fs.ensureDir(this.tempTsPath);
+                const tsGenerator = new TypescriptGenerator(this.validationConfig, this.errorCodes, this.tempTsPath);
+                await tsGenerator.generateCode(codeConfig);
+                // Step 2: Create tsconfig.json for compilation
+                logger.debug("Step 2: Creating TypeScript configuration");
+                await this.createTsConfig();
+                // Step 3: Install TypeScript if not available and compile
+                logger.debug("Step 3: Compiling TypeScript to JavaScript");
+                await this.compileToJavaScript();
+                // Step 4: Copy and modify generated files
+                logger.debug("Step 4: Processing generated files");
+                await this.processGeneratedFiles();
+                // Step 5: Generate package.json
+                logger.debug("Step 5: Creating package.json");
+                await this.generatePackageJson(codeConfig.codeName);
+                // Step 6: Generate documentation
+                logger.debug("Step 6: Generating documentation");
+                await new MarkdownDocGenerator(this.validationConfig, this.errorCodes, this.rootPath).generateCode();
+                // Step 7: Clean up temporary files
+                logger.debug("Step 7: Cleaning up temporary files");
+                await this.cleanup();
+                logger.info("JavaScript code generation completed successfully");
+            }
+            catch (error) {
+                logger.error("Error during JavaScript code generation:", error);
+                await this.cleanup(); // Ensure cleanup even on error
+                throw error;
+            }
+        };
+        this.tempTsPath = path.resolve(rootPath, "../temp-ts-generation");
+    }
+    async createTsConfig() {
+        const tsConfig = {
+            compilerOptions: {
+                target: "ES2020",
+                module: "ESNext",
+                moduleResolution: "node",
+                declaration: true,
+                outDir: "./js-output",
+                rootDir: ".",
+                strict: false,
+                esModuleInterop: true,
+                allowSyntheticDefaultImports: true,
+                skipLibCheck: true,
+                forceConsistentCasingInFileNames: true,
+                allowJs: true,
+                noEmitOnError: false,
+                removeComments: false,
+            },
+            include: ["./**/*.ts"],
+            exclude: ["node_modules", "./js-output"],
+        };
+        await writeAndFormatCode(this.tempTsPath, "tsconfig.json", JSON.stringify(tsConfig, null, 2), "json");
+    }
+    async compileToJavaScript() {
+        logger.debug("Compiling TypeScript to JavaScript...");
+        try {
+            // Try using npx tsc first
+            await this.runCommand("npx tsc", this.tempTsPath);
+        }
+        catch (error) {
+            // If npx tsc fails, try to install TypeScript locally and retry
+            logger.info("TypeScript compilation failed, installing TypeScript...");
+            await this.runCommand("npm init -y", this.tempTsPath);
+            await this.runCommand("npm install --save-dev typescript", this.tempTsPath);
+            await this.runCommand("npx tsc", this.tempTsPath);
+        }
+    }
+    async processGeneratedFiles() {
+        const jsOutputPath = path.resolve(this.tempTsPath, "js-output");
+        // Ensure the target directory exists
+        await fs.ensureDir(this.rootPath);
+        // Copy all .js files and modify imports
+        await this.copyAndProcessJsFiles(jsOutputPath, this.rootPath);
+        // Copy all .d.ts files
+        await this.copyTypeDefinitions(jsOutputPath, this.rootPath);
+    }
+    async copyAndProcessJsFiles(sourceDir, targetDir) {
+        if (!(await fs.pathExists(sourceDir))) {
+            throw new Error(`Source directory ${sourceDir} does not exist`);
+        }
+        const files = await this.getAllFiles(sourceDir, ".js");
+        for (const file of files) {
+            const relativePath = path.relative(sourceDir, file);
+            const targetFile = path.resolve(targetDir, relativePath);
+            let content = await fs.readFile(file, "utf-8");
+            // Convert TypeScript-style imports to work better with JavaScript
+            content = this.processJavaScriptImports(content);
+            await fs.ensureDir(path.dirname(targetFile));
+            await fs.writeFile(targetFile, content);
+        }
+    }
+    async copyTypeDefinitions(sourceDir, targetDir) {
+        if (!(await fs.pathExists(sourceDir))) {
+            logger.warn(`Type definitions source directory ${sourceDir} does not exist`);
+            return;
+        }
+        const files = await this.getAllFiles(sourceDir, ".d.ts");
+        for (const file of files) {
+            const relativePath = path.relative(sourceDir, file);
+            const targetFile = path.resolve(targetDir, relativePath);
+            let content = await fs.readFile(file, "utf-8");
+            // Process .d.ts imports
+            content = this.processTypeDefinitionImports(content);
+            await fs.ensureDir(path.dirname(targetFile));
+            await fs.writeFile(targetFile, content);
+        }
+    }
+    processJavaScriptImports(content) {
+        // For ES modules, we need to keep the .js extensions in imports
+        // But fix the .js.js issue if it occurs
+        return content
+            .replace(/\.js\.js/g, ".js")
+            .replace(/from\s+["']([^"']+)\.ts["']/g, "from '$1.js'")
+            .replace(/import\s+["']([^"']+)\.ts["']/g, "import '$1.js'");
+    }
+    processTypeDefinitionImports(content) {
+        // Fix TypeScript imports in .d.ts files
+        return content
+            .replace(/from\s+["']([^"']+)\.ts["']/g, "from '$1'")
+            .replace(/import\s+["']([^"']+)\.ts["']/g, "import '$1'")
+            .replace(/\.js\.js/g, ".js");
+    }
+    async getAllFiles(dir, extension) {
+        const files = [];
+        if (!(await fs.pathExists(dir))) {
+            return files;
+        }
+        const items = await fs.readdir(dir, { withFileTypes: true });
+        for (const item of items) {
+            const fullPath = path.resolve(dir, item.name);
+            if (item.isDirectory()) {
+                const subFiles = await this.getAllFiles(fullPath, extension);
+                files.push(...subFiles);
+            }
+            else if (item.isFile() && item.name.endsWith(extension)) {
+                files.push(fullPath);
+            }
+        }
+        return files;
+    }
+    async generatePackageJson(codeName) {
+        const packageJson = {
+            name: codeName.toLowerCase().replace(/[^a-z0-9-]/g, "-"),
+            version: "1.0.0",
+            description: `Generated validation library: ${codeName}`,
+            type: "module",
+            main: "index.js",
+            types: "index.d.ts",
+            scripts: {
+                test: 'echo "Error: no test specified" && exit 1',
+            },
+            dependencies: {
+                // Add any runtime dependencies your generated code needs
+                jsonpath: "^1.1.1",
+            },
+            keywords: ["validation", "api", "testing", "javascript", "ondc"],
+            author: "Generated by ONDC Code Generator",
+            license: "MIT",
+        };
+        await writeAndFormatCode(this.rootPath, "package.json", JSON.stringify(packageJson, null, 2), "json");
+    }
+    async runCommand(command, cwd) {
+        try {
+            const { stdout, stderr } = await execAsync(command, { cwd });
+            if (stderr && !stderr.includes("npm WARN")) {
+                logger.warn(`Command stderr: ${command}`, stderr);
+            }
+            return stdout;
+        }
+        catch (error) {
+            logger.error(`Command failed: ${command}`, error.message);
+            throw new Error(`Command failed: ${command}
+${error.message}`);
+        }
+    }
+    async cleanup() {
+        try {
+            if (await fs.pathExists(this.tempTsPath)) {
+                await fs.remove(this.tempTsPath);
+                logger.debug("Cleaned up temporary TypeScript files");
+            }
+        }
+        catch (error) {
+            logger.warn("Failed to clean up temporary files:", error);
+        }
+    }
+}

package/dist/index.js

@@ -15,22 +15,32 @@ export { ConfigCompiler };
 // 	);
 // 	const buildYaml = readFileSync(buildPath, "utf-8");
 // 	const valConfig = JSON.parse(readFileSync(valConfigPath, "utf-8"));
-// 	await compiler.initialize(buildYaml);
-// 	await compiler.generateCode(
+// 	// await compiler.initialize(buildYaml);
+// 	// await compiler.generateCode(
+// 	// 	valConfig,
+// 	// 	"L1_validations",
+// 	// 	false,
+// 	// 	"./alpha/python/"
+// 	// );
+// 	// const compilerTy = new ConfigCompiler(SupportedLanguages.Typescript);
+// 	// await compilerTy.initialize(buildYaml);
+// 	// await compilerTy.generateCode(
+// 	// 	valConfig,
+// 	// 	"L1_validations",
+// 	// 	false,
+// 	// 	"./alpha/typescript/"
+// 	// );
+// 	// JavaScript generation example
+// 	const compilerJs = new ConfigCompiler(SupportedLanguages.Javascript);
+// 	await compilerJs.initialize(buildYaml);
+// 	await compilerJs.generateCode(
 // 		valConfig,
 // 		"L1_validations",
 // 		false,
-// 		"./alpha/python/"
-// 	);
-// 	const compilerTy = new ConfigCompiler(SupportedLanguages.Typescript);
-// 	await compilerTy.initialize(buildYaml);
-// 	await compilerTy.generateCode(
-// 		valConfig,
-// 		"L1_validations",
-// 		false,
-// 		"./alpha/typescript/"
+// 		"./alpha/javascriptNative/"
 // 	);
 // };
 // (async () => {
 // 	await main();
+// 	console.log("Code generation completed.");
 // })();

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

@@ -1,4 +1,5 @@
 export declare enum SupportedLanguages {
     Typescript = "typescript",
-    Python = "python"
+    Python = "python",
+    Javascript = "javascript"
 }

package/dist/types/compiler-types.js

@@ -2,4 +2,5 @@ export var SupportedLanguages;
 (function (SupportedLanguages) {
     SupportedLanguages["Typescript"] = "typescript";
     SupportedLanguages["Python"] = "python";
+    SupportedLanguages["Javascript"] = "javascript";
 })(SupportedLanguages || (SupportedLanguages = {}));

package/dist/utils/logger.js

@@ -31,6 +31,7 @@ const logLevel = process.env.NODE_ENV === "production" ? "info" : "debug";
 // Configure Winston logger
 const logger = winston.createLogger({
     level: logLevel,
+    silent: true,
     format: combine(timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), errors({ stack: true }), // Include stack trace in error messages
     logFormat),
     transports: [

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ondc-code-generator",
-	"version": "0.5.4",
+	"version": "0.5.42",
 	"description": "generate code from build.yaml ",
 	"main": "dist/index.js",
 	"type": "module",