@dolphjs/cli 1.1.8 → 1.1.10

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/generate_model.js

@@ -3,6 +3,7 @@ import path from "path";
 import chalk from "chalk";
 import { readConfig } from "../utils/read_user_config_path.js";
 import { resolveModelContent } from "./resolvers/resolve_model_content.js";
+import { generateModel as generateSpringModel } from "./spring/generate_spring_model.js";
 const createModelDirectory = () => {
     const projectRoot = path.join(process.cwd());
     const userModelFilePath = path.join(projectRoot, "/src/models");
@@ -34,28 +35,33 @@ export const generateModelFile = async (name, modelDir, readConfig) => {
     });
 };
 export const generateModel = async (name) => {
-    if (!name)
-        chalk.bold(chalk.red("Model extension or name is required! 🤨"));
-    let modelDir = findModelDirectory();
-    if (!modelDir) {
-        //TODO: create one if it doesn't exist
-        // console.log(chalk.bold(chalk.red("Model directory doesn't exist 🤨")));
-        // return;
-        createModelDirectory();
-        modelDir = findModelDirectory();
+    if (readConfig().routing === "spring") {
+        generateSpringModel(name, readConfig().database === "mongo" ? true : false, readConfig().database === "mysql" ? true : false);
     }
-    const modelDirName = path.join(modelDir, name);
-    const modelFilePath = path.join(modelDirName + `/${name}.model.${readConfig().language}`);
-    try {
-        // Create the generate controller path
-        mkdirSync(modelDirName);
-        //TODO: if no index.ts file, create one too
-        generateModelFile(name, path.join(modelFilePath), readConfig
-        // modelDirName,
-        );
-    }
-    catch (e) {
-        console.log(chalk.bold(chalk.red(e)));
+    else {
+        if (!name)
+            chalk.bold(chalk.red("Model extension or name is required! 🤨"));
+        let modelDir = findModelDirectory();
+        if (!modelDir) {
+            //TODO: create one if it doesn't exist
+            // console.log(chalk.bold(chalk.red("Model directory doesn't exist 🤨")));
+            // return;
+            createModelDirectory();
+            modelDir = findModelDirectory();
+        }
+        const modelDirName = path.join(modelDir, name);
+        const modelFilePath = path.join(modelDirName + `/${name}.model.${readConfig().language}`);
+        try {
+            // Create the generate controller path
+            mkdirSync(modelDirName);
+            //TODO: if no index.ts file, create one too
+            generateModelFile(name, path.join(modelFilePath), readConfig
+            // modelDirName,
+            );
+        }
+        catch (e) {
+            console.log(chalk.bold(chalk.red(e)));
+        }
     }
     console.log(`${chalk.bold(chalk.green(`${name}.model.${readConfig().language} generated successfully! 🙃`))}`);
 };

package/dist/generators/generate_service.js

@@ -3,6 +3,7 @@ import path from "path";
 import chalk from "chalk";
 import { readConfig } from "../utils/read_user_config_path.js";
 import { resolveServiceContent } from "./resolvers/resolve_service_content.js";
+import { generateService as generateSpringService } from "./spring/generate_spring_service.js";
 const createServiceDirectory = () => {
     const projectRoot = path.join(process.cwd());
     const userServiceFilePath = path.join(projectRoot, "/src/services");
@@ -34,30 +35,35 @@ export const generateServiceFile = async (name, serviceDir, readConfig) => {
     });
 };
 export const generateService = async (name) => {
-    if (!name)
-        chalk.bold(chalk.red("Service extension or name is required! 🤨"));
-    let serviceDir = findServiceDirectory();
-    if (!serviceDir) {
-        //TODO: create one if it doesn't exist
-        // console.log(chalk.bold(chalk.red("Service directory doesn't exist 🤨")));
-        // return;
-        createServiceDirectory();
-        serviceDir = findServiceDirectory();
+    if (readConfig().routing === "spring") {
+        generateSpringService(name, readConfig().database === "mongo" ? true : false, readConfig().database === "mysql" ? true : false);
     }
-    const serviceDirName = path.join(serviceDir, name);
-    const serviceFilePath = path.join(serviceDirName + `/${name}.service.${readConfig().language}`);
-    try {
-        // Create the generate controller path
-        if (readConfig().generateFolder === "true" || true) {
-            mkdirSync(serviceDirName);
+    {
+        if (!name)
+            chalk.bold(chalk.red("Service extension or name is required! 🤨"));
+        let serviceDir = findServiceDirectory();
+        if (!serviceDir) {
+            //TODO: create one if it doesn't exist
+            // console.log(chalk.bold(chalk.red("Service directory doesn't exist 🤨")));
+            // return;
+            createServiceDirectory();
+            serviceDir = findServiceDirectory();
+        }
+        const serviceDirName = path.join(serviceDir, name);
+        const serviceFilePath = path.join(serviceDirName + `/${name}.service.${readConfig().language}`);
+        try {
+            // Create the generate controller path
+            if (readConfig().generateFolder === "true" || true) {
+                mkdirSync(serviceDirName);
+            }
+            //TODO: if no index.ts file, create one too
+            generateServiceFile(name, path.join(serviceFilePath), readConfig
+            // serviceDirName,
+            );
+        }
+        catch (e) {
+            console.log(chalk.bold(chalk.red(e)));
         }
-        //TODO: if no index.ts file, create one too
-        generateServiceFile(name, path.join(serviceFilePath), readConfig
-        // serviceDirName,
-        );
-    }
-    catch (e) {
-        console.log(chalk.bold(chalk.red(e)));
     }
     console.log(`${chalk.bold(chalk.green(`${name}.service.${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,65 @@
+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";`;
+    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\(([^)]+)\);/);
+                if (routesArrayMatch) {
+                    const existingCode = routesArrayMatch && routesArrayMatch[1]
+                        ? 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,7 @@ 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 { addComponentToServerFile } from "../registers/register_component.js";
 export const packageGenerator = () => {
     program
         .command("generate")
@@ -65,6 +66,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.10",
   "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",