@dolphjs/cli 1.4.1 → 2.0.0

package/dist/index.js

@@ -1,32 +1,113 @@
 #!/usr/bin/env node
-import chalk from "chalk";
-import { program } from "commander";
-import figlet from "figlet";
-import { packageDescription } from "./utils/package_description.js";
-import { configurePackage } from "./utils/read_user_config.js";
-import { InitDolphCli } from "./utils/package_init.js";
-import { packageGenerator } from "./utils/package_generator.js";
-import { watcherConfig } from "./daemon/watcherConfig.js";
-figlet.text("dolph cli", {
-    font: "Big",
-    horizontalLayout: "default",
-    verticalLayout: "default",
-    width: 150,
-    whitespaceBreak: true,
-}, function (err, _data) {
-    if (err) {
-        console.log("[FIGLET ERROR]: ", chalk.red(err.toString()));
-        return;
+"use strict";
+// import chalk from "chalk";
+// import { program } from "commander";
+// import figlet from "figlet";
+// import { packageDescription } from "./utils/package_description.js";
+// import { configurePackage } from "./utils/read_user_config.js";
+// import { InitDolphCli } from "./utils/package_init.js";
+// import { packageGenerator } from "./utils/package_generator.js";
+// import { watcherConfig } from "./daemon/watcherConfig.js";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// figlet.text(
+//   "dolph cli",
+//   {
+//     font: "Big",
+//     horizontalLayout: "default",
+//     verticalLayout: "default",
+//     width: 150,
+//     whitespaceBreak: true,
+//   },
+//   function (err: any, _data: any) {
+//     if (err) {
+//       console.log("[FIGLET ERROR]: ", chalk.red(err.toString()));
+//       return;
+//     }
+//     // console.log(chalk.bold(chalk.cyan(data)));
+//     InitDolphCli();
+//     packageDescription();
+//     configurePackage();
+//     packageGenerator();
+//     watcherConfig();
+//     program.command("*", { hidden: true }).action(() => {
+//       console.log(
+//         `${chalk.red("[DOLPH ERROR]: ")} ${chalk.redBright(
+//           "unknown command. See list of available commands: "
+//         )}`
+//       );
+//       program.help();
+//     });
+//     program.parse(process.argv);
+//   }
+// );
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+function getBinaryPath() {
+    const platform = os.platform();
+    const arch = os.arch();
+    let binaryName = "dolph";
+    if (platform === "win32") {
+        binaryName = "dolph.exe";
+    }
+    // const binaryPath = path.join(__dirname, "..", "bin", binaryName);
+    const binaryPath = path.join(__dirname, "../", "bin", binaryName);
+    if (!require("fs").existsSync(binaryPath)) {
+        console.log(`${chalk_1.default.red("[ERROR]: ")} ${chalk_1.default.blue(`DolphJS CLI binary not found. Please run "npm install" again.`)}`);
+        process.exit(1);
+    }
+    return binaryPath;
+}
+const binary = getBinaryPath();
+// Pass all arguments to the Rust binary
+const args = process.argv.slice(2);
+const child = (0, child_process_1.spawn)(binary, args, {
+    // This pipes input/output to the current terminal
+    stdio: "inherit",
+});
+child.on("error", (err) => {
+    console.log(`${chalk_1.default.red("[ERROR]: ")} ${chalk_1.default.blue(`Failed to start DolphJS CLI: ${err.message}`)}`);
+    process.exit(1);
+});
+child.on("close", (code) => {
+    if (code !== null) {
+        process.exit(code);
     }
-    // console.log(chalk.bold(chalk.cyan(data)));
-    InitDolphCli();
-    packageDescription();
-    configurePackage();
-    packageGenerator();
-    watcherConfig();
-    program.command("*", { hidden: true }).action(() => {
-        console.log(`${chalk.red("[DOLPH ERROR]: ")} ${chalk.redBright("unknown command. See list of available commands: ")}`);
-        program.help();
-    });
-    program.parse(process.argv);
 });

package/dist/install.d.ts

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

package/dist/install.js

@@ -0,0 +1,149 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const https = __importStar(require("https"));
+const http = __importStar(require("http"));
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+async function downloadBinary() {
+    const platform = os.platform(); // 'darwin', 'linux', 'win32'
+    const arch = os.arch(); // 'x64', 'arm64'
+    let binaryName = "dolph";
+    let releaseAssetName = ""; // e.g., 'dolph-x86_64-apple-darwin.tar.gz' or 'dolph-x86_64-pc-windows-msvc.zip'
+    // Map Node.js platform/arch to the Rust target triples and asset names
+    if (platform === "darwin") {
+        if (arch === "arm64") {
+            releaseAssetName = "dolph-aarch64-apple-darwin";
+        }
+        else {
+            // x64
+            releaseAssetName = "dolph-x86_64-apple-darwin";
+        }
+        // macOS binaries are often just executable, not compressed, or .tar.gz
+        binaryName = "dolph"; // No .exe extension
+    }
+    else if (platform === "win32") {
+        releaseAssetName = "dolph-x86_64-pc-windows-msvc";
+        binaryName = "dolph.exe";
+    }
+    else if (platform === "linux") {
+        releaseAssetName = "dolph-x86_64-unknown-linux-gnu";
+        binaryName = "dolph";
+    }
+    else {
+        console.error(`Unsupported platform: ${platform}-${arch}`);
+        process.exit(1);
+    }
+    const version = require("../package.json").version; // Get version from package.json
+    let releaseUrl = `https://github.com/dolphjs/cli_v2/releases/download/v${version}/${releaseAssetName}.tar.gz`;
+    if (platform === "win32") {
+        releaseUrl = `https://github.com/dolphjs/cli_v2/releases/download/v${version}/${releaseAssetName}.zip`;
+    }
+    // Where to put the binary
+    const installDir = path.join(__dirname, "..", "bin");
+    if (!fs.existsSync(installDir)) {
+        fs.mkdirSync(installDir, { recursive: true });
+    }
+    const binaryPath = path.join(__dirname, "..", "bin", binaryName);
+    const archiveName = platform === "win32" ? "dolph.zip" : "dolph.tar.gz";
+    const archivePath = path.join(__dirname, "..", "bin", archiveName);
+    console.log(`${chalk_1.default.blue("[INFO]: ")} ${chalk_1.default.blue(`Downloading DolphJS CLI for ${platform}-${arch} from ${releaseUrl}...`)}`);
+    try {
+        await downloadWithRedirects(releaseUrl, archivePath);
+        console.log(`${chalk_1.default.blue("[INFO]: ")} Extracting archive...`);
+        if (platform === "win32") {
+            const extCmd = (0, child_process_1.spawnSync)("powershell", ["-command", `Expand-Archive -Path '${archivePath}' -DestinationPath '${installDir}' -Force`], { stdio: "inherit" });
+            if (extCmd.status !== 0)
+                throw new Error("Failed to extract zip archive");
+        }
+        else {
+            const extCmd = (0, child_process_1.spawnSync)("tar", ["-xzf", archivePath, "-C", installDir], { stdio: "inherit" });
+            if (extCmd.status !== 0)
+                throw new Error("Failed to extract tar archive");
+        }
+        fs.unlinkSync(archivePath);
+        fs.chmodSync(binaryPath, "755");
+        console.log(`${chalk_1.default.blue("[INFO]: ")} ${chalk_1.default.blue(`DolphJS CLI downloaded and installed successfully!`)}`);
+    }
+    catch (error) {
+        console.log(`${chalk_1.default.red("[ERROR]: ")} ${chalk_1.default.redBright(`Error downloading DolphJS CLI: ${error?.message || error}`)}`);
+        process.exit(1);
+    }
+}
+function downloadWithRedirects(url, filePath, maxRedirects = 5) {
+    return new Promise((resolve, reject) => {
+        if (maxRedirects < 0) {
+            return reject(new Error("Too many redirects"));
+        }
+        const parsedUrl = new URL(url);
+        const httpModule = parsedUrl.protocol === "https:" ? https : http;
+        const request = httpModule.get(url, (response) => {
+            // Handle redirects
+            if (response.statusCode >= 300 &&
+                response.statusCode < 400 &&
+                response.headers.location) {
+                const redirectUrl = response.headers.location.startsWith("http")
+                    ? response.headers.location
+                    : new URL(response.headers.location, url).href;
+                console.log(`Redirecting to: ${redirectUrl}`);
+                return downloadWithRedirects(redirectUrl, filePath, maxRedirects - 1)
+                    .then(resolve)
+                    .catch(reject);
+            }
+            // Handle error status codes
+            if (response.statusCode < 200 || response.statusCode >= 300) {
+                return reject(new Error(`Failed to download binary: HTTP status code ${response.statusCode}`));
+            }
+            // Create write stream and pipe response
+            const file = fs.createWriteStream(filePath);
+            response.pipe(file);
+            file.on("finish", () => {
+                file.close(() => resolve());
+            });
+            file.on("error", (err) => {
+                // Delete file on error
+                fs.unlink(filePath, () => reject(err));
+            });
+        });
+        request.on("error", (err) => reject(err));
+    });
+}
+downloadBinary();

package/dist/registers/register_component.d.ts

@@ -0,0 +1 @@
+export declare const addComponentToServerFile: (componentName: string) => Promise<void>;

package/dist/registers/register_component.js

@@ -1,49 +1,54 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { dolphMsg } from "../helpers/messages.js";
-import path from "path";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addComponentToServerFile = void 0;
+const fs_1 = require("fs");
+const messages_js_1 = require("../helpers/messages.js");
+const path_1 = __importDefault(require("path"));
 const createComponentDirectory = () => {
-    const projectRoot = path.join(process.cwd());
-    const userComponentPath = path.join(projectRoot, `/src/components`);
-    if (!existsSync(userComponentPath)) {
-        mkdirSync(userComponentPath);
+    const projectRoot = path_1.default.join(process.cwd());
+    const userComponentPath = path_1.default.join(projectRoot, `/src/components`);
+    if (!(0, fs_1.existsSync)(userComponentPath)) {
+        (0, fs_1.mkdirSync)(userComponentPath);
     }
 };
 const findSrcDirectory = () => {
     const rootDir = process.cwd();
     const possibleDirs = [`src`];
-    const srcDir = possibleDirs.find((dir) => existsSync(path.join(rootDir, dir)));
-    return srcDir ? path.join(rootDir, srcDir) : null;
+    const srcDir = possibleDirs.find((dir) => (0, fs_1.existsSync)(path_1.default.join(rootDir, dir)));
+    return srcDir ? path_1.default.join(rootDir, srcDir) : null;
 };
-export const addComponentToServerFile = async (componentName) => {
+const addComponentToServerFile = async (componentName) => {
     if (!componentName) {
-        dolphMsg.errorRed("component extension or name is required! 🤨");
+        messages_js_1.dolphMsg.errorRed("component extension or name is required! 🤨");
     }
     const serverDir = findSrcDirectory();
     if (!serverDir) {
-        dolphMsg.errorRed("something went wrong, please make sure to use the `new` command when creating a dolph project.");
+        messages_js_1.dolphMsg.errorRed("something went wrong, please make sure to use the `new` command when creating a dolph project.");
         return;
     }
-    const serverPath = path.join(serverDir, "server.ts");
+    const serverPath = path_1.default.join(serverDir, "server.ts");
     const capitalizedString = componentName.charAt(0).toUpperCase() + componentName.slice(1);
     const importStatement = `import { ${capitalizedString}Component } from "./components/${componentName}/${componentName}.component";`;
     try {
-        if (!existsSync(serverPath)) {
+        if (!(0, fs_1.existsSync)(serverPath)) {
             const fileContent = `import { DolphFactory } from "@dolphjs/dolph";
 ${importStatement}
 const dolph = new DolphFactory([${capitalizedString}Component]);
 dolph.start();
 `;
-            writeFileSync(serverPath, fileContent);
+            (0, fs_1.writeFileSync)(serverPath, fileContent);
         }
         else {
-            const fileContent = readFileSync(serverPath, "utf8");
+            const fileContent = (0, fs_1.readFileSync)(serverPath, "utf8");
             const newComponentInstance = `${capitalizedString}Component`;
             if (!fileContent.includes(importStatement)) {
                 const updatedContent = `${importStatement}\n${fileContent}`;
-                writeFileSync(serverPath, updatedContent);
+                (0, fs_1.writeFileSync)(serverPath, updatedContent);
             }
             if (fileContent.includes(`const dolph`)) {
-                // add new controller class to the existing array
                 const routesArrayMatch = fileContent.match(/const dolph = new DolphFactory\(([^)]+)\);/);
                 if (routesArrayMatch) {
                     const existingCode = routesArrayMatch[1].trim();
@@ -52,14 +57,15 @@ dolph.start();
                         ? existingCode.slice(0, -1) + `, ${newComponentInstance}]`
                         : newComponentInstance}`);
                     const updatedContents = `${importStatement}\n${fileContents}`;
-                    writeFileSync(serverPath, updatedContents);
+                    (0, fs_1.writeFileSync)(serverPath, updatedContents);
                 }
             }
         }
-        dolphMsg.info(`added ${capitalizedString}Component to components array in server.ts file.`);
+        messages_js_1.dolphMsg.info(`added ${capitalizedString}Component to components array in server.ts file.`);
         process.exit(0);
     }
     catch (e) {
-        dolphMsg.errorRed(e.toString());
+        messages_js_1.dolphMsg.errorRed(e.toString());
     }
 };
+exports.addComponentToServerFile = addComponentToServerFile;

package/dist/registers/register_controllers_in_components.d.ts

@@ -0,0 +1 @@
+export declare const addControllerInComponentFIle: (componentName: string) => Promise<void>;

package/dist/registers/register_controllers_in_components.js

@@ -1,44 +1,48 @@
-import { existsSync, readFileSync, writeFileSync } from "fs";
-import path from "path";
-import { dolphMsg } from "../helpers/messages.js";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addControllerInComponentFIle = void 0;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const messages_js_1 = require("../helpers/messages.js");
 const findComponentsDirectory = (componentName) => {
     const rootDir = process.cwd();
     const possibleDirs = [`src/components/${componentName}`];
-    const srcDir = possibleDirs.find((dir) => existsSync(path.join(rootDir, dir)));
-    return srcDir ? path.join(rootDir, srcDir) : null;
+    const srcDir = possibleDirs.find((dir) => (0, fs_1.existsSync)(path_1.default.join(rootDir, dir)));
+    return srcDir ? path_1.default.join(rootDir, srcDir) : null;
 };
-export const addControllerInComponentFIle = async (componentName) => {
+const addControllerInComponentFIle = async (componentName) => {
     if (!componentName) {
-        dolphMsg.errorRed("component extension or name is required! 🤨");
+        messages_js_1.dolphMsg.errorRed("component extension or name is required! 🤨");
     }
     const componentDir = findComponentsDirectory(componentName);
     if (!componentDir) {
-        dolphMsg.errorRed("something went wrong, please make sure to use the `new` command when creating a dolph project.");
+        messages_js_1.dolphMsg.errorRed("something went wrong, please make sure to use the `new` command when creating a dolph project.");
         return;
     }
-    const componentPath = path.join(componentDir, `${componentName}.component.ts`);
+    const componentPath = path_1.default.join(componentDir, `${componentName}.component.ts`);
     const capitalizedString = componentName.charAt(0).toUpperCase() + componentName.slice(1);
     const importStatement = `import { ${capitalizedString}Controller } from "./${componentName}.controller";`;
     try {
-        if (!existsSync(componentPath)) {
+        if (!(0, fs_1.existsSync)(componentPath)) {
             const fileContent = `import { Component } from "@dolphjs/dolph/decorators";
 import { ${capitalizedString}Controller } from "./${componentName}.controller";
 
 @Component({ controllers: [${capitalizedString}Controller], services: [] })
 export class ${capitalizedString}Component {}
 `;
-            writeFileSync(componentPath, fileContent);
+            (0, fs_1.writeFileSync)(componentPath, fileContent);
         }
         else {
-            const fileContent = readFileSync(componentPath, "utf8");
+            const fileContent = (0, fs_1.readFileSync)(componentPath, "utf8");
             const newComponentInstance = `${capitalizedString}Controller`;
             if (!fileContent.includes(importStatement)) {
-                // If import statement is not present, add it along with the new controller
                 const updatedContents = `${importStatement}\n${fileContent.replace(/@Component\(\s*{\s*controllers:\s*\[([^\]]*)\]\s*}\s*\)/, `@Component({ controllers: [${newComponentInstance}] })`)}`;
-                writeFileSync(componentPath, updatedContents);
+                (0, fs_1.writeFileSync)(componentPath, updatedContents);
             }
             else if (fileContent.includes(`const dolph`)) {
-                // If import statement is present and contains `const dolph`
                 const controllersArrayMatch = fileContent.match(/@Component\(\s*{\s*controllers:\s*\[([^\]]*)\]\s*}\s*\)/);
                 if (controllersArrayMatch) {
                     const existingCode = controllersArrayMatch[1].trim();
@@ -47,11 +51,11 @@ export class ${capitalizedString}Component {}
                         ? existingCode.slice(0, -1) + `, ${newComponentInstance}`
                         : newComponentInstance}`);
                     const updatedContents = `${importStatement}\n${fileContents}`;
-                    writeFileSync(componentPath, updatedContents);
+                    (0, fs_1.writeFileSync)(componentPath, updatedContents);
                 }
             }
         }
-        dolphMsg.info(`registered ${capitalizedString}Controller in ${capitalizedString}Component`);
+        messages_js_1.dolphMsg.info(`registered ${capitalizedString}Controller in ${capitalizedString}Component`);
         process.exit(0);
     }
     catch (error) {
@@ -59,3 +63,4 @@ export class ${capitalizedString}Component {}
         process.exit(1);
     }
 };
+exports.addControllerInComponentFIle = addControllerInComponentFIle;

package/dist/registers/register_routes.d.ts

@@ -0,0 +1 @@
+export declare const addRoutesIndexFile: (routesName: string, readConfig: any) => void;

package/dist/registers/register_routes.js

@@ -1,22 +1,21 @@
-import chalk from "chalk";
-import { existsSync, readFileSync, writeFileSync } from "fs";
-import path from "path";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addRoutesIndexFile = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
 const findRoutesDirectory = () => {
     const rootDir = process.cwd();
     const possibleDirs = [
         "/src/routes",
-        // "/src/Routes",
-        // "/src/route",
-        // "/src/Route",
-        // "/Routes",
-        // "/Route",
-        // "/routes",
-        // "/route",
     ];
-    const routesDir = possibleDirs.find((dir) => existsSync(path.join(rootDir, dir)));
-    return routesDir ? path.join(rootDir, routesDir) : null;
+    const routesDir = possibleDirs.find((dir) => (0, fs_1.existsSync)(path_1.default.join(rootDir, dir)));
+    return routesDir ? path_1.default.join(rootDir, routesDir) : null;
 };
-export const addRoutesIndexFile = (routesName, readConfig) => {
+const addRoutesIndexFile = (routesName, readConfig) => {
     let extension;
     let paradigm;
     paradigm = readConfig().paradigm;
@@ -32,14 +31,13 @@ export const addRoutesIndexFile = (routesName, readConfig) => {
             break;
     }
     if (!routesName)
-        chalk.bold(chalk.red("Routes extension or name is required! 🤨"));
+        chalk_1.default.bold(chalk_1.default.red("Routes extension or name is required! 🤨"));
     const routesDir = findRoutesDirectory();
     if (!routesDir) {
-        //TODO: create one if it doesn't exist
-        console.log(chalk.bold(chalk.red("Routes directory doesn't exist 🤨")));
+        console.log(chalk_1.default.bold(chalk_1.default.red("Routes directory doesn't exist 🤨")));
         return;
     }
-    const indexPath = path.join(routesDir, `index.${extension}`);
+    const indexPath = path_1.default.join(routesDir, `index.${extension}`);
     let importStatement = ``;
     const capitalizedString = routesName.charAt(0).toUpperCase() + routesName.slice(1);
     if (extension === "ts") {
@@ -55,7 +53,7 @@ export const addRoutesIndexFile = (routesName, readConfig) => {
         }
     }
     else {
-        console.log(chalk.bold(chalk.red("dolphjs only supports '.js' & '.ts' file extensions")));
+        console.log(chalk_1.default.bold(chalk_1.default.red("dolphjs only supports '.js' & '.ts' file extensions")));
     }
     let routesArray = "";
     if (extension === "ts") {
@@ -75,22 +73,19 @@ module.exports  = { routes };
         }
     }
     try {
-        // check if file exists
-        if (!existsSync(indexPath)) {
-            // if it doesn't exist, create file and add import statement
+        if (!(0, fs_1.existsSync)(indexPath)) {
             const fileContent = `${importStatement}\n\n${routesArray}\n`;
-            writeFileSync(indexPath, fileContent);
+            (0, fs_1.writeFileSync)(indexPath, fileContent);
         }
         else {
-            const fileContent = readFileSync(indexPath, "utf8");
+            const fileContent = (0, fs_1.readFileSync)(indexPath, "utf8");
             const newRouterInstance = `new ${capitalizedString}Router()`;
             const newRoutesInstance = `${routesName}Routes`;
             if (!fileContent.includes(importStatement)) {
                 const updatedContent = `${importStatement}\n${fileContent}`;
-                writeFileSync(indexPath, updatedContent);
+                (0, fs_1.writeFileSync)(indexPath, updatedContent);
             }
             if (fileContent.includes(`${extension === "ts" ? "export const routes" : "const routes"}`)) {
-                // add new routes instance to the exisiting routes array
                 if (extension === "ts") {
                     const routesArrayMatch = fileContent.match(/export const routes = \[([\s\S]+?)\];/);
                     if (routesArrayMatch) {
@@ -103,7 +98,7 @@ module.exports  = { routes };
                             fileContents = fileContent.replace(`[${existingRoutes}]`, `[${existingRoutes.length > 0 ? existingRoutes + ", " : ""}${newRoutesInstance}]`);
                         }
                         const updatedContents = `${importStatement}\n${fileContents}`;
-                        writeFileSync(indexPath, updatedContents);
+                        (0, fs_1.writeFileSync)(indexPath, updatedContents);
                     }
                 }
                 else {
@@ -118,27 +113,27 @@ module.exports  = { routes };
                             fileContents = fileContent.replace(`[${existingRoutes}]`, `[${existingRoutes.length > 0 ? existingRoutes + ", " : ""}${newRoutesInstance}]`);
                         }
                         const updatedContents = `${importStatement}\n${fileContents}`;
-                        writeFileSync(indexPath, updatedContents);
+                        (0, fs_1.writeFileSync)(indexPath, updatedContents);
                     }
                 }
             }
             else {
-                // if there is no routes array, add new one
                 if (extension === "ts") {
                     const updatedContents = `${fileContent.trim()}\n\nexport const routes = [${paradigm !== "oop" ? newRouterInstance : newRoutesInstance}];\n`;
-                    writeFileSync(indexPath, updatedContents);
+                    (0, fs_1.writeFileSync)(indexPath, updatedContents);
                 }
                 else {
                     const updatedContents = `${fileContent.trim()}\n\nconst routes = [${paradigm !== "oop" ? newRouterInstance : newRoutesInstance}];\n\n module.exports = { routes } \n`;
-                    writeFileSync(indexPath, updatedContents);
+                    (0, fs_1.writeFileSync)(indexPath, updatedContents);
                 }
             }
         }
-        console.log(chalk.bold(chalk.green(`added ${paradigm === "oop"
+        console.log(chalk_1.default.bold(chalk_1.default.green(`added ${paradigm === "oop"
             ? `${capitalizedString}Router`
             : `${routesName}Routes`} to routes array in index.${extension} file`)));
     }
     catch (e) {
-        console.log(chalk.bold(chalk.red(e)));
+        console.log(chalk_1.default.bold(chalk_1.default.red(e)));
     }
 };
+exports.addRoutesIndexFile = addRoutesIndexFile;

package/dist/registers/server_file_express.d.ts

@@ -0,0 +1 @@
+export declare const addServerFile: (readConfig: any) => void;