@dolphjs/cli 1.1.10 → 1.1.12

package/dist/generators/generate_controller.js

@@ -1,9 +1,11 @@
 import { existsSync, mkdirSync, writeFile } from "fs";
 import path from "path";
 import chalk from "chalk";
+import { promisify } from "util";
 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 writeFileAsync = promisify(writeFile);
 const createControllerDirectory = () => {
     const projectRoot = path.join(process.cwd());
     const userControllerFilePath = path.join(projectRoot, "/src/controllers");
@@ -11,36 +13,30 @@ const createControllerDirectory = () => {
         mkdirSync(userControllerFilePath);
     }
 };
-// removed other possible dirs to enforce dolphjs style guide
 const findControllerDirectory = () => {
     const rootDir = process.cwd();
-    const possibleDirs = [
-        "/src/controllers",
-        // "/src/Controllers",
-        // "/src/controller",
-        // "/src/Controller",
-        // "/Controller",
-        // "/Controllers",
-        // "/controllers",
-        // "/controller",
-    ];
+    const possibleDirs = ["/src/controllers"];
     const controllerDir = possibleDirs.find((dir) => existsSync(path.join(rootDir, dir)));
     return controllerDir ? path.join(rootDir, controllerDir) : null;
 };
 export const generateControllerFile = async (name, controllerDir, readConfig) => {
-    await writeFile(controllerDir, resolveControllerContent(readConfig, name), (error) => {
-        if (error) {
-            console.log(chalk.bold(chalk.red(error.toString())));
-        }
-    });
+    try {
+        await writeFileAsync(controllerDir, resolveControllerContent(readConfig, name));
+        console.log(`${chalk.bold(chalk.green(`${name}.controller.${readConfig().language} generated successfully! 🙃`))}`);
+    }
+    catch (error) {
+        console.log(chalk.bold(chalk.red(error.toString())));
+    }
 };
 export const generateController = async (name) => {
     if (readConfig().routing === "spring") {
         generateSpringController(name);
     }
     else {
-        if (!name)
-            chalk.bold(chalk.red("Controller extension or name is required! 🤨"));
+        if (!name) {
+            console.log(chalk.bold(chalk.red("Controller extension or name is required! 🤨")));
+            return;
+        }
         let controllerDir = findControllerDirectory();
         if (!controllerDir) {
             createControllerDirectory();
@@ -49,18 +45,13 @@ export const generateController = async (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);
             }
-            //TODO: if no index.ts file, create one too
-            generateControllerFile(name, path.join(controllerFilePath), readConfig
-            // controllerDirName,
-            );
+            generateControllerFile(name, path.join(controllerFilePath), readConfig);
         }
         catch (e) {
             console.log(chalk.bold(chalk.red(e)));
         }
-        console.log(`${chalk.bold(chalk.green(`${name}.controller.${readConfig().language} generated successfully! 🙃`))}`);
     }
 };

package/dist/generators/generate_model.js

@@ -1,9 +1,11 @@
 import { existsSync, mkdirSync, writeFile } from "fs";
 import path from "path";
 import chalk from "chalk";
+import { promisify } from "util";
 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 writeFileAsync = promisify(writeFile);
 const createModelDirectory = () => {
     const projectRoot = path.join(process.cwd());
     const userModelFilePath = path.join(projectRoot, "/src/models");
@@ -11,57 +13,43 @@ const createModelDirectory = () => {
         mkdirSync(userModelFilePath);
     }
 };
-// removed other possible dirs to enforce dolphjs style guide
 const findModelDirectory = () => {
     const rootDir = process.cwd();
-    const possibleDirs = [
-        "/src/models",
-        // "/src/Models",
-        // "/src/model",
-        // "/src/Model",
-        // "/Models",
-        // "/Model",
-        // "/models",
-        // "/model",
-    ];
+    const possibleDirs = ["/src/models"];
     const modelDir = possibleDirs.find((dir) => existsSync(path.join(rootDir, dir)));
     return modelDir ? path.join(rootDir, modelDir) : null;
 };
 export const generateModelFile = async (name, modelDir, readConfig) => {
-    await writeFile(modelDir, resolveModelContent(readConfig, name), (error) => {
-        if (error) {
-            console.log(chalk.bold(chalk.red(error.toString())));
-        }
-    });
+    try {
+        await writeFileAsync(modelDir, resolveModelContent(readConfig, name));
+        console.log(`${chalk.bold(chalk.green(`${name}.model.${readConfig().language} generated successfully! 🙃`))}`);
+    }
+    catch (error) {
+        console.log(chalk.bold(chalk.red(error.toString())));
+    }
 };
 export const generateModel = async (name) => {
     if (readConfig().routing === "spring") {
         generateSpringModel(name, readConfig().database === "mongo" ? true : false, readConfig().database === "mysql" ? true : false);
     }
     else {
-        if (!name)
-            chalk.bold(chalk.red("Model extension or name is required! 🤨"));
+        if (!name) {
+            console.log(chalk.bold(chalk.red("Model extension or name is required! 🤨")));
+            return;
+        }
         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,
-            );
+            generateModelFile(name, path.join(modelFilePath), readConfig);
         }
         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_mysql.js

@@ -1,8 +1,10 @@
 import { existsSync, mkdirSync, writeFile } from "fs";
 import path from "path";
 import chalk from "chalk";
+import { promisify } from "util";
 import { readConfig } from "../utils/read_user_config_path.js";
 import { resolveMySqlContent } from "./resolvers/resolve_model_content.js";
+const writeFileAsync = promisify(writeFile);
 const createConfigDirectory = () => {
     const projectRoot = path.join(process.cwd());
     const userConfigFilePath = path.join(projectRoot, "/src/configs");
@@ -10,54 +12,37 @@ const createConfigDirectory = () => {
         mkdirSync(userConfigFilePath);
     }
 };
-// removed other possible dirs to enforce dolphjs style guide
 const findConfigDirectory = () => {
     const rootDir = process.cwd();
-    const possibleDirs = [
-        // "/src/Configs",
-        // "/src/Config",
-        "/src/configs",
-        // "/src/config",
-        // "/Configs",
-        // "/configs",
-        // "/config",
-        // "/Config",
-    ];
+    const possibleDirs = ["/src/configs"];
     const configDir = possibleDirs.find((dir) => existsSync(path.join(rootDir, dir)));
     return configDir ? path.join(rootDir, configDir) : null;
 };
 export const generateConfigFile = async (name, configDir, readConfig) => {
-    await writeFile(configDir, resolveMySqlContent(readConfig), (error) => {
-        if (error) {
-            console.log(chalk.bold(chalk.red(error.toString())));
-        }
-    });
+    try {
+        await writeFileAsync(configDir, resolveMySqlContent(readConfig));
+        console.log(`${chalk.bold(chalk.green(`db.config.${readConfig().language} generated successfully! 🙃`))}`);
+    }
+    catch (error) {
+        console.log(chalk.bold(chalk.red(error.toString())));
+    }
 };
 export const generateConfig = async (name) => {
-    if (!name)
-        chalk.bold(chalk.red("Config extension or name is required! 🤨"));
+    if (!name) {
+        console.log(chalk.bold(chalk.red("Config extension or name is required! 🤨")));
+        return;
+    }
     let configDir = findConfigDirectory();
     if (!configDir) {
-        //TODO: create one if it doesn't exist
-        // console.log(chalk.bold(chalk.red("Config directory doesn't exist 🤨")));
-        // return;
         createConfigDirectory();
         configDir = findConfigDirectory();
     }
     const configDirName = configDir;
     const configFilePath = path.join(configDirName + `/db.configs.${readConfig().language}`);
     try {
-        // Create the generate controller path
-        // if (readConfig().generateFolder === "true" || true) {
-        //   mkdirSync(configDirName);
-        // }
-        //TODO: if no index.ts file, create one too
-        generateConfigFile(name, path.join(configFilePath), readConfig
-        // configDirName,
-        );
+        generateConfigFile(name, path.join(configFilePath), readConfig);
     }
     catch (e) {
         console.log(chalk.bold(chalk.red(e)));
     }
-    console.log(`${chalk.bold(chalk.green(`db.config.${readConfig().language} generated successfully! 🙃`))}`);
 };

package/dist/generators/generate_routes.js

@@ -1,8 +1,10 @@
 import { existsSync, mkdirSync, writeFile } from "fs";
 import path from "path";
 import chalk from "chalk";
+import { promisify } from "util";
 import { readConfig } from "../utils/read_user_config_path.js";
 import { resolveRoutesContent } from "./resolvers/resolve_routes_content.js";
+const writeFileAsync = promisify(writeFile);
 const createRoutesDirectory = () => {
     const projectRoot = path.join(process.cwd());
     const userRoutesFilePath = path.join(projectRoot, "/src/routes");
@@ -10,50 +12,40 @@ const createRoutesDirectory = () => {
         mkdirSync(userRoutesFilePath);
     }
 };
-// removed other possible dirs to enforce dolphjs style guide
 const findRoutesDirectory = () => {
     const rootDir = process.cwd();
-    const possibleDirs = [
-        "/src/routes",
-        // "/src/Routes",
-        // "/Routes",
-        // "/routes"
-    ];
+    const possibleDirs = ["/src/routes"];
     const routesDir = possibleDirs.find((dir) => existsSync(path.join(rootDir, dir)));
     return routesDir ? path.join(rootDir, routesDir) : null;
 };
 export const generateRoutesFile = async (name, routesDir, readConfig) => {
-    await writeFile(routesDir, resolveRoutesContent(readConfig, name), (error) => {
-        if (error) {
-            console.log(chalk.bold(chalk.red(error.toString())));
-        }
-    });
+    try {
+        await writeFileAsync(routesDir, resolveRoutesContent(readConfig, name));
+        console.log(`${chalk.bold(chalk.green(`${name}.routes.${readConfig().language} generated successfully! 🙃`))}`);
+    }
+    catch (error) {
+        console.log(chalk.bold(chalk.red(error.toString())));
+    }
 };
 export const generateRouter = async (name) => {
-    if (!name)
-        chalk.bold(chalk.red("Routes extension or name is required! 🤨"));
+    if (!name) {
+        console.log(chalk.bold(chalk.red("Routes extension or name is required! 🤨")));
+        return;
+    }
     let routesDir = findRoutesDirectory();
     if (!routesDir) {
-        //TODO: create one if it doesn't exist
-        // console.log(chalk.bold(chalk.red("routes directory doesn't exist 🤨")));
-        // return;
         createRoutesDirectory();
         routesDir = findRoutesDirectory();
     }
     const routesDirName = path.join(routesDir, name);
     const routesFilePath = path.join(routesDirName + `/${name}.routes.${readConfig().language}`);
     try {
-        // Create the generate controller path
         if (readConfig().generateFolder === "true" || true) {
             mkdirSync(routesDirName);
         }
-        //TODO: if no index.ts file, create one too
-        generateRoutesFile(name, path.join(routesFilePath), readConfig
-        // routesDirName,
-        );
+        generateRoutesFile(name, path.join(routesFilePath), readConfig);
     }
     catch (e) {
         console.log(chalk.bold(chalk.red(e)));
     }
-    console.log(`${chalk.bold(chalk.green(`${name}.routes.${readConfig().language} generated successfully! 🙃`))}`);
 };

package/dist/generators/generate_service.js

@@ -1,9 +1,11 @@
 import { existsSync, mkdirSync, writeFile } from "fs";
 import path from "path";
 import chalk from "chalk";
+import { promisify } from "util";
 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 writeFileAsync = promisify(writeFile);
 const createServiceDirectory = () => {
     const projectRoot = path.join(process.cwd());
     const userServiceFilePath = path.join(projectRoot, "/src/services");
@@ -11,59 +13,45 @@ const createServiceDirectory = () => {
         mkdirSync(userServiceFilePath);
     }
 };
-// removed other possible dirs to enforce dolphjs style guide
 const findServiceDirectory = () => {
     const rootDir = process.cwd();
-    const possibleDirs = [
-        "/src/services",
-        // "/src/Services",
-        // "/src/service",
-        // "/src/Services",
-        // "/Service",
-        // "/Services",
-        // "/services",
-        // "/service",
-    ];
+    const possibleDirs = ["/src/services"];
     const serviceDir = possibleDirs.find((dir) => existsSync(path.join(rootDir, dir)));
     return serviceDir ? path.join(rootDir, serviceDir) : null;
 };
 export const generateServiceFile = async (name, serviceDir, readConfig) => {
-    await writeFile(serviceDir, resolveServiceContent(readConfig, name), (error) => {
-        if (error) {
-            console.log(chalk.bold(chalk.red(error.toString())));
-        }
-    });
+    try {
+        await writeFileAsync(serviceDir, resolveServiceContent(readConfig, name));
+        console.log(`${chalk.bold(chalk.green(`${name}.service.${readConfig().language} generated successfully! 🙃`))}`);
+    }
+    catch (error) {
+        console.log(chalk.bold(chalk.red(error.toString())));
+    }
 };
 export const generateService = async (name) => {
     if (readConfig().routing === "spring") {
         generateSpringService(name, readConfig().database === "mongo" ? true : false, readConfig().database === "mysql" ? true : false);
     }
-    {
-        if (!name)
-            chalk.bold(chalk.red("Service extension or name is required! 🤨"));
+    else {
+        if (!name) {
+            console.log(chalk.bold(chalk.red("Service extension or name is required! 🤨")));
+            return;
+        }
         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,
-            );
+            generateServiceFile(name, path.join(serviceFilePath), readConfig);
         }
         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_component.js

@@ -3,6 +3,8 @@ import path from "path";
 import chalk from "chalk";
 import { generateSpringComponent } from "../../generators/templates/spring_component_template.js";
 import { dolphMsg } from "../../helpers/messages.js";
+import { promisify } from "util";
+const writeFileAsync = promisify(writeFile);
 const createComponentDirectory = (componentName) => {
     const projectRoot = path.join(process.cwd());
     const userComponentPath = path.join(projectRoot, `/src/${componentName}`);
@@ -17,15 +19,18 @@ const findComponentDirectory = (componentName) => {
     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());
-        }
-    });
+    try {
+        await writeFileAsync(componentDir, generateSpringComponent(componentName));
+    }
+    catch (error) {
+        dolphMsg.errorRed(error.toString());
+    }
 };
 export const generateComponent = async (name) => {
-    if (!name)
-        dolphMsg.errorRed("component extension or name is required! 🤨");
+    if (!name) {
+        dolphMsg.errorRed("Component extension or name is required! 🤨");
+        return;
+    }
     let componentDir = findComponentDirectory(name);
     if (!componentDir) {
         createComponentDirectory(name);
@@ -33,10 +38,10 @@ export const generateComponent = async (name) => {
     }
     const componentFilePath = path.join(componentDir + `/${name}.component.ts`);
     try {
-        generateSpringComponentFile(name, path.join(componentFilePath));
+        await generateSpringComponentFile(name, path.join(componentFilePath));
+        dolphMsg.info(`${chalk.blue(`${name}.component.ts`)} generated successfully for ${chalk.blue(`${name}`)} component.`);
     }
     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

@@ -3,6 +3,8 @@ import path from "path";
 import chalk from "chalk";
 import { generateSpringController } from "../../generators/templates/spring_controller_template.js";
 import { dolphMsg } from "../../helpers/messages.js";
+import { promisify } from "util";
+const writeFileAsync = promisify(writeFile);
 const createControllerDirectory = (componentName) => {
     const projectRoot = path.join(process.cwd());
     const userCompontrollerPath = path.join(projectRoot, `/src/${componentName}`);
@@ -17,15 +19,18 @@ const findControllerDirectory = (componentName) => {
     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());
-        }
-    });
+    try {
+        await writeFileAsync(controllerDir, generateSpringController(componentName));
+    }
+    catch (error) {
+        dolphMsg.errorRed(error.toString());
+    }
 };
 export const generateController = async (name) => {
-    if (!name)
-        dolphMsg.errorRed("controller extension or name is required! 🤨");
+    if (!name) {
+        dolphMsg.errorRed("Controller extension or name is required! 🤨");
+        return;
+    }
     let controllerDir = findControllerDirectory(name);
     if (!controllerDir) {
         createControllerDirectory(name);
@@ -33,10 +38,10 @@ export const generateController = async (name) => {
     }
     const controllerFilePath = path.join(controllerDir + `/${name}.controller.ts`);
     try {
-        generateSpringControllerFile(name, path.join(controllerFilePath));
+        await generateSpringControllerFile(name, path.join(controllerFilePath));
+        dolphMsg.info(`${chalk.blue(`${name}.controller.ts`)} generated successfully for ${chalk.blue(`${name}`)} component.`);
     }
     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

@@ -3,6 +3,8 @@ import path from "path";
 import chalk from "chalk";
 import { generateSpringModel } from "../../generators/templates/spring_model_template.js";
 import { dolphMsg } from "../../helpers/messages.js";
+import { promisify } from "util";
+const writeFileAsync = promisify(writeFile);
 const createModelDirectory = (componentName) => {
     const projectRoot = path.join(process.cwd());
     const userModelPath = path.join(projectRoot, `/src/${componentName}`);
@@ -17,15 +19,18 @@ const findModelDirectory = (componentName) => {
     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());
-        }
-    });
+    try {
+        await writeFileAsync(modelDir, generateSpringModel(componentName, isMongo, isMySql));
+    }
+    catch (error) {
+        dolphMsg.errorRed(error.toString());
+    }
 };
 export const generateModel = async (name, isMongo, isMySql) => {
-    if (!name)
-        dolphMsg.errorRed("model extension or name is required! 🤨");
+    if (!name) {
+        dolphMsg.errorRed("Model extension or name is required! 🤨");
+        return;
+    }
     let modelDir = findModelDirectory(name);
     if (!modelDir) {
         createModelDirectory(name);
@@ -33,10 +38,10 @@ export const generateModel = async (name, isMongo, isMySql) => {
     }
     const modelFilePath = path.join(modelDir + `/${name}.model.ts`);
     try {
-        generateSpringModelFile(name, path.join(modelFilePath), isMongo, isMySql);
+        await generateSpringModelFile(name, path.join(modelFilePath), isMongo, isMySql);
+        dolphMsg.info(`${chalk.blue(`${name}.model.ts`)} generated successfully for ${chalk.blue(`${name}`)} component.`);
     }
     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

@@ -3,6 +3,8 @@ import path from "path";
 import chalk from "chalk";
 import { generateSpringService } from "../../generators/templates/spring_service_template.js";
 import { dolphMsg } from "../../helpers/messages.js";
+import { promisify } from "util";
+const writeFileAsync = promisify(writeFile);
 const createServiceDirectory = (componentName) => {
     const projectRoot = path.join(process.cwd());
     const userServicePath = path.join(projectRoot, `/src/${componentName}`);
@@ -17,15 +19,18 @@ const findServiceDirectory = (componentName) => {
     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());
-        }
-    });
+    try {
+        await writeFileAsync(serviceDir, generateSpringService(componentName, isMongo, isMySql));
+    }
+    catch (error) {
+        dolphMsg.errorRed(error.toString());
+    }
 };
 export const generateService = async (name, isMongo, isMySql) => {
-    if (!name)
-        dolphMsg.errorRed("service extension or name is required! 🤨");
+    if (!name) {
+        dolphMsg.errorRed("Service extension or name is required! 🤨");
+        return;
+    }
     let serviceDir = findServiceDirectory(name);
     if (!serviceDir) {
         createServiceDirectory(name);
@@ -33,10 +38,10 @@ export const generateService = async (name, isMongo, isMySql) => {
     }
     const serviceFilePath = path.join(serviceDir + `/${name}.service.ts`);
     try {
-        generateSpringServiceFile(name, path.join(serviceFilePath), isMongo, isMySql);
+        await generateSpringServiceFile(name, path.join(serviceFilePath), isMongo, isMySql);
+        dolphMsg.info(`${chalk.blue(`${name}.service.ts`)} generated successfully for ${chalk.blue(`${name}`)} component.`);
     }
     catch (e) {
         dolphMsg.errorRed(e);
     }
-    dolphMsg.info(`${chalk.blue(`${name}.service.ts`)} generated successfully for ${chalk.blue(`${name}`)} component.`);
 };

package/dist/generators/templates/spring_service_template.js

@@ -39,7 +39,7 @@ import { ${capitalizeFirstLetter(componentName)}Model, I${capitalizeFirstLetter(
 
 @InjectMongo("${componentName}Model", ${capitalizeFirstLetter(componentName)}Model)
 export class ${className} extends DolphServiceHandler<Dolph> {
-  ${componentName}Model!: Model<>;
+  ${componentName}Model!: Model<I${capitalizeFirstLetter(componentName)}>;
 
   constructor() {
     super("${className.toLowerCase()}");

package/dist/registers/register_component.js

@@ -46,9 +46,7 @@ dolph.start();
                 // 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()
-                        : "";
+                    const existingCode = routesArrayMatch[1].trim();
                     let fileContents;
                     fileContents = fileContent.replace(existingCode, `${existingCode.length > 0 ? existingCode + ", " : ""}${newComponentInstance}`);
                     const updatedContents = `${importStatement}\n${fileContents}`;

package/dist/utils/package_generator.js

@@ -70,14 +70,5 @@ export const packageGenerator = () => {
                 }
             }
         });
-        //   const controllerName = controller ? `${controller}` : undefined;
-        //   const serviceName = service ? `${service}` : undefined;
-        //   const modelName = model ? `${model}` : undefined;
-        //   const routesName = routes ? `${routes}` : undefined;
-        //   const interfacesName = interfaces ? `${interfaces}` : undefined;
-        //   const helperName = helper ? `${helper}` : undefined;
-        //   if (controllerName) {
-        //     controllerGen.generateController(controllerName);
-        //   }
     });
 };

package/package.json

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