@dolphjs/cli 1.1.6 → 1.1.8

package/dist/daemon/watcher.js

@@ -4,7 +4,7 @@ import chalk from "chalk";
 import { getRootDirectory } from "../utils/get_root_dir_path.js";
 import { readConfig } from "../utils/read_user_config_path.js";
 import { join } from "path";
-import { debounce } from "lodash";
+import _ from "lodash";
 let fileExtension = "";
 let indexFilePath = "";
 export const startApp = () => {
@@ -105,7 +105,7 @@ const watcher = chokidar.watch([], {
     ignoreInitial: false,
 });
 let isWatcherActive = false;
-const debouncedStartApp = debounce(startApp, 1000);
+const debouncedStartApp = _.debounce(startApp, 1000);
 export const watchFile = () => {
     if (!isWatcherActive) {
         console.log(`${chalk.bold(chalk.green("[DOLPH INFO]: "))} ${chalk.greenBright("watching files for changes ...")}`);

package/dist/generators/generate_controller.js

@@ -3,6 +3,7 @@ import path from "path";
 import chalk from "chalk";
 import { readConfig } from "../utils/read_user_config_path.js";
 import { resolveControllerContent } from "./resolvers/resolve_controller_content.js";
+import { generateController as generateSpringController } from "./spring/generate_spring_controller.js";
 const createControllerDirectory = () => {
     const projectRoot = path.join(process.cwd());
     const userControllerFilePath = path.join(projectRoot, "/src/controllers");
@@ -34,15 +35,13 @@ export const generateControllerFile = async (name, controllerDir, readConfig) =>
     });
 };
 export const generateController = async (name) => {
+    if (readConfig().routing === "spring") {
+        generateSpringController(name);
+    }
     if (!name)
         chalk.bold(chalk.red("Controller extension or name is required! 🤨"));
     let controllerDir = findControllerDirectory();
     if (!controllerDir) {
-        //TODO: create one if it doesn't exist
-        // console.log(
-        //   chalk.bold(chalk.red("controller directory doesn't exist 🤨"))
-        // );
-        // return;
         createControllerDirectory();
         controllerDir = findControllerDirectory();
     }

package/dist/generators/spring/generate_spring_component.js

@@ -0,0 +1,42 @@
+import { existsSync, mkdirSync, writeFile } from "fs";
+import path from "path";
+import chalk from "chalk";
+import { generateSpringComponent } from "../../generators/templates/spring_component_template.js";
+import { dolphMsg } from "../../helpers/messages.js";
+const createComponentDirectory = (componentName) => {
+    const projectRoot = path.join(process.cwd());
+    const userComponentPath = path.join(projectRoot, `/src/${componentName}`);
+    if (!existsSync(userComponentPath)) {
+        mkdirSync(userComponentPath);
+    }
+};
+const findComponentDirectory = (componentName) => {
+    const rootDir = process.cwd();
+    const possibleDirs = [`src/${componentName}`];
+    const componentDir = possibleDirs.find((dir) => existsSync(path.join(rootDir, dir)));
+    return componentDir ? path.join(rootDir, componentDir) : null;
+};
+export const generateSpringComponentFile = async (componentName, componentDir) => {
+    await writeFile(componentDir, generateSpringComponent(componentName), (error) => {
+        if (error) {
+            dolphMsg.errorRed(error.toString());
+        }
+    });
+};
+export const generateComponent = async (name) => {
+    if (!name)
+        dolphMsg.errorRed("component extension or name is required! 🤨");
+    let componentDir = findComponentDirectory(name);
+    if (!componentDir) {
+        createComponentDirectory(name);
+        componentDir = findComponentDirectory(name);
+    }
+    const componentFilePath = path.join(componentDir + `/${name}.component.ts`);
+    try {
+        generateSpringComponentFile(name, path.join(componentFilePath));
+    }
+    catch (e) {
+        dolphMsg.errorRed(e);
+    }
+    dolphMsg.info(`${chalk.blue(`${name}.component.ts`)} generated successfully for ${chalk.blue(`${name}`)} component.`);
+};

package/dist/generators/spring/generate_spring_controller.js

@@ -0,0 +1,42 @@
+import { existsSync, mkdirSync, writeFile } from "fs";
+import path from "path";
+import chalk from "chalk";
+import { generateSpringController } from "../../generators/templates/spring_controller_template.js";
+import { dolphMsg } from "../../helpers/messages.js";
+const createControllerDirectory = (componentName) => {
+    const projectRoot = path.join(process.cwd());
+    const userCompontrollerPath = path.join(projectRoot, `/src/${componentName}`);
+    if (!existsSync(userCompontrollerPath)) {
+        mkdirSync(userCompontrollerPath);
+    }
+};
+const findControllerDirectory = (componentName) => {
+    const rootDir = process.cwd();
+    const possibleDirs = [`src/${componentName}`];
+    const controllerDir = possibleDirs.find((dir) => existsSync(path.join(rootDir, dir)));
+    return controllerDir ? path.join(rootDir, controllerDir) : null;
+};
+export const generateSpringControllerFile = async (componentName, controllerDir) => {
+    await writeFile(controllerDir, generateSpringController(componentName), (error) => {
+        if (error) {
+            dolphMsg.errorRed(error.toString());
+        }
+    });
+};
+export const generateController = async (name) => {
+    if (!name)
+        dolphMsg.errorRed("controller extension or name is required! 🤨");
+    let controllerDir = findControllerDirectory(name);
+    if (!controllerDir) {
+        createControllerDirectory(name);
+        controllerDir = findControllerDirectory(name);
+    }
+    const controllerFilePath = path.join(controllerDir + `/${name}.controller.ts`);
+    try {
+        generateSpringControllerFile(name, path.join(controllerFilePath));
+    }
+    catch (e) {
+        dolphMsg.errorRed(e);
+    }
+    dolphMsg.info(`${chalk.blue(`${name}.controller.ts`)} generated successfully for ${chalk.blue(`${name}`)} component.`);
+};

package/dist/generators/templates/spring_component_template.js

@@ -0,0 +1,12 @@
+export const generateSpringComponent = (componentName) => {
+    const capitalizeFirstLetter = (str) => {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    };
+    const className = capitalizeFirstLetter(componentName) + "Component";
+    const template = `import { Component } from "@dolphjs/dolph/decorators";
+
+@Component({ controllers: [] })
+export class ${className} {}
+`;
+    return template;
+};

package/dist/generators/templates/spring_controller_template.js

@@ -0,0 +1,28 @@
+export const generateSpringController = (componentName) => {
+    const capitalizeFirstLetter = (str) => {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    };
+    const className = capitalizeFirstLetter(componentName) + "Controller";
+    const template = `import { DolphControllerHandler } from "@dolphjs/dolph/classes";
+import {
+  Dolph,
+  SuccessResponse,
+  DRequest,
+  DResponse
+} from "@dolphjs/dolph/common
+import { Get, Route } from "@dolphjs/dolph/decorators";
+
+@Route('${componentName}')
+export class ${className} extends DolphControllerHandler<Dolph> {
+  constructor() {
+    super();
+  }
+
+  @Get("greet")
+  async greet (req: DRequest, res: DResponse) {
+    SuccessResponse({ res, body: { message: "you've reached the ${componentName} endpoint." } });
+  }
+}
+`;
+    return template;
+};

package/dist/helpers/messages.js

@@ -0,0 +1,9 @@
+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)),
+};

package/dist/registers/register_routes.js

@@ -1,7 +1,6 @@
 import chalk from "chalk";
 import { existsSync, readFileSync, writeFileSync } from "fs";
 import path from "path";
-// removed other possible dirs to enforce dolphjs style guide
 const findRoutesDirectory = () => {
     const rootDir = process.cwd();
     const possibleDirs = [

package/dist/utils/init_helper_function.js

@@ -2,16 +2,16 @@ import { existsSync, mkdirSync, writeFileSync } from "fs";
 import inquirer from "inquirer";
 import path from "path";
 import yaml from "js-yaml";
-import chalk from "chalk";
 import { writeSwcrc } from "./write_swrcc.js";
 import { writeTsConfigFile } from "./write_tsconfig.js";
 import { writeDolphConfig } from "./write_dolph_config.js";
 import { writePackageJsonFile } from "./write_package_json.js";
 import { writeGitignore } from "./write_gitignore.js";
+import { dolphMsg } from "../helpers/messages.js";
 export const initDolphCli = (appname) => {
     let projectName = appname;
     if (appname.length === 0) {
-        console.log(chalk.red(chalk.bold("Provide a name for you project or indicate with a '.' to use current directory ")));
+        dolphMsg.errorGray("provide a name for you project or indicate with a '.' to use current directory.");
         return;
     }
     if (appname !== ".") {
@@ -35,6 +35,7 @@ export const initDolphCli = (appname) => {
         paradigm: "oop",
         database: "mongo",
         generateFolder: true,
+        routing: "express",
     };
     if (!existsSync(userConfigFilePath)) {
         inquirer
@@ -60,20 +61,23 @@ export const initDolphCli = (appname) => {
                 choices: ["mongo", "mysql", "postgresql", "other"],
                 default: "mongo",
             },
-            // {
-            //   type: "list",
-            //   name: "generateFolder",
-            //   message:
-            //     "Generate folder and files for the Services, Models, Controllers and Routes",
-            //   choices: ["true", "false"],
-            //   default: "true",
-            // },
+            {
+                type: "list",
+                name: "routing",
+                message: "Which dolph routing architecture would you be using? (choosing 'spring' means that you are making use of  both 'oop' & 'typescript')",
+                choices: ["express", "spring"],
+                default: "express",
+            },
         ])
             .then((replies) => {
             // TODO: add this to the config file:
-            // # this is an auto generate file, please do not edit manually
+            const comment = "# this is an auto-generated file, please do not edit manually\n";
+            if ((replies.routing = "spring")) {
+                replies.paradigm = "oop";
+                replies.language = "ts";
+            }
             const userConfig = { ...defaultConfig, ...replies };
-            const yamlString = yaml.dump(userConfig);
+            const yamlString = comment + yaml.dump(userConfig);
             writeFileSync(userConfigFilePath, yamlString, "utf8");
             if (userConfig.language === "ts") {
                 writeSwcrc();
@@ -82,12 +86,12 @@ export const initDolphCli = (appname) => {
             writeDolphConfig();
             writePackageJsonFile(projectName, userConfig.language);
             writeGitignore();
-            console.log(chalk.green(chalk.bold("dolph cli configurations have been initialized successfully 😎.")));
-            console.log(chalk.green(chalk.bold("run yarn install to install dependencies in project directory and start coding 😉.")));
+            dolphMsg.infoBlue("dolph configurations have been initialized successfully ✨.");
+            dolphMsg.infoYellow("run `yarn install` to install dependencies in project directory and start building 🚀.");
             process.exit(0);
         });
     }
     else {
-        console.log(chalk.bold(chalk.cyan("I see you already have your dolph cli configurations present 😉.")));
+        dolphMsg.info("I see you already have your dolph configurations present, so I'll abort gently ... 😉.");
     }
 };

package/dist/utils/package_description.js

@@ -3,5 +3,5 @@ import { program } from "commander";
 export const packageDescription = () => {
     program
         .version("1.1.0")
-        .description(chalk.cyan("The dolphjs-cli is a tool for efficient intialization and management of a dolphjs project"));
+        .description(chalk.cyan("The dolph-cli is a tool for efficient intialization and management of a dolphjs project"));
 };

package/dist/utils/package_generator.js

@@ -8,23 +8,18 @@ import * as mysqlGen from "../generators/generate_mysql.js";
 import { readConfig } from "./read_user_config_path.js";
 import { addRoutesIndexFile } from "../registers/register_routes.js";
 import { addServerFile } from "../registers/server_file_routes.js";
+import { dolphMsg } from "../helpers/messages.js";
+import { generateComponent } from "../generators/spring/generate_spring_component.js";
 export const packageGenerator = () => {
     program
         .command("generate")
         .alias("g")
         .option("-s, --service" + chalk.bold(chalk.blue("<name>")), "Generates a dolphjs service file.")
         .option("-c, --controller" + chalk.bold(chalk.blue("<name>")), "Generates a dolphjs controller file.")
-        .option("-r, --routes" + chalk.bold(chalk.blue("<name>")), "Generates a dolphjs routes file.")
-        .option("-m, --models" + chalk.bold(chalk.blue("<name>")), "Generates a dolphjs models file.")
-        .option("-a, --all" + chalk.bold(chalk.blue("<name>")), "Generates dolphjs ocntrollers, routes, models and services files for the name paramter.")
-        // .option(
-        //   "-in, --interfaces" + chalk.bold(chalk.blue("<name>")),
-        //   "Generates a dolphjs interfaces file."
-        // )
-        // .option(
-        //   "-hp, --helper" + chalk.bold(chalk.blue("<name>")),
-        //   "Generates a dolphjs helper file."
-        // )
+        .option("-r, --route" + chalk.bold(chalk.blue("<name>")), "Generates a dolphjs routes file.")
+        .option("-m, --model" + chalk.bold(chalk.blue("<name>")), "Generates a dolphjs models file.")
+        .option("-com, --component" + chalk.bold(chalk.blue("<name>")), "Generates a dolphjs spring component file.")
+        .option("-a, --all" + chalk.bold(chalk.blue(" <name> ")), "Generates dolphjs controllers, routes, models and services files for the name paramter.")
         .action(async (name, _options) => {
         Object.entries(name).forEach(([key, value]) => {
             // generates controller files for the paramter name
@@ -36,17 +31,25 @@ export const packageGenerator = () => {
                 serviceGen.generateService(value.toString());
             }
             // generatess routes files for the paramter name
-            if (key && key.toLowerCase().includes("routes") && value) {
-                routesGen.generateRouter(value.toString());
-                addRoutesIndexFile(value.toString(), readConfig);
+            if (key && key.toLowerCase().includes("route") && value) {
+                if (readConfig().routing === "spring") {
+                    dolphMsg.errorGray("cannot create routes file for spring routing.");
+                }
+                else {
+                    routesGen.generateRouter(value.toString());
+                    addRoutesIndexFile(value.toString(), readConfig);
+                }
             }
             // generatess model fles for the paramter name
-            if (key && key.toLowerCase().includes("models") && value) {
+            if (key && key.toLowerCase().includes("model") && value) {
                 modelGen.generateModel(value.toString());
                 if (readConfig().database === "mysql") {
                     mysqlGen.generateConfig(value.toString());
                 }
             }
+            if (key && key.toLowerCase().includes("component") && value) {
+                generateComponent(value.toString());
+            }
             // generates files for all the above options
             if (key && key.toLowerCase().includes("all") && value) {
                 modelGen.generateModel(value.toString());
@@ -55,9 +58,14 @@ export const packageGenerator = () => {
                 }
                 serviceGen.generateService(value.toString());
                 controllerGen.generateController(value.toString());
-                routesGen.generateRouter(value.toString());
-                addRoutesIndexFile(value.toString(), readConfig);
-                addServerFile(readConfig);
+                if (readConfig().routing === "express") {
+                    routesGen.generateRouter(value.toString());
+                    addRoutesIndexFile(value.toString(), readConfig);
+                    addServerFile(readConfig);
+                }
+                else {
+                    generateComponent(value.toString());
+                }
             }
         });
         //   const controllerName = controller ? `${controller}` : undefined;

package/dist/utils/read_user_config.js

@@ -2,6 +2,7 @@ import { program } from "commander";
 import chalk from "chalk";
 import { readConfig } from "./read_user_config_path.js";
 import { writeConfig } from "./write_user_config.js";
+import { dolphMsg } from "../helpers/messages.js";
 const dbOptions = ["mongo", "postgresql", "mysql", "other"];
 export const configurePackage = () => {
     program
@@ -18,63 +19,37 @@ export const configurePackage = () => {
             if (key && key.toLocaleLowerCase().includes("language") && value) {
                 console.log(value.toString(), value);
                 if (value.toString() !== "js" && value.toString() !== "ts") {
-                    console.log(chalk.red(`Invalid project language, format must be either ${chalk.bold("js")} or ${chalk.bold("ts")}`));
+                    dolphMsg.errorRed(`invalid project language, format must be either ${chalk.bold("js")} or ${chalk.bold("ts")}`);
                     return;
                 }
                 config.language = value;
                 writeConfig(config);
-                console.log(chalk.cyan(`Default project language is now ${chalk.bold(config.language)}`));
+                dolphMsg.info(`default project language is now ${chalk.bold(config.language)}`);
                 return;
             }
             if (key && key.toLocaleLowerCase().includes("paradigm") && value) {
                 if (value.toString() !== "oop" && value.toString() !== "functional") {
-                    console.log(chalk.red(`Invalid programming paradigm, must be either ${chalk.bold("oop")} or ${chalk.bold("functional")}`));
+                    dolphMsg.errorRed(`invalid programming paradigm, must be either ${chalk.bold("oop")} or ${chalk.bold("functional")}`);
                     return;
                 }
                 config.paradigm = value;
                 writeConfig(config);
-                console.log(chalk.cyan(`Default programming paradigm is now ${chalk.bold(config.paradigm)}`));
+                dolphMsg.info(`default programming paradigm is now ${chalk.bold(config.paradigm)}`);
                 return;
             }
             if (key && key.toLocaleLowerCase().includes("database") && value) {
                 if (!dbOptions.includes(value.toString())) {
-                    console.log(chalk.red(`Invalid database value, must be either of these: ${dbOptions.join(", ")} `));
+                    dolphMsg.errorRed(`invalid database value, must be either of these: ${dbOptions.join(", ")} `);
                     return;
                 }
                 config.database = value;
                 writeConfig(config);
-                console.log(chalk.cyan(`Default project database is now ${chalk.bold(config.database)}`));
+                dolphMsg.info(`default project database is now ${chalk.bold(config.database)}`);
                 return;
             }
         });
-        // validate generateFolder
-        // if (options.generateFolder) {
-        //   if (
-        //     options.generateFolder !== "true" &&
-        //     options.generateFolder !== "false"
-        //   ) {
-        //     console.log(
-        //       chalk.red(
-        //         `Invalid folder generation value, value must be ${chalk.bold(
-        //           "true"
-        //         )} or ${chalk.bold("false")}`
-        //       )
-        //     );
-        //     return;
-        //   }
-        //   config.generateFolder = options.generateFolder;
-        //   writeConfig(config);
-        //   console.log(
-        //     chalk.cyan(
-        //       `Generation of folder files for the Services, Models, Controllers and Routes  set to ${chalk.bold(
-        //         config.generateFolder
-        //       )}`
-        //     )
-        //   );
-        //   return;
-        // }
         if (Object.keys(options).length === 0) {
-            console.log(chalk.yellow(chalk.bold(`No configurations applied, run ${chalk.white("dolph config --help")} to see available commands`)));
+            dolphMsg.errorGray(`no configurations applied, run ${chalk.green("dolph config --help")} to see available commands`);
         }
         process.exit(0);
     });

package/dist/utils/write_package_json.js

@@ -27,7 +27,6 @@ export function writePackageJsonFile(name, extension) {
   "devDependencies": {
     "@swc/cli": "^0.1.62",
     "@swc/core": "^1.3.91",
-    "@types/express": "^4.17.18",
     "@types/node": "^20.8.2",
     "ts-node": "^10.9.1",
     "tsc-alias": "^1.8.8",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dolphjs/cli",
-  "version": "1.1.6",
+  "version": "1.1.8",
   "description": "The dolphjs-cli is a tool for efficient intialization and management of a dolphjs project",
   "main": "./dist/index.js",
   "repository": "https://github.com/dolphjs/dolph-cli.git",