@dolphjs/cli 1.1.8 → 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

@@ -38,27 +38,29 @@ 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) {
-        createControllerDirectory();
-        controllerDir = findControllerDirectory();
-    }
-    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_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_controller_template.js

@@ -9,7 +9,7 @@ import {
   SuccessResponse,
   DRequest,
   DResponse
-} from "@dolphjs/dolph/common
+} from "@dolphjs/dolph/common";
 import { Get, Route } from "@dolphjs/dolph/decorators";
 
 @Route('${componentName}')

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/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/utils/package_generator.js

@@ -10,6 +10,9 @@ 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")
@@ -28,7 +31,12 @@ 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("route") && value) {
@@ -42,9 +50,14 @@ export const packageGenerator = () => {
             }
             // generatess model fles for the paramter name
             if (key && key.toLowerCase().includes("model") && value) {
-                modelGen.generateModel(value.toString());
-                if (readConfig().database === "mysql") {
-                    mysqlGen.generateConfig(value.toString());
+                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) {
@@ -52,12 +65,22 @@ export const packageGenerator = () => {
             }
             // 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());
+                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);
@@ -65,6 +88,7 @@ export const packageGenerator = () => {
                 }
                 else {
                     generateComponent(value.toString());
+                    addComponentToServerFile(value.toString());
                 }
             }
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dolphjs/cli",
-  "version": "1.1.8",
+  "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",