@ifecodes/backend-template 1.1.0 → 1.1.3

package/bin/cli.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 import fs from "fs";
 import path from "path";
 import { execSync } from "child_process";
@@ -7,7 +7,7 @@ import pc from "picocolors";
 import { getProjectConfig } from "./lib/prompts.js";
 import { setupService } from "./lib/service-setup.js";
 import { generateReadme } from "./lib/readme-generator.js";
-import { stripTypeScript, getJavaScriptScripts, getJavaScriptDependencies } from "./lib/ts-to-js.js";
+import { stripTypeScript, getJavaScriptScripts, getJavaScriptDependencies, transformToJavaScript, transformDirectory } from "./lib/ts-to-js.js";
 import {
   generateDockerCompose,
   generatePm2Config,
@@ -67,97 +67,6 @@ if (!isInMicroserviceProject && config.projectType === "microservice") {
   console.log(`\n${pc.cyan("🏗️  Adding service:")} ${pc.bold(servicesToCreate[0])}...\n`);
 }
 
-// Helper function to transform TypeScript project to JavaScript
-function transformToJavaScript(projectRoot) {
-  // Recursively find and transform all .ts files
-  function transformDirectory(dir) {
-    const items = fs.readdirSync(dir);
-    
-    for (const item of items) {
-      const fullPath = path.join(dir, item);
-      const stat = fs.statSync(fullPath);
-      
-      if (stat.isDirectory()) {
-        // Skip node_modules and dist
-        if (item !== 'node_modules' && item !== 'dist') {
-          transformDirectory(fullPath);
-        }
-      } else if (item.endsWith('.ts') && !item.endsWith('.d.ts')) {
-        // Transform TypeScript file to JavaScript
-        const content = fs.readFileSync(fullPath, 'utf8');
-        const jsContent = stripTypeScript(content);
-        const jsPath = fullPath.replace(/\.ts$/, '.js');
-        
-        fs.writeFileSync(jsPath, jsContent);
-        fs.unlinkSync(fullPath); // Remove original .ts file
-      }
-    }
-  }
-  
-  transformDirectory(path.join(projectRoot, 'src'));
-  
-  // Remove TypeScript config file
-  const tsconfigPath = path.join(projectRoot, 'tsconfig.json');
-  if (fs.existsSync(tsconfigPath)) {
-    fs.unlinkSync(tsconfigPath);
-  }
-  
-  // Remove .eslintrc.json and replace with JS version
-  const eslintrcPath = path.join(projectRoot, '.eslintrc.json');
-  if (fs.existsSync(eslintrcPath)) {
-    fs.unlinkSync(eslintrcPath);
-  }
-  
-  // Update package.json
-  const packageJsonPath = path.join(projectRoot, 'package.json');
-  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-  
-  // Update scripts
-  packageJson.scripts = {
-    ...packageJson.scripts,
-    ...getJavaScriptScripts()
-  };
-  
-  // Update type
-  packageJson.type = "module";
-  
-  // Remove main field
-  delete packageJson.main;
-  
-  // Update dependencies
-  const { dependencies, devDependencies } = getJavaScriptDependencies(
-    packageJson.dependencies,
-    packageJson.devDependencies
-  );
-  
-  packageJson.dependencies = dependencies;
-  packageJson.devDependencies = devDependencies;
-  
-  // Remove _moduleAliases (not needed for ES modules with import maps)
-  delete packageJson._moduleAliases;
-  
-  fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
-  
-  // Create simple .eslintrc.json for JavaScript
-  const eslintConfig = {
-    env: {
-      node: true,
-      es2021: true
-    },
-    extends: ["eslint:recommended", "prettier"],
-    parserOptions: {
-      ecmaVersion: "latest",
-      sourceType: "module"
-    },
-    rules: {}
-  };
-  
-  fs.writeFileSync(
-    path.join(projectRoot, '.eslintrc.json'),
-    JSON.stringify(eslintConfig, null, 2) + '\n'
-  );
-}
-
 // Process services
 if (isInMicroserviceProject || config.projectType === "microservice") {
   // Create shared folder for config and utils (only once)
@@ -247,6 +156,26 @@ if (isInMicroserviceProject || config.projectType === "microservice") {
   // Store for later use
   config.allInstallsSucceeded = allInstallsSucceeded;
 
+  // Transform to JavaScript if selected (for microservices)
+  if (config.language === "javascript") {
+    console.log(`\n${pc.cyan("⚙️  Converting microservices to JavaScript...")}\n`);
+    
+    // Transform shared folder
+    const sharedDir = path.join(target, "shared");
+    if (fs.existsSync(sharedDir)) {
+      transformDirectory(sharedDir);
+    }
+    
+    // Transform each service
+    for (const serviceName of allServices) {
+      const serviceRoot = path.join(target, "services", serviceName);
+      console.log(pc.dim(`   Transforming ${serviceName}...`));
+      transformToJavaScript(serviceRoot);
+    }
+    
+    console.log(pc.green("✓ JavaScript transformation complete\n"));
+  }
+
   if (mode === "docker") {
     generateDockerCompose(target, allServices);
     copyDockerfile(target, servicesToCreate);

package/bin/lib/prompts.js

@@ -59,19 +59,19 @@ export const getProjectConfig = async () => {
       initial: 0,
     },
     {
-      type: isInMicroserviceProject || hasCliArgs || isCI ? null : "text",
+      type: isInMicroserviceProject || isCI ? null : "text",
       name: "description",
       message: pc.cyan("Project description") + pc.dim(" (optional)"),
       initial: "",
     },
     {
-      type: isInMicroserviceProject || hasCliArgs || isCI ? null : "text",
+      type: isInMicroserviceProject || isCI ? null : "text",
       name: "author",
       message: pc.cyan("Author") + pc.dim(" (optional)"),
       initial: "",
     },
     {
-      type: isInMicroserviceProject || hasCliArgs || isCI ? null : "text",
+      type: isInMicroserviceProject || isCI ? null : "text",
       name: "keywords",
       message: pc.cyan("Keywords") + pc.dim(" (comma-separated, optional)"),
       initial: "",
@@ -135,7 +135,35 @@ export const getProjectConfig = async () => {
         { title: pc.blue("CORS"), value: "cors" },
       ],
     },
-  ]);
+  ],
+  {
+    onCancel: () => {
+      console.log(pc.yellow("\n❌ Operation cancelled by user."));
+      process.exit(0);
+    }
+  });
+
+  // Handle cancelled prompts (user pressed Ctrl+C or closed the prompt)
+  // Check if user cancelled the prompt (Ctrl+C) vs just didn't enter anything
+  if (!res) {
+    console.log(pc.yellow("\n❌ Operation cancelled by user."));
+    process.exit(0);
+  }
+  
+  // Check if critical fields are missing (indicates cancellation mid-prompt)
+  if (!isInMicroserviceProject && !isCI) {
+    // For new projects, we need language and projectType
+    if (!res.language || (!res.projectType && !cliProjectType)) {
+      console.log(pc.yellow("\n❌ Operation cancelled by user."));
+      process.exit(0);
+    }
+  }
+  
+  // If the response is empty but we expected prompts, something went wrong
+  if (Object.keys(res).length === 0 && !isInMicroserviceProject && !hasCliArgs && !isCI) {
+    console.log(pc.red("\n❌ No inputs received. Please try again."));
+    process.exit(1);
+  }
 
   // Set defaults for CI/non-interactive mode
   if (isCI) {
@@ -155,6 +183,11 @@ export const getProjectConfig = async () => {
       res.projectType = res.projectType || "monolith";
     }
   }
+  
+  // Ensure we have a project name (fallback if somehow missed)
+  if (!res.name && !isInMicroserviceProject) {
+    res.name = "my-backend";
+  }
 
   let sanitizedName, target, isExistingProject, mode;
 

package/bin/lib/service-setup.js

@@ -5,6 +5,19 @@ import pc from "picocolors";
 import { execSync } from "child_process";
 import { fileURLToPath } from "url";
 
+// Helper function to get the correct file extension (.ts or .js)
+function getFileExtension(dir) {
+  // Check if .ts files exist, otherwise use .js
+  const sampleFiles = ['src/app.ts', 'src/server.ts', 'src/routes.ts'];
+  for (const file of sampleFiles) {
+    const tsPath = path.join(dir, file);
+    if (fs.existsSync(tsPath)) return 'ts';
+    const jsPath = path.join(dir, file.replace('.ts', '.js'));
+    if (fs.existsSync(jsPath)) return 'js';
+  }
+  return 'ts'; // default to ts
+}
+
 export const setupService = async (
   res,
   serviceName,
@@ -18,6 +31,9 @@ export const setupService = async (
   let devDeps = [];
   let v1Imports = [];
   let v1Routes = [];
+  
+  // Detect file extension (ts or js)
+  const ext = getFileExtension(serviceRoot);
 
   // Special handling for gateway service
   if (serviceName === "gateway") {
@@ -25,8 +41,8 @@ export const setupService = async (
     deps.push(...gatewayModule.gatewayDeps);
 
     // Copy gateway-specific files
-    const gatewayAppPath = path.join(serviceRoot, "src/app.ts");
-    const gatewayServerPath = path.join(serviceRoot, "src/server.ts");
+    const gatewayAppPath = path.join(serviceRoot, `src/app.${ext}`);
+    const gatewayServerPath = path.join(serviceRoot, `src/server.${ext}`);
     const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
     const gatewayAppContent = fs.readFileSync(
@@ -46,7 +62,7 @@ export const setupService = async (
     fs.writeFileSync(gatewayServerPath, gatewayServerContent);
 
     // Remove unnecessary files for gateway
-    const routesPath = path.join(serviceRoot, "src/routes.ts");
+    const routesPath = path.join(serviceRoot, `src/routes.${ext}`);
     const modulesPath = path.join(serviceRoot, "src/modules");
     const middlewaresPath = path.join(serviceRoot, "src/middlewares");
 
@@ -125,15 +141,15 @@ export const setupService = async (
       v1Routes.push(baseAuth.middleware);
     }
 
-    // Update app.ts
-    const appPath = path.join(serviceRoot, "src/app.ts");
+    // Update app file
+    const appPath = path.join(serviceRoot, `src/app.${ext}`);
     let content = fs.readFileSync(appPath, "utf8");
     content = content.replace("/*__IMPORTS__*/", imports.join("\n"));
     content = content.replace("/*__MIDDLEWARE__*/", middlewares.join("\n"));
     fs.writeFileSync(appPath, content);
 
     // Update root endpoint middleware with project info
-    const rootMiddlewarePath = path.join(serviceRoot, "src/middlewares/root.middleware.ts");
+    const rootMiddlewarePath = path.join(serviceRoot, `src/middlewares/root.middleware.${ext}`);
     if (fs.existsSync(rootMiddlewarePath)) {
       let rootContent = fs.readFileSync(rootMiddlewarePath, "utf8");
       rootContent = rootContent.replace("/*__PROJECT_NAME__*/", serviceName || res.sanitizedName);
@@ -152,9 +168,9 @@ export const setupService = async (
       fs.writeFileSync(rootMiddlewarePath, rootContent);
     }
 
-    // Update v1 index.ts if needed
+    // Update v1 index file if needed
     if (v1Imports.length || v1Routes.length) {
-      const v1IndexPath = path.join(serviceRoot, "src/modules/v1/index.ts");
+      const v1IndexPath = path.join(serviceRoot, `src/modules/v1/index.${ext}`);
       let v1Content = fs.readFileSync(v1IndexPath, "utf8");
 
       const lastImportIndex = v1Content.lastIndexOf("import");
@@ -175,8 +191,8 @@ export const setupService = async (
       fs.writeFileSync(v1IndexPath, v1Content);
     }
     
-    // Update env.ts to conditionally include ALLOWED_ORIGIN and MONGO_URI
-    const envPath = path.join(serviceRoot, "src/config/env.ts");
+    // Update env file to conditionally include ALLOWED_ORIGIN and MONGO_URI
+    const envPath = path.join(serviceRoot, `src/config/env.${ext}`);
     if (fs.existsSync(envPath)) {
       let envContent = fs.readFileSync(envPath, "utf8");
       
@@ -220,8 +236,8 @@ export const setupService = async (
       fs.writeFileSync(envPath, envContent);
     }
     
-    // Update server.ts to connect to DB if auth is enabled
-    const serverPath = path.join(serviceRoot, "src/server.ts");
+    // Update server file to connect to DB if auth is enabled
+    const serverPath = path.join(serviceRoot, `src/server.${ext}`);
     if (fs.existsSync(serverPath)) {
       let serverContent = fs.readFileSync(serverPath, "utf8");
       
@@ -334,6 +350,14 @@ await connectDB();`
     finalPackageJson.keywords = res.keywords.split(',').map(k => k.trim()).filter(Boolean);
   }
   
+  // Add Node.js native path aliasing for JavaScript projects
+  // This replaces TypeScript's tsconfig paths with Node's native imports field
+  if (res.language === 'javascript') {
+    finalPackageJson.imports = {
+      "#/*": "./src/*"
+    };
+  }
+  
   fs.writeFileSync(
     packageJsonPath,
     JSON.stringify(finalPackageJson, null, 2) + "\n"

package/bin/lib/ts-to-js.js

@@ -4,7 +4,7 @@
  */
 
 /**
- * Strip TypeScript type annotations from code
+ * Strip TypeScript type annotations from code and fix imports for JavaScript
  * @param {string} content - TypeScript file content
  * @returns {string} - JavaScript content
  */
@@ -20,42 +20,114 @@ export function stripTypeScript(content) {
     return match.replace(/,?\s*type\s+\w+/g, '').replace(/\{\s*,/, '{').replace(/,\s*\}/, '}');
   });
 
+  // Remove imports from express types (Request, Response, NextFunction, etc.)
+  jsContent = jsContent.replace(/import\s*\{\s*Request\s*,\s*Response\s*,\s*NextFunction\s*\}\s*from\s*["']express["'];?\s*\n/gm, '');
+  jsContent = jsContent.replace(/import\s*\{\s*Request\s*,\s*Response\s*\}\s*from\s*["']express["'];?\s*\n/gm, '');
+  jsContent = jsContent.replace(/import\s*\{\s*Response\s*,\s*Request\s*\}\s*from\s*["']express["'];?\s*\n/gm, '');
+  jsContent = jsContent.replace(/import\s*\{\s*Request\s*\}\s*from\s*["']express["'];?\s*\n/gm, '');
+  jsContent = jsContent.replace(/import\s*\{\s*Response\s*\}\s*from\s*["']express["'];?\s*\n/gm, '');
+  jsContent = jsContent.replace(/import\s*\{\s*NextFunction\s*\}\s*from\s*["']express["'];?\s*\n/gm, '');
+
   // Remove interface declarations
-  jsContent = jsContent.replace(/^export\s+interface\s+\w+\s*\{[^}]*\}\s*$/gm, '');
-  jsContent = jsContent.replace(/^interface\s+\w+\s*\{[^}]*\}\s*$/gm, '');
+  // CRITICAL: Must have 'interface' keyword explicitly (not 'const' or other keywords)
+  // Single-line interfaces
+  jsContent = jsContent.replace(/^export\s+interface\s+\w+(\s+extends\s+[\w,\s]+)?\s*\{[^}]*\}\s*;?\s*$/gm, '');
+  jsContent = jsContent.replace(/^interface\s+\w+(\s+extends\s+[\w,\s]+)?\s*\{[^}]*\}\s*;?\s*$/gm, '');
+  
+  // Multi-line interfaces - must have a line break after the interface name/extends before {
+  // This prevents matching regular object literals
+  jsContent = jsContent.replace(/^export\s+interface\s+\w+(\s+extends\s+[\w,\s<>]+)?\s*\{[\s\S]*?^}/gm, '');
+  jsContent = jsContent.replace(/^interface\s+\w+(\s+extends\s+[\w,\s<>]+)?\s*\{[\s\S]*?^}/gm, '');
 
   // Remove type aliases
   jsContent = jsContent.replace(/^export\s+type\s+\w+\s*=\s*[^;]+;\s*$/gm, '');
   jsContent = jsContent.replace(/^type\s+\w+\s*=\s*[^;]+;\s*$/gm, '');
+  
+  // Remove class property type annotations: public/private/protected status: number;
+  // CRITICAL: Only match single-line class properties (use [^\n;=]+ instead of [^;=]+)
+  jsContent = jsContent.replace(/^\s*(public|private|protected)?\s+(\w+)\s*:\s*[^\n;=]+;/gm, '');
+  
+  // Remove visibility modifiers and types from constructor parameters
+  jsContent = jsContent.replace(/constructor\s*\(\s*([^)]*)\)\s*\{/g, (match, params) => {
+    if (!params.trim()) return 'constructor() {';
+    const cleanParams = params
+      .split(',')
+      .map(p => {
+        // Remove visibility modifiers
+        let cleaned = p.replace(/^\s*(public|private|protected)\s+/, '');
+        // Remove type annotation (everything after :)
+        cleaned = cleaned.replace(/:\s*[^=,]+/, '');
+        return cleaned.trim();
+      })
+      .filter(p => p)
+      .join(', ');
+    return `constructor(${cleanParams}) {`;
+  });
 
-  // Remove parameter types: (param: Type) => (param)
-  jsContent = jsContent.replace(/\(\s*(\w+)\s*:\s*[^,)]+/g, '($1');
-  jsContent = jsContent.replace(/,\s*(\w+)\s*:\s*[^,)]+/g, ', $1');
+  // Remove ! non-null assertions FIRST (before other transformations)
+  // Only remove ! that appears after identifiers, closing brackets, or closing parentheses
+  // Be very conservative to avoid breaking other syntax
+  jsContent = jsContent.replace(/([a-zA-Z0-9_\])])!/g, '$1');
   
-  // Remove return types: ): Type => ): void => ()
-  jsContent = jsContent.replace(/\)\s*:\s*[^{=>\n]+\s*=>/g, ') =>');
-  jsContent = jsContent.replace(/\)\s*:\s*[^{=>\n]+\s*\{/g, ') {');
+  // Remove function parameter types - IMPROVED VERSION
+  // Handle spread parameters: ...args: Type[] => ...args
+  jsContent = jsContent.replace(/(\.\.\.\s*\w+)\s*:\s*[^,)]+/g, '$1');
   
-  // Remove variable type annotations: const x: Type = ... => const x = ...
-  jsContent = jsContent.replace(/:\s*[^=\n]+(?=\s*=)/g, '');
+  // Handle regular parameters with more precision
+  // Strategy: Clean type annotations from parameter lists while avoiding object literals in function CALLS
   
-  // Remove function return types
-  jsContent = jsContent.replace(/function\s+(\w+)\s*\([^)]*\)\s*:\s*[^{]+\{/g, 'function $1($2) {');
+  // 1. Function declarations: function name(params) {
+  jsContent = jsContent.replace(/function\s+\w+\s*\(([^)]*)\)/g, (match, params) => {
+    if (!params.includes(':')) return match;
+    // Skip if it has object literals (look for : followed by value, not type)
+    // Object literals have patterns like {key: value} while types have param: Type
+    const cleaned = params.split(',').map(p => p.replace(/:\s*[^,=)]+(?=[,)]|$)/, '')).join(',');
+    return match.replace(params, cleaned);
+  });
   
-  // Remove as type assertions
-  jsContent = jsContent.replace(/\s+as\s+\w+/g, '');
+  // 2. Arrow functions: (params) => or (params) => {
+  // Be more specific: only skip if we see actual object literal patterns {key:value}
+  jsContent = jsContent.replace(/\(([^)]+)\)\s*=>/g, (match, params) => {
+    if (!params.includes(':')) return match;
+    
+    // Check if this looks like an object literal: has both { and } with content between
+    if (/\{[^}]+\}/.test(params)) return match;
+    
+    const cleaned = params.split(',').map(p => p.replace(/:\s*[^,=)]+(?=[,)]|$)/, '')).join(',');
+    return `(${cleaned}) =>`;
+  });
   
-  // Remove angle bracket type assertions: <Type>value => value
-  jsContent = jsContent.replace(/<\w+>/g, '');
+  // 3. Method definitions in classes/objects: methodName(params) {
+  jsContent = jsContent.replace(/(\w+)\s*\(([^)]*)\)\s*\{/g, (match, name, params) => {
+    if (!params.includes(':')) return match;
+    // Skip if it looks like object destructuring in params
+    if (/\{[^}]+\}/.test(params)) return match;
+    const cleaned = params.split(',').map(p => p.replace(/:\s*[^,=)]+(?=[,)]|$)/, '')).join(',');
+    return `${name}(${cleaned}) {`;
+  });
+  
+  // Remove return type annotations - IMPROVED VERSION
+  // Match ): Type => but only consume the type part
+  jsContent = jsContent.replace(/\)\s*:\s*[^{=>]+(\s*=>)/g, ')$1');
+  jsContent = jsContent.replace(/\)\s*:\s*[^{=>]+(\s*\{)/g, ')$1');
+  
+  // Remove function parameter types in function declarations
+  jsContent = jsContent.replace(/function\s+(\w+)\s*:\s*[^=]+/g, 'function $1');
   
-  // Remove ! non-null assertions
-  jsContent = jsContent.replace(/(\w+)!/g, '$1');
+  // Remove as type assertions (including 'as const')
+  jsContent = jsContent.replace(/\s+as\s+(const|any|unknown|readonly|\w+)/g, '');
   
-  // Remove ? optional chaining that's TypeScript specific
-  // Keep ?. and ?? as they're valid JS
+  // Remove satisfies operators
+  jsContent = jsContent.replace(/\s+satisfies\s+[^;,\n]+/g, '');
   
-  // Remove generic type parameters
-  jsContent = jsContent.replace(/<[^>]+>/g, '');
+  // Remove angle bracket type assertions: <Type>value => value (but not JSX)
+  jsContent = jsContent.replace(/<[\w\[\]]+>(?=[^<]*[^>])/g, '');
+  
+  // Remove optional property markers: property?: Type => property
+  jsContent = jsContent.replace(/(\w+)\?\s*:/g, '$1:');
+  
+  // Remove generic type parameters from class/function declarations
+  jsContent = jsContent.replace(/(class|function|interface)\s+(\w+)\s*<[^>]+>/g, '$1 $2');
   
   // Remove enum declarations (convert to object)
   jsContent = jsContent.replace(/enum\s+(\w+)\s*\{([^}]+)\}/g, (match, name, body) => {
@@ -67,6 +139,30 @@ export function stripTypeScript(content) {
     return `const ${name} = {\n${obj}\n}`;
   });
 
+  // Fix import paths for Node.js ESM
+  // 1. Replace TypeScript alias @/ with Node.js native #/
+  jsContent = jsContent.replace(/from\s+["']@\//g, 'from "#/');
+  jsContent = jsContent.replace(/import\s*\(\s*["']@\//g, 'import("#/');
+  jsContent = jsContent.replace(/require\s*\(\s*["']@\//g, 'require("#/');
+  
+  // 2. Add .js extension to #/ imports (they're now pointing to .js files)
+  jsContent = jsContent.replace(/from\s+["']#\/([^"']+)["']/g, (match, path) => {
+    // Don't add .js if it already has an extension or is a directory import
+    if (path.endsWith('.js') || path.endsWith('.json') || path.endsWith('/')) {
+      return match;
+    }
+    return `from "#/${path}.js"`;
+  });
+  
+  // 3. Add .js extension to relative imports
+  jsContent = jsContent.replace(/from\s+["'](\.\.?\/[^"']+)["']/g, (match, path) => {
+    // Don't add .js if it already has an extension
+    if (path.match(/\.\w+$/)) {
+      return match;
+    }
+    return `from "${path}.js"`;
+  });
+
   // Remove multiple consecutive blank lines
   jsContent = jsContent.replace(/\n\s*\n\s*\n/g, '\n\n');
 
@@ -121,3 +217,126 @@ export function getJavaScriptDependencies(originalDeps, originalDevDeps) {
     devDependencies: devDeps
   };
 }
+
+/**
+ * Get package.json imports field for Node.js native path aliasing
+ * This replaces TypeScript's tsconfig paths with Node's native imports
+ * @returns {Object} - imports configuration
+ */
+export function getNodeImportsConfig() {
+  return {
+    "#/*": "./src/*"
+  };
+}
+
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Transform a single TypeScript file to JavaScript
+ * @param {string} filePath - Path to .ts file
+ */
+function transformFile(filePath) {
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const jsContent = stripTypeScript(content);
+  
+  // Write to .js file
+  const jsFilePath = filePath.replace(/\.ts$/, '.js');
+  fs.writeFileSync(jsFilePath, jsContent);
+  
+  // Remove original .ts file
+  fs.unlinkSync(filePath);
+}
+
+/**
+ * Recursively transform all .ts files in a directory to .js
+ * @param {string} dir - Directory path
+ */
+export function transformDirectory(dir) {
+  if (!fs.existsSync(dir)) return;
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      // Skip node_modules and other non-source directories
+      if (entry.name === 'node_modules' || entry.name === '.git') {
+        continue;
+      }
+      transformDirectory(fullPath);
+    } else if (entry.isFile() && entry.name.endsWith('.ts')) {
+      transformFile(fullPath);
+    }
+  }
+}
+
+/**
+ * Main function to transform a TypeScript project to JavaScript
+ * @param {string} targetDir - Root directory of the project
+ */
+export function transformToJavaScript(targetDir) {
+  // Transform all .ts files to .js
+  const srcDir = path.join(targetDir, 'src');
+  if (fs.existsSync(srcDir)) {
+    transformDirectory(srcDir);
+  }
+
+  // Update package.json
+  const packageJsonPath = path.join(targetDir, 'package.json');
+  if (fs.existsSync(packageJsonPath)) {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+
+    // Get JavaScript dependencies
+    const { dependencies, devDependencies } = getJavaScriptDependencies(
+      packageJson.dependencies || {},
+      packageJson.devDependencies || {}
+    );
+
+    // Update package.json
+    packageJson.dependencies = dependencies;
+    packageJson.devDependencies = devDependencies;
+    packageJson.scripts = getJavaScriptScripts();
+    
+    // Add Node.js native imports for path aliasing
+    packageJson.imports = getNodeImportsConfig();
+
+    // Ensure type: module is set
+    packageJson.type = 'module';
+
+    fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
+  }
+
+  // Remove tsconfig.json if it exists
+  const tsconfigPath = path.join(targetDir, 'tsconfig.json');
+  if (fs.existsSync(tsconfigPath)) {
+    fs.unlinkSync(tsconfigPath);
+  }
+
+  // Update .prettierrc if it exists to use .js instead of .ts
+  const prettierrcPath = path.join(targetDir, '.prettierrc');
+  if (fs.existsSync(prettierrcPath)) {
+    let prettierConfig = fs.readFileSync(prettierrcPath, 'utf-8');
+    prettierConfig = prettierConfig.replace(/\.ts/g, '.js');
+    fs.writeFileSync(prettierrcPath, prettierConfig);
+  }
+
+  // Update eslint.config.js if it exists
+  const eslintConfigPath = path.join(targetDir, 'eslint.config.js');
+  if (fs.existsSync(eslintConfigPath)) {
+    let eslintConfig = fs.readFileSync(eslintConfigPath, 'utf-8');
+    
+    // Remove TypeScript parser and plugin
+    eslintConfig = eslintConfig.replace(/@typescript-eslint\/parser/g, '');
+    eslintConfig = eslintConfig.replace(/@typescript-eslint\/eslint-plugin/g, '');
+    eslintConfig = eslintConfig.replace(/tseslint\./g, '');
+    eslintConfig = eslintConfig.replace(/import tseslint[^\n]+\n/g, '');
+    
+    // Update file patterns
+    eslintConfig = eslintConfig.replace(/\*\*\/\*\.ts/g, '**/*.js');
+    
+    fs.writeFileSync(eslintConfigPath, eslintConfig);
+  }
+}
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ifecodes/backend-template",
-  "version": "1.1.0",
+  "version": "1.1.3",
   "description": "Production-ready Express + TypeScript/JavaScript backend generator with optional features and microservice support",
   "bin": {
     "ifecodes-template": "bin/cli.js"

package/template/base/src/utils/http-error.ts

@@ -43,5 +43,3 @@ export class InternalServerError extends HttpError {
     super(500, message);
   }
 }
-
-export default HttpError;

package/template/base/src/utils/logger.ts

@@ -1,7 +1,17 @@
 import { ENV } from "@/config";
 
-function format(tag: string, args: unknown[]) {
-  return [`%c[${tag}]`, "color:#6366f1;font-weight:600", ...args];
+// ANSI color codes for terminal output
+const colors = {
+  reset: "\x1b[0m",
+  blue: "\x1b[34m",
+  cyan: "\x1b[36m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  bold: "\x1b[1m",
+};
+
+function format(tag: string, color: string) {
+  return `${color}${colors.bold}[${tag}]${colors.reset}`;
 }
 
 function getEnvironment() {
@@ -13,22 +23,22 @@ function getEnvironment() {
 const logger = {
   log(tag: string, ...args: unknown[]) {
     if (getEnvironment() !== "development") return;
-    console.log(...format(tag, args));
+    console.log(format(tag, colors.blue), ...args);
   },
 
   info(tag: string, ...args: unknown[]) {
     if (getEnvironment() !== "development") return;
-    console.info(...format(tag, args));
+    console.info(format(tag, colors.cyan), ...args);
   },
 
   warn(tag: string, ...args: unknown[]) {
     if (getEnvironment() !== "development") return;
-    console.warn(...format(tag, args));
+    console.warn(format(tag, colors.yellow), ...args);
   },
 
   error(tag: string, ...args: unknown[]) {
     if (getEnvironment() !== "development") return;
-    console.error(...format(tag, args));
+    console.error(format(tag, colors.red), ...args);
   },
 };