@dolphjs/cli 1.1.11 → 1.1.13

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);
+        await 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,
-            );
+            await 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);
+        await 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,
-            );
+            await 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,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 { resolveMySqlContent } from "./resolvers/resolve_model_content.js";
+import { generateConfig as generateSpringConfig } from "./spring/generate_spring_mysql.js";
+const writeFileAsync = promisify(writeFile);
 const createConfigDirectory = () => {
     const projectRoot = path.join(process.cwd());
     const userConfigFilePath = path.join(projectRoot, "/src/configs");
@@ -10,54 +13,42 @@ 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! 🤨"));
-    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();
+    if (!name) {
+        console.log(chalk.bold(chalk.red("Config extension or name is required! 🤨")));
+        return;
     }
-    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,
-        );
+    if (readConfig().routing === "spring") {
+        await generateSpringConfig(name);
     }
-    catch (e) {
-        console.log(chalk.bold(chalk.red(e)));
+    else {
+        let configDir = findConfigDirectory();
+        if (!configDir) {
+            createConfigDirectory();
+            configDir = findConfigDirectory();
+        }
+        const configDirName = configDir;
+        const configFilePath = path.join(configDirName + `/db.configs.${readConfig().language}`);
+        try {
+            await 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,
-        );
+        await 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,61 +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);
+        await generateSpringService(name, readConfig().database === "mongo" ? true : false, readConfig().database === "mysql" ? true : false);
     }
     else {
-        {
-            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)));
+        if (!name) {
+            console.log(chalk.bold(chalk.red("Service extension or name is required! 🤨")));
+            return;
+        }
+        let serviceDir = findServiceDirectory();
+        if (!serviceDir) {
+            createServiceDirectory();
+            serviceDir = findServiceDirectory();
+        }
+        const serviceDirName = path.join(serviceDir, name);
+        const serviceFilePath = path.join(serviceDirName + `/${name}.service.${readConfig().language}`);
+        try {
+            if (readConfig().generateFolder === "true" || true) {
+                mkdirSync(serviceDirName);
             }
+            await 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,29 +3,34 @@ 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}`);
+    const userComponentPath = path.join(projectRoot, `/src/components/${componentName}`);
     if (!existsSync(userComponentPath)) {
         mkdirSync(userComponentPath);
     }
 };
 const findComponentDirectory = (componentName) => {
     const rootDir = process.cwd();
-    const possibleDirs = [`src/${componentName}`];
+    const possibleDirs = [`src/components/${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());
-        }
-    });
+    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,29 +3,34 @@ 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}`);
+    const userCompontrollerPath = path.join(projectRoot, `/src/components/${componentName}`);
     if (!existsSync(userCompontrollerPath)) {
         mkdirSync(userCompontrollerPath);
     }
 };
 const findControllerDirectory = (componentName) => {
     const rootDir = process.cwd();
-    const possibleDirs = [`src/${componentName}`];
+    const possibleDirs = [`src/components/${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());
-        }
-    });
+    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,29 +3,34 @@ 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}`);
+    const userModelPath = path.join(projectRoot, `/src/components/${componentName}`);
     if (!existsSync(userModelPath)) {
         mkdirSync(userModelPath);
     }
 };
 const findModelDirectory = (componentName) => {
     const rootDir = process.cwd();
-    const possibleDirs = [`src/${componentName}`];
+    const possibleDirs = [`src/components/${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());
-        }
-    });
+    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_mysql.js

@@ -0,0 +1,48 @@
+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/shared/configs");
+    if (!existsSync(userConfigFilePath)) {
+        mkdirSync(userConfigFilePath);
+    }
+};
+const findConfigDirectory = () => {
+    const rootDir = process.cwd();
+    const possibleDirs = ["/src/shared/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) => {
+    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) {
+        console.log(chalk.bold(chalk.red("Config extension or name is required! 🤨")));
+        return;
+    }
+    let configDir = findConfigDirectory();
+    if (!configDir) {
+        createConfigDirectory();
+        configDir = findConfigDirectory();
+    }
+    const configDirName = configDir;
+    const configFilePath = path.join(configDirName + `/db.configs.${readConfig().language}`);
+    try {
+        await generateConfigFile(name, path.join(configFilePath), readConfig);
+    }
+    catch (e) {
+        console.log(chalk.bold(chalk.red(e)));
+    }
+};

package/dist/generators/spring/generate_spring_service.js

@@ -3,29 +3,34 @@ 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}`);
+    const userServicePath = path.join(projectRoot, `/src/components/${componentName}`);
     if (!existsSync(userServicePath)) {
         mkdirSync(userServicePath);
     }
 };
 const findServiceDirectory = (componentName) => {
     const rootDir = process.cwd();
-    const possibleDirs = [`src/${componentName}`];
+    const possibleDirs = [`src/components/${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());
-        }
-    });
+    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

@@ -1,9 +1,9 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dolphMsg } from "../helpers/messages.js";
 import path from "path";
-const createSrcDirectory = () => {
+const createComponentDirectory = () => {
     const projectRoot = path.join(process.cwd());
-    const userComponentPath = path.join(projectRoot, `/src`);
+    const userComponentPath = path.join(projectRoot, `/src/components`);
     if (!existsSync(userComponentPath)) {
         mkdirSync(userComponentPath);
     }
@@ -48,7 +48,9 @@ dolph.start();
                 if (routesArrayMatch) {
                     const existingCode = routesArrayMatch[1].trim();
                     let fileContents;
-                    fileContents = fileContent.replace(existingCode, `${existingCode.length > 0 ? existingCode + ", " : ""}${newComponentInstance}`);
+                    fileContents = fileContent.replace(existingCode, `[${existingCode.length > 0
+                        ? existingCode.slice(0, -1) + `, ${newComponentInstance}]`
+                        : newComponentInstance}`);
                     const updatedContents = `${importStatement}\n${fileContents}`;
                     writeFileSync(serverPath, updatedContents);
                 }

package/dist/utils/init_helper_function.js

@@ -24,12 +24,18 @@ export const initDolphCli = (appname) => {
     const configFolderPath = path.join(process.cwd());
     const srcPath = path.join(configFolderPath, "src");
     const userConfigFilePath = path.join(configFolderPath, "dolph_cli.yaml");
+    const testPath = path.join(configFolderPath, "tests");
+    const sharedDirPath = path.join(srcPath, "shared");
+    const componentDirPath = path.join(srcPath, "components");
     if (!existsSync(configFolderPath)) {
         mkdirSync(configFolderPath);
     }
     if (!existsSync(srcPath)) {
         mkdirSync(srcPath);
     }
+    if (!existsSync(testPath)) {
+        mkdirSync(testPath);
+    }
     const defaultConfig = {
         language: "ts",
         paradigm: "oop",
@@ -72,7 +78,7 @@ export const initDolphCli = (appname) => {
             .then((replies) => {
             // TODO: add this to the config file:
             const comment = "# this is an auto-generated file, please do not edit manually\n";
-            if ((replies.routing = "spring")) {
+            if (replies.routing === "spring") {
                 replies.paradigm = "oop";
                 replies.language = "ts";
             }
@@ -86,6 +92,14 @@ export const initDolphCli = (appname) => {
             writeDolphConfig();
             writePackageJsonFile(projectName, userConfig.language);
             writeGitignore();
+            if (userConfig.routing === "spring") {
+                if (!existsSync(componentDirPath)) {
+                    mkdirSync(componentDirPath);
+                }
+                if (!existsSync(sharedDirPath)) {
+                    mkdirSync(sharedDirPath);
+                }
+            }
             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);

package/dist/utils/package_generator.js

@@ -15,11 +15,11 @@ 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, --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("-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, --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]) => {
@@ -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.11",
+  "version": "1.1.13",
   "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",