@dolphjs/cli 1.4.1 → 2.0.1

package/dist/generators/templates/socket_service_template.js

@@ -1,4 +1,7 @@
-export const generateSocketService = (componentName) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSocketService = void 0;
+const generateSocketService = (componentName) => {
     let template;
     const capitalizeFirstLetter = (str) => {
         return str.charAt(0).toUpperCase() + str.slice(1);
@@ -23,3 +26,4 @@ export class ${className} extends DolphSocketServiceHandler<Dolph> {
     `;
     return template;
 };
+exports.generateSocketService = generateSocketService;

package/dist/generators/templates/spring_component_template.d.ts

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

package/dist/generators/templates/spring_component_template.js

@@ -1,4 +1,7 @@
-export const generateSpringComponent = (componentName) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSpringComponent = void 0;
+const generateSpringComponent = (componentName) => {
     const capitalizeFirstLetter = (str) => {
         return str.charAt(0).toUpperCase() + str.slice(1);
     };
@@ -10,3 +13,4 @@ export class ${className} {}
 `;
     return template;
 };
+exports.generateSpringComponent = generateSpringComponent;

package/dist/generators/templates/spring_controller_template.d.ts

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

package/dist/generators/templates/spring_controller_template.js

@@ -1,4 +1,7 @@
-export const generateSpringController = (componentName) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSpringController = void 0;
+const generateSpringController = (componentName) => {
     const capitalizeFirstLetter = (str) => {
         return str.charAt(0).toUpperCase() + str.slice(1);
     };
@@ -26,3 +29,4 @@ export class ${className} extends DolphControllerHandler<Dolph> {
 `;
     return template;
 };
+exports.generateSpringController = generateSpringController;

package/dist/generators/templates/spring_model_template.d.ts

@@ -0,0 +1 @@
+export declare const generateSpringModel: (componentName: string, isMongo: boolean, isMysql: boolean) => any;

package/dist/generators/templates/spring_model_template.js

@@ -1,4 +1,7 @@
-export const generateSpringModel = (componentName, isMongo, isMysql) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSpringModel = void 0;
+const generateSpringModel = (componentName, isMongo, isMysql) => {
     let template;
     const capitalizeFirstLetter = (str) => {
         return str.charAt(0).toUpperCase() + str.slice(1);
@@ -38,3 +41,4 @@ export const ${capitalizeFirstLetter(componentName)} = sequelizeInstance.define(
     }
     return template;
 };
+exports.generateSpringModel = generateSpringModel;

package/dist/generators/templates/spring_service_template.d.ts

@@ -0,0 +1 @@
+export declare const generateSpringService: (componentName: string, isMongo: boolean, isMySql: boolean) => any;

package/dist/generators/templates/spring_service_template.js

@@ -1,4 +1,7 @@
-export const generateSpringService = (componentName, isMongo, isMySql) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSpringService = void 0;
+const generateSpringService = (componentName, isMongo, isMySql) => {
     let template;
     const capitalizeFirstLetter = (str) => {
         return str.charAt(0).toUpperCase() + str.slice(1);
@@ -80,3 +83,4 @@ export class ${className} extends DolphServiceHandler<Dolph> {
     }
     return template;
 };
+exports.generateSpringService = generateSpringService;

package/dist/get_file_stats.d.ts

@@ -0,0 +1 @@
+export declare const getFileStats: (filePath: string) => number;

package/dist/get_file_stats.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFileStats = void 0;
+const fs_1 = require("fs");
+const getFileStats = (filePath) => {
+    const stats = (0, fs_1.statSync)(filePath);
+    const sizeInBytes = stats.size;
+    return sizeInBytes;
+};
+exports.getFileStats = getFileStats;

package/dist/helpers/messages.d.ts

@@ -0,0 +1,8 @@
+export declare const dolphMsg: {
+    infoGreen: (message: string) => void;
+    infoYellow: (message: string) => void;
+    infoBlue: (message: string) => void;
+    info: (message: string) => void;
+    errorRed: (message: string) => void;
+    errorGray: (message: string) => void;
+};

package/dist/helpers/messages.js

@@ -1,9 +1,15 @@
-import chalk from "chalk";
-export const dolphMsg = {
-    infoGreen: (message) => console.log(chalk.bold(chalk.green("[DOLPH INFO]: ")) + chalk.greenBright(message)),
-    infoYellow: (message) => console.log(chalk.bold(chalk.yellow("[DOLPH INFO]: ")) + chalk.yellowBright(message)),
-    infoBlue: (message) => console.log(chalk.bold(chalk.blue("[DOLPH INFO]: ")) + chalk.blueBright(message)),
-    info: (message) => console.log(chalk.bold(chalk.blue("[DOLPH INFO]: " + chalk.white(message)))),
-    errorRed: (message) => console.log(chalk.bold(chalk.red("[DOLPH ERROR]: ")) + chalk.redBright(message)),
-    errorGray: (message) => console.log(chalk.bold(chalk.bgGrey("[DOLPH ERROR]: ")) + chalk.grey(message)),
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dolphMsg = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+exports.dolphMsg = {
+    infoGreen: (message) => console.log(chalk_1.default.bold(chalk_1.default.green("[DOLPH INFO]: ")) + chalk_1.default.greenBright(message)),
+    infoYellow: (message) => console.log(chalk_1.default.bold(chalk_1.default.yellow("[DOLPH INFO]: ")) + chalk_1.default.yellowBright(message)),
+    infoBlue: (message) => console.log(chalk_1.default.bold(chalk_1.default.blue("[DOLPH INFO]: ")) + chalk_1.default.blueBright(message)),
+    info: (message) => console.log(chalk_1.default.bold(chalk_1.default.blue("[DOLPH INFO]: " + chalk_1.default.white(message)))),
+    errorRed: (message) => console.log(chalk_1.default.bold(chalk_1.default.red("[DOLPH ERROR]: ")) + chalk_1.default.redBright(message)),
+    errorGray: (message) => console.log(chalk_1.default.bold(chalk_1.default.bgGrey("[DOLPH ERROR]: ")) + chalk_1.default.grey(message)),
 };

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

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;