@dolphjs/cli 1.1.7 → 1.1.9

package/README.md

@@ -27,7 +27,7 @@ to install all packages .
 - models
 - routes
 
-It is recommended to make use of the `generate` command when one was to create these files because it generates code the dolphjs way. In a scenario when you want to create files for all of the above, let's say you want to write code for user logic and functionalities, use the `-a` flag, as in:
+It is recommended to make use of the `generate` command when one wants to create these files because it generates code the dolphjs way. In a scenario when you want to create files for all of the above, let's say you want to write code for user logic and functionalities, use the `-a` flag, as in:
 
 ```bash
 dolph-cli g -a user
@@ -61,4 +61,4 @@ the command above creates a service, controller, model and routes file for `user
 
 ## Credit
 
-dolphjs-cli is inspired by methane-cli [https://github.com/adedoyin/methane-cli]
+dolphjs-cli is inspired by methane-cli [https://github.com/adedoyin-Emmanuel/methane-cli]

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,32 +35,32 @@ export const generateControllerFile = async (name, controllerDir, readConfig) =>
     });
 };
 export const generateController = async (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();
+    if (readConfig().routing === "spring") {
+        generateSpringController(name);
     }
-    const controllerDirName = path.join(controllerDir, name);
-    const controllerFilePath = path.join(controllerDirName + `/${name}.controller.${readConfig().language}`);
-    try {
-        // Create the generate controller path
-        if (readConfig().generateFolder === "true" || true) {
-            mkdirSync(controllerDirName);
+    else {
+        if (!name)
+            chalk.bold(chalk.red("Controller extension or name is required! 🤨"));
+        let controllerDir = findControllerDirectory();
+        if (!controllerDir) {
+            createControllerDirectory();
+            controllerDir = findControllerDirectory();
         }
-        //TODO: if no index.ts file, create one too
-        generateControllerFile(name, path.join(controllerFilePath), readConfig
-        // controllerDirName,
-        );
-    }
-    catch (e) {
-        console.log(chalk.bold(chalk.red(e)));
+        const controllerDirName = path.join(controllerDir, name);
+        const controllerFilePath = path.join(controllerDirName + `/${name}.controller.${readConfig().language}`);
+        try {
+            // Create the generate controller path
+            if (readConfig().generateFolder === "true" || true) {
+                mkdirSync(controllerDirName);
+            }
+            //TODO: if no index.ts file, create one too
+            generateControllerFile(name, path.join(controllerFilePath), readConfig
+            // controllerDirName,
+            );
+        }
+        catch (e) {
+            console.log(chalk.bold(chalk.red(e)));
+        }
+        console.log(`${chalk.bold(chalk.green(`${name}.controller.${readConfig().language} generated successfully! 🙃`))}`);
     }
-    console.log(`${chalk.bold(chalk.green(`${name}.controller.${readConfig().language} generated successfully! 🙃`))}`);
 };

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/spring/generate_spring_model.js

@@ -0,0 +1,42 @@
+import { existsSync, mkdirSync, writeFile } from "fs";
+import path from "path";
+import chalk from "chalk";
+import { generateSpringModel } from "../../generators/templates/spring_model_template.js";
+import { dolphMsg } from "../../helpers/messages.js";
+const createModelDirectory = (componentName) => {
+    const projectRoot = path.join(process.cwd());
+    const userModelPath = path.join(projectRoot, `/src/${componentName}`);
+    if (!existsSync(userModelPath)) {
+        mkdirSync(userModelPath);
+    }
+};
+const findModelDirectory = (componentName) => {
+    const rootDir = process.cwd();
+    const possibleDirs = [`src/${componentName}`];
+    const modelDir = possibleDirs.find((dir) => existsSync(path.join(rootDir, dir)));
+    return modelDir ? path.join(rootDir, modelDir) : null;
+};
+export const generateSpringModelFile = async (componentName, modelDir, isMongo, isMySql) => {
+    await writeFile(modelDir, generateSpringModel(componentName, isMongo, isMySql), (error) => {
+        if (error) {
+            dolphMsg.errorRed(error.toString());
+        }
+    });
+};
+export const generateModel = async (name, isMongo, isMySql) => {
+    if (!name)
+        dolphMsg.errorRed("model extension or name is required! 🤨");
+    let modelDir = findModelDirectory(name);
+    if (!modelDir) {
+        createModelDirectory(name);
+        modelDir = findModelDirectory(name);
+    }
+    const modelFilePath = path.join(modelDir + `/${name}.model.ts`);
+    try {
+        generateSpringModelFile(name, path.join(modelFilePath), isMongo, isMySql);
+    }
+    catch (e) {
+        dolphMsg.errorRed(e);
+    }
+    dolphMsg.info(`${chalk.blue(`${name}.model.ts`)} generated successfully for ${chalk.blue(`${name}`)} component.`);
+};

package/dist/generators/spring/generate_spring_service.js

@@ -0,0 +1,42 @@
+import { existsSync, mkdirSync, writeFile } from "fs";
+import path from "path";
+import chalk from "chalk";
+import { generateSpringService } from "../../generators/templates/spring_service_template.js";
+import { dolphMsg } from "../../helpers/messages.js";
+const createServiceDirectory = (componentName) => {
+    const projectRoot = path.join(process.cwd());
+    const userServicePath = path.join(projectRoot, `/src/${componentName}`);
+    if (!existsSync(userServicePath)) {
+        mkdirSync(userServicePath);
+    }
+};
+const findServiceDirectory = (componentName) => {
+    const rootDir = process.cwd();
+    const possibleDirs = [`src/${componentName}`];
+    const serviceDir = possibleDirs.find((dir) => existsSync(path.join(rootDir, dir)));
+    return serviceDir ? path.join(rootDir, serviceDir) : null;
+};
+export const generateSpringServiceFile = async (componentName, serviceDir, isMongo, isMySql) => {
+    await writeFile(serviceDir, generateSpringService(componentName, isMongo, isMySql), (error) => {
+        if (error) {
+            dolphMsg.errorRed(error.toString());
+        }
+    });
+};
+export const generateService = async (name, isMongo, isMySql) => {
+    if (!name)
+        dolphMsg.errorRed("service extension or name is required! 🤨");
+    let serviceDir = findServiceDirectory(name);
+    if (!serviceDir) {
+        createServiceDirectory(name);
+        serviceDir = findServiceDirectory(name);
+    }
+    const serviceFilePath = path.join(serviceDir + `/${name}.service.ts`);
+    try {
+        generateSpringServiceFile(name, path.join(serviceFilePath), isMongo, isMySql);
+    }
+    catch (e) {
+        dolphMsg.errorRed(e);
+    }
+    dolphMsg.info(`${chalk.blue(`${name}.service.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/generators/templates/spring_model_template.js

@@ -0,0 +1,40 @@
+export const generateSpringModel = (componentName, isMongo, isMysql) => {
+    let template;
+    const capitalizeFirstLetter = (str) => {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    };
+    if (isMongo) {
+        template = `import { Schema, Document, model } from "mongoose";
+
+export interface I${capitalizeFirstLetter(componentName)} extends Document {
+  
+}
+
+const ${capitalizeFirstLetter(componentName)}Schema = new Schema(
+    {
+
+    }
+);
+
+export const ${capitalizeFirstLetter(componentName)}Model = model<I${capitalizeFirstLetter(componentName)}>("${componentName.charAt(0) !== "s" ? `${componentName}s` : componentName}", ${capitalizeFirstLetter(componentName)}Schema);
+`;
+    }
+    if (isMysql) {
+        template = `import { sequelizeInstance } from "@/shared/configs/db.configs";
+import { DataTypes } from "sequelize";
+
+export const ${capitalizeFirstLetter(componentName)} = sequelizeInstance.define("${componentName}", {
+  id: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+    primaryKey: true,
+    autoIncrement: true,
+  },
+});
+`;
+    }
+    if (!isMongo && !isMysql) {
+        template = ``;
+    }
+    return template;
+};

package/dist/generators/templates/spring_service_template.js

@@ -0,0 +1,86 @@
+export const generateSpringService = (componentName, isMongo, isMySql) => {
+    let template;
+    const capitalizeFirstLetter = (str) => {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    };
+    const className = capitalizeFirstLetter(componentName) + "Service";
+    if (isMongo && isMySql) {
+        template = `
+import { DolphServiceHandler } from "@dolphjs/dolph/classes";
+import { Dolph } from "@dolphjs/dolph/common";
+import { InjectMongo, InjectMySQL } from "@dolphjs/dolph/decorators";
+import { Model } from "mongoose";
+import { ModelStatic, Model as SqlModel } from "sequelize";
+import { ${capitalizeFirstLetter(componentName)}Model, I${capitalizeFirstLetter(componentName)} } from "./${componentName}.model";
+
+
+@InjectMongo("${componentName}Model", ${capitalizeFirstLetter(componentName)}Model)
+@InjectMySQL("${componentName}SqlModel", )
+export class ${className} extends DolphServiceHandler<Dolph> {
+  ${componentName}Model!: Model<${capitalizeFirstLetter(componentName)}>;
+  ${componentName}SqlModel!: ModelStatic<SqlModel<any, any>>;
+
+
+  constructor() {
+    super("${className.toLowerCase()}");
+  }
+}
+    
+`;
+    }
+    if (isMongo) {
+        template = `
+import { DolphServiceHandler } from "@dolphjs/dolph/classes";
+import { Dolph } from "@dolphjs/dolph/common";
+import { InjectMongo} from "@dolphjs/dolph/decorators";
+import { Model } from "mongoose";
+import { ${capitalizeFirstLetter(componentName)}Model, I${capitalizeFirstLetter(componentName)} } from "./${componentName}.model";
+
+
+@InjectMongo("${componentName}Model", ${capitalizeFirstLetter(componentName)}Model)
+export class ${className} extends DolphServiceHandler<Dolph> {
+  ${componentName}Model!: Model<>;
+
+  constructor() {
+    super("${className.toLowerCase()}");
+  }
+}
+    
+`;
+    }
+    if (isMySql) {
+        template = `
+import { DolphServiceHandler } from "@dolphjs/dolph/classes";
+import { Dolph } from "@dolphjs/dolph/common";
+import { InjectMySQL } from "@dolphjs/dolph/decorators";
+import { ModelStatic, Model } from "sequelize";
+
+
+@InjectMySQL("${componentName}Model", )
+export class ${className} extends DolphServiceHandler<Dolph> {
+  ${componentName}Model!: ModelStatic<Model<any, any>>;
+
+
+  constructor() {
+    super("${className.toLowerCase()}");
+  }
+}
+    
+`;
+    }
+    if (!isMongo && !isMySql) {
+        template = `
+import { DolphServiceHandler } from "@dolphjs/dolph/classes";
+import { Dolph } from "@dolphjs/dolph/common";
+
+
+export class ${className} extends DolphServiceHandler<Dolph> {
+
+  constructor() {
+    super("${className.toLowerCase()}");
+  }
+}    
+`;
+    }
+    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_component.js

@@ -0,0 +1,64 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dolphMsg } from "../helpers/messages.js";
+import path from "path";
+const createSrcDirectory = () => {
+    const projectRoot = path.join(process.cwd());
+    const userComponentPath = path.join(projectRoot, `/src`);
+    if (!existsSync(userComponentPath)) {
+        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;
+};
+export const addComponentToServerFile = (componentName) => {
+    if (!componentName) {
+        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.");
+        return;
+    }
+    const serverPath = path.join(serverDir, "server.ts");
+    const capitalizedString = componentName.charAt(0).toUpperCase() + componentName.slice(1);
+    const importStatement = `import { ${capitalizedString}Component } from "./${componentName}/${componentName}.component.ts";`;
+    try {
+        if (!existsSync(serverPath)) {
+            const fileContent = `import { DolphFactory } from "@dolphjs/dolph";
+${importStatement}
+const dolph = new DolphFactory([${capitalizedString}Component]);
+dolph.start();
+`;
+            writeFileSync(serverPath, fileContent);
+        }
+        else {
+            const fileContent = readFileSync(serverPath, "utf8");
+            const newComponentInstance = `${capitalizedString}Component`;
+            if (!fileContent.includes(importStatement)) {
+                const updatedContent = `
+        ${importStatement}\n${fileContent}}`;
+                writeFileSync(serverPath, updatedContent);
+            }
+            if (fileContent.includes(`const dolph`)) {
+                // add new controller class to the existing array
+                const routesArrayMatch = fileContent.match(/const dolph = new DolphFactory\[([\s\S]]+?)\];/);
+                if (routesArrayMatch) {
+                    const existingCode = routesArrayMatch[1].trim();
+                    let fileContents;
+                    fileContents = fileContent.replace(existingCode, `${existingCode.length > 0 ? existingCode + ", " : ""}${newComponentInstance}`);
+                    const updatedContents = `${importStatement}\n${fileContents}`;
+                    writeFileSync(serverPath, updatedContents);
+                }
+            }
+        }
+        dolphMsg.info(`added ${capitalizedString}Component to components array in server.ts file.`);
+        process.exit(0);
+    }
+    catch (e) {
+        dolphMsg.errorRed(e.toString());
+    }
+};

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,21 @@ 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";
+import { generateService } from "../generators/spring/generate_spring_service.js";
+import { generateModel } from "../generators/spring/generate_spring_model.js";
+import { addComponentToServerFile } from "../registers/register_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
@@ -33,31 +31,65 @@ export const packageGenerator = () => {
             }
             // generates service files for the paramter name
             if (key && key.toLowerCase().includes("service") && value) {
-                serviceGen.generateService(value.toString());
+                if (readConfig().routing === "express") {
+                    serviceGen.generateService(value.toString());
+                }
+                else {
+                    generateService(value.toString(), readConfig().database === "mongo" ? true : false, readConfig().database === "mysql" ? true : false);
+                }
             }
             // 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) {
-                modelGen.generateModel(value.toString());
-                if (readConfig().database === "mysql") {
-                    mysqlGen.generateConfig(value.toString());
+            if (key && key.toLowerCase().includes("model") && value) {
+                if (readConfig().routing === "express") {
+                    modelGen.generateModel(value.toString());
+                    if (readConfig().database === "mysql") {
+                        mysqlGen.generateConfig(value.toString());
+                    }
                 }
+                else {
+                    generateModel(value.toString(), readConfig().database === "mongo" ? true : false, readConfig().database === "mysql" ? true : false);
+                }
+            }
+            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());
+                if (readConfig().routing === "express") {
+                    modelGen.generateModel(value.toString());
+                }
+                else {
+                    generateModel(value.toString(), readConfig().database === "mongo" ? true : false, readConfig().database === "mysql" ? true : false);
+                }
                 if (readConfig().database === "mysql") {
                     mysqlGen.generateConfig(value.toString());
                 }
-                serviceGen.generateService(value.toString());
-                controllerGen.generateController(value.toString());
-                routesGen.generateRouter(value.toString());
-                addRoutesIndexFile(value.toString(), readConfig);
-                addServerFile(readConfig);
+                if (readConfig().routing === "express") {
+                    serviceGen.generateService(value.toString());
+                    controllerGen.generateController(value.toString());
+                }
+                else {
+                    generateService(value.toString(), readConfig().database === "mongo" ? true : false, readConfig().database === "mysql" ? true : false);
+                }
+                if (readConfig().routing === "express") {
+                    routesGen.generateRouter(value.toString());
+                    addRoutesIndexFile(value.toString(), readConfig);
+                    addServerFile(readConfig);
+                }
+                else {
+                    generateComponent(value.toString());
+                    addComponentToServerFile(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.7",
+  "version": "1.1.9",
   "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",