@dolphjs/cli 0.1.1 → 1.0.0

package/dist/generators/templates/model_template.js

@@ -0,0 +1,168 @@
+const generateOopTsTemplate = (modelName, 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(modelName)} extends Document {
+  
+}
+
+const ${capitalizeFirstLetter(modelName)}Schema = new Schema(
+    {
+
+    }
+);
+
+export const ${capitalizeFirstLetter(modelName)}Model = model<I${capitalizeFirstLetter(modelName)}>("${modelName.charAt(0) !== "s" ? `${modelName}s` : modelName}", ${capitalizeFirstLetter(modelName)}Schema);
+`;
+    }
+    if (isMysql) {
+        template = `
+import { sequelizeInstance } from "@/configs/db.configs";
+import { DataTypes } from "sequelize";
+
+export const ${capitalizeFirstLetter(modelName)} = sequelizeInstance.define("${modelName}", {
+  id: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+    primaryKey: true,
+    autoIncrement: true,
+  },
+});
+`;
+    }
+    if (!isMongo && !isMysql) {
+        template = ``;
+    }
+    return template;
+};
+const generateOopJsTemplate = (modelName, isMongo, isMysql) => {
+    let template;
+    const capitalizeFirstLetter = (str) => {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    };
+    if (isMongo) {
+        template = `
+const { Schema, model } = require("mongoose");
+
+const ${capitalizeFirstLetter(modelName)}Schema = new Schema(
+    {
+
+    }
+);
+
+const ${capitalizeFirstLetter(modelName)}Model = model("${modelName.charAt(0) !== "s" ? `${modelName}s` : modelName}", ${capitalizeFirstLetter(modelName)}Schema);
+
+module.exports = { ${capitalizeFirstLetter(modelName)}Model }
+`;
+    }
+    if (isMysql) {
+        template = `
+const { sequelizeInstance } = require("../../../configs/db.configs");
+const { DataTypes } = require("sequelize");
+
+const User = sequelizeInstance.define("user", {
+  id: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+    primaryKey: true,
+    autoIncrement: true,
+  },
+});
+
+module.exports = { ${capitalizeFirstLetter(modelName)} };
+`;
+    }
+    if (!isMongo && !isMysql) {
+        template = ``;
+    }
+    return template;
+};
+const generateFnTsTemplate = (modelName, 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(modelName)} extends Document {
+  
+}
+
+const ${capitalizeFirstLetter(modelName)}Schema = new Schema(
+    {
+
+    }
+);
+
+export const ${capitalizeFirstLetter(modelName)}Model = model<I${capitalizeFirstLetter(modelName)}>("${modelName.charAt(0) !== "s" ? `${modelName}s` : modelName}", ${capitalizeFirstLetter(modelName)}Schema);
+`;
+    }
+    if (isMysql) {
+        template = `
+import { sequelizeInstance } from "@/configs/db.configs";
+import { DataTypes } from "sequelize";
+
+export const ${capitalizeFirstLetter(modelName)} = sequelizeInstance.define("${modelName}", {
+  id: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+    primaryKey: true,
+    autoIncrement: true,
+  },
+});
+`;
+    }
+    if (!isMongo && !isMysql) {
+        template = ``;
+    }
+    return template;
+};
+const generateFnJsTemplate = (modelName, isMongo, isMysql) => {
+    let template;
+    const capitalizeFirstLetter = (str) => {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    };
+    if (isMongo) {
+        template = `
+const { Schema, model } = require("mongoose");
+
+const ${capitalizeFirstLetter(modelName)}Schema = new Schema(
+    {
+
+    }
+);
+
+const ${capitalizeFirstLetter(modelName)}Model = model("${modelName.charAt(0) !== "s" ? `${modelName}s` : modelName}", ${capitalizeFirstLetter(modelName)}Schema);
+
+module.exports = { ${capitalizeFirstLetter(modelName)}Model };
+`;
+    }
+    if (isMysql) {
+        template = `
+const { sequelizeInstance } = require("../../../configs/db.configs");
+const { DataTypes } = require("sequelize");
+
+const User = sequelizeInstance.define("user", {
+  id: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+    primaryKey: true,
+    autoIncrement: true,
+  },
+});
+
+module.exports = { ${capitalizeFirstLetter(modelName)} };
+`;
+    }
+    if (!isMongo && !isMysql) {
+        template = ``;
+    }
+    return template;
+};
+export { generateFnJsTemplate, generateFnTsTemplate, generateOopJsTemplate, generateOopTsTemplate, };

package/dist/generators/templates/mysql_config_template.js

@@ -0,0 +1,59 @@
+const generateOopTsTemplate = () => {
+    let template;
+    template = `
+import { initMySql } from "@dolphjs/dolph/packages";
+import {} from ".."
+
+export const sequelizeInstance = initMySql(
+  "dolph",
+  "root",
+  "password",
+  "localhost"
+);
+
+`;
+    return template;
+};
+const generateOopJsTemplate = () => {
+    let template;
+    template = `
+const { initMySql } = require("@dolphjs/dolph/packages");
+const  {} = require("..");
+
+const sequelizeInstance = initMySql("dolph", "root", "password", "localhost");
+
+module.exports = { sequelizeInstance };
+
+`;
+    return template;
+};
+const generateFnTsTemplate = () => {
+    let template;
+    template = `
+import { initMySql } from "@dolphjs/dolph/packages";
+import {} from ".."
+
+export const sequelizeInstance = initMySql(
+  "dolph",
+  "root",
+  "password",
+  "localhost"
+);
+
+`;
+    return template;
+};
+const generateFnJsTemplate = () => {
+    let template;
+    template = `
+const { initMySql } = require("@dolphjs/dolph/packages");
+const  {} = require("..");
+
+const sequelizeInstance = initMySql("dolph", "root", "password", "localhost");
+
+module.exports = { sequelizeInstance };
+
+`;
+    return template;
+};
+export { generateFnJsTemplate, generateFnTsTemplate, generateOopJsTemplate, generateOopTsTemplate, };

package/dist/generators/templates/routes_template.js

@@ -0,0 +1,86 @@
+const generateOopTsTemplate = (routerName) => {
+    const capitalizeFirstLetter = (str) => {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    };
+    const className = capitalizeFirstLetter(routerName) + "Router";
+    const path = `/${routerName.charAt(0) === "s" ? routerName : `${routerName}s`}`;
+    const template = `
+import { DolphRouteHandler } from "@dolphjs/dolph/classes";
+import { Dolph } from "@dolphjs/dolph/common";
+
+export class ${className} extends DolphRouteHandler<Dolph> {
+  constructor() {
+    super();
+    this.initRoutes();
+  }
+
+  public readonly path: string = "${path}";
+  controller;
+
+  initRoutes(): void {
+    this.router.get();
+  }
+}
+`;
+    return template;
+};
+const generateOopJsTemplate = (routerName) => {
+    const capitalizeFirstLetter = (str) => {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    };
+    const className = capitalizeFirstLetter(routerName) + "Router";
+    const path = `/${routerName.charAt(0) === "s" ? routerName : `${routerName}s`}`;
+    const template = `
+const { DolphRouteHandler } = require("@dolphjs/dolph/classes");
+
+class ${className} extends DolphRouteHandler {
+  constructor() {
+    super();
+    this.initRoutes();
+  }
+
+  path = "${path}";
+  controller;
+
+  initRoutes() {
+    this.router.get();
+  }
+}
+
+module.exports = { ${className} };
+`;
+    return template;
+};
+const generateFnTsTemplate = (routerName) => {
+    const path = `/${routerName}`;
+    const template = `
+import { Router } from "express";
+
+const router = Router();
+router.get();
+
+export const ${routerName}Routes = {
+  path: "${path}",
+  router,
+};
+`;
+    return template;
+};
+const generateFnJsTemplate = (routerName) => {
+    const path = `/${routerName}`;
+    const template = `
+const { Router } = require("express");
+
+const router = Router();
+router.get();
+
+const ${routerName}Routes = {
+  path: "${path}",
+  router,
+};
+
+module.exports = { ${routerName}Routes };
+`;
+    return template;
+};
+export { generateFnJsTemplate, generateFnTsTemplate, generateOopJsTemplate, generateOopTsTemplate, };

package/dist/generators/templates/service_template.js

@@ -0,0 +1,172 @@
+const generateOopTsTemplate = (serviceName, isMongo, isMySql) => {
+    let template;
+    const capitalizeFirstLetter = (str) => {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    };
+    const className = capitalizeFirstLetter(serviceName) + "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";
+
+
+@InjectMongo("${serviceName}Model", )
+@InjectMySQL("${serviceName}SqlModel", )
+export class ${className} extends DolphServiceHandler<Dolph> {
+  ${serviceName}Model!: Model<>;
+  ${serviceName}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";
+
+
+@InjectMongo("${serviceName}Model", )
+export class ${className} extends DolphServiceHandler<Dolph> {
+  ${serviceName}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("${serviceName}Model", )
+export class ${className} extends DolphServiceHandler<Dolph> {
+  ${serviceName}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;
+};
+const generateOopJsTemplate = (serviceName, isMongo, isMySql) => {
+    let template;
+    const capitalizeFirstLetter = (str) => {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    };
+    const className = capitalizeFirstLetter(serviceName) + "Service";
+    if (isMongo && isMySql) {
+        template = `
+const { DolphServiceHandler } = require("@dolphjs/dolph/classes");
+
+class ${className} extends DolphServiceHandler {
+
+  constructor() {
+    super("${className.toLowerCase()}");
+  }
+}
+    
+`;
+    }
+    if (isMongo) {
+        template = `
+const { DolphServiceHandler } = require("@dolphjs/dolph/classes");
+
+export class ${className} extends DolphServiceHandler {
+
+  constructor() {
+    super("${className.toLowerCase()}");
+  }
+}
+    
+`;
+    }
+    if (isMySql) {
+        template = `
+const { DolphServiceHandler } = require("@dolphjs/dolph/classes");
+
+export class ${className} extends DolphServiceHandler {
+
+  constructor() {
+    super("${className.toLowerCase()}");
+  }
+}
+    
+`;
+    }
+    if (!isMongo && !isMySql) {
+        template = `
+const { DolphServiceHandler } = require("@dolphjs/dolph/classes");
+
+
+export class ${className} extends DolphServiceHandler {
+
+  constructor() {
+    super("${className.toLowerCase()}");
+  }
+}    
+
+module.exports = { ${className} }
+`;
+    }
+    return template;
+};
+const generateFnTsTemplate = (serviceName) => {
+    let template;
+    template = `
+import { TryCatchAsyncFn } from "@dolphjs/dolph/common";
+
+export const default${serviceName}Service = TryCatchAsyncFn(async (data: string) => {
+  return { data };
+});
+
+`;
+    return template;
+};
+const generateFnJsTemplate = (serviceName) => {
+    let template;
+    template = `
+const { TryCatchAsyncFn } = require("@dolphjs/dolph/classes");
+
+const default${serviceName}Service = TryCatchAsyncFn(async (data) => {
+  return { data };
+});
+
+module.exports = { default${serviceName}Service }
+`;
+    return template;
+};
+export { generateFnJsTemplate, generateFnTsTemplate, generateOopJsTemplate, generateOopTsTemplate, };

package/dist/index.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import chalk from "chalk";
+import { program } from "commander";
+import figlet from "figlet";
+import { packageDescription } from "./utils/package_description.js";
+import { configurePackage } from "./utils/read_user_config.js";
+import { InitDolphCli } from "./utils/package_init.js";
+import { packageGenerator } from "./utils/package_generator.js";
+figlet.text("dolphjs cli", {
+    font: "Big",
+    horizontalLayout: "default",
+    verticalLayout: "default",
+    width: 150,
+    whitespaceBreak: true,
+}, function (err, _data) {
+    if (err) {
+        console.log("[FIGLET ERROR]: ", chalk.red(err.toString()));
+        return;
+    }
+    // console.log(chalk.bold(chalk.cyan(data)));
+    InitDolphCli();
+    packageDescription();
+    configurePackage();
+    packageGenerator();
+    program.command("*", { hidden: true }).action(() => {
+        console.log(`${chalk.red("[DOLPH ERROR]: ")} ${chalk.redBright("unknown command. See list of available commands: ")}`);
+        program.help();
+    });
+    program.parse(process.argv);
+});

package/dist/registers/register_routes.js

@@ -0,0 +1,145 @@
+import chalk from "chalk";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import path from "path";
+// removed other possible dirs to enforce dolphjs style guide
+const findRoutesDirectory = () => {
+    const rootDir = process.cwd();
+    const possibleDirs = [
+        "/src/routes",
+        // "/src/Routes",
+        // "/src/route",
+        // "/src/Route",
+        // "/Routes",
+        // "/Route",
+        // "/routes",
+        // "/route",
+    ];
+    const routesDir = possibleDirs.find((dir) => existsSync(path.join(rootDir, dir)));
+    return routesDir ? path.join(rootDir, routesDir) : null;
+};
+export const addRoutesIndexFile = (routesName, readConfig) => {
+    let extension;
+    let paradigm;
+    paradigm = readConfig().paradigm;
+    switch (readConfig().language) {
+        case "ts":
+            extension = "ts";
+            break;
+        case "js":
+            extension = "js";
+            break;
+        default:
+            extension = "ts";
+            break;
+    }
+    if (!routesName)
+        chalk.bold(chalk.red("Routes extension or name is required! 🤨"));
+    const routesDir = findRoutesDirectory();
+    if (!routesDir) {
+        //TODO: create one if it doesn't exist
+        console.log(chalk.bold(chalk.red("Routes directory doesn't exist 🤨")));
+        return;
+    }
+    const indexPath = path.join(routesDir, `index.${extension}`);
+    let importStatement = ``;
+    const capitalizedString = routesName.charAt(0).toUpperCase() + routesName.slice(1);
+    if (extension === "ts") {
+        importStatement = `import { ${capitalizedString}Router } from "./${routesName}/${routesName}.routes"; `;
+        if (paradigm !== "oop") {
+            importStatement = `import { ${routesName}Routes } from "./${routesName}/${routesName}.routes"; `;
+        }
+    }
+    else if (extension === "js") {
+        importStatement = `const { ${capitalizedString}Router } = require("./${routesName}/${routesName}.routes"); `;
+        if (paradigm !== "oop") {
+            importStatement = `const { ${routesName}Routes } = require("./${routesName}/${routesName}.routes"); `;
+        }
+    }
+    else {
+        console.log(chalk.bold(chalk.red("dolphjs only supports '.js' & '.ts' file extensions")));
+    }
+    let routesArray = "";
+    if (extension === "ts") {
+        routesArray = `export const routes = [new ${capitalizedString}Router()]; `;
+        if (paradigm !== "oop") {
+            routesArray = `export const routes = [${routesName}Routes];`;
+        }
+    }
+    else {
+        routesArray = `const routes = [new ${capitalizedString}Router()]; 
+module.exports  = { routes };
+        `;
+        if (paradigm !== "oop") {
+            routesArray = `const routes = [${routesName}Routes];
+module.exports  = { routes }; 
+      `;
+        }
+    }
+    try {
+        // check if file exists
+        if (!existsSync(indexPath)) {
+            // if it doesn't exist, create file and add import statement
+            const fileContent = `${importStatement}\n\n${routesArray}\n`;
+            writeFileSync(indexPath, fileContent);
+        }
+        else {
+            const fileContent = readFileSync(indexPath, "utf8");
+            const newRouterInstance = `new ${capitalizedString}Router()`;
+            const newRoutesInstance = `${routesName}Routes`;
+            if (!fileContent.includes(importStatement)) {
+                const updatedContent = `${importStatement}\n${fileContent}`;
+                writeFileSync(indexPath, updatedContent);
+            }
+            if (fileContent.includes(`${extension === "ts" ? "export const routes" : "const routes"}`)) {
+                // add new routes instance to the exisiting routes array
+                if (extension === "ts") {
+                    const routesArrayMatch = fileContent.match(/export const routes = \[([\s\S]+?)\];/);
+                    if (routesArrayMatch) {
+                        const existingRoutes = routesArrayMatch[1].trim();
+                        let fileContents;
+                        if (paradigm === "oop") {
+                            fileContents = fileContent.replace(existingRoutes, `${existingRoutes.length > 0 ? existingRoutes + ", " : ""}${newRouterInstance}`);
+                        }
+                        else {
+                            fileContents = fileContent.replace(`[${existingRoutes}]`, `[${existingRoutes.length > 0 ? existingRoutes + ", " : ""}${newRoutesInstance}]`);
+                        }
+                        const updatedContents = `${importStatement}\n${fileContents}`;
+                        writeFileSync(indexPath, updatedContents);
+                    }
+                }
+                else {
+                    const routesArrayMatch = fileContent.match(/const routes = \[([\s\S]+?)\];/);
+                    if (routesArrayMatch) {
+                        const existingRoutes = routesArrayMatch[1].trim();
+                        let fileContents;
+                        if (paradigm === "oop") {
+                            fileContents = fileContent.replace(existingRoutes, `${existingRoutes.length > 0 ? existingRoutes + ", " : ""}${newRouterInstance}`);
+                        }
+                        else {
+                            fileContents = fileContent.replace(`[${existingRoutes}]`, `[${existingRoutes.length > 0 ? existingRoutes + ", " : ""}${newRoutesInstance}]`);
+                        }
+                        const updatedContents = `${importStatement}\n${fileContents}`;
+                        writeFileSync(indexPath, updatedContents);
+                    }
+                }
+            }
+            else {
+                // if there is no routes array, add new one
+                if (extension === "ts") {
+                    const updatedContents = `${fileContent.trim()}\n\nexport const routes = [${paradigm !== "oop" ? newRouterInstance : newRoutesInstance}];\n`;
+                    writeFileSync(indexPath, updatedContents);
+                }
+                else {
+                    const updatedContents = `${fileContent.trim()}\n\nconst routes = [${paradigm !== "oop" ? newRouterInstance : newRoutesInstance}];\n\n module.exports = { routes } \n`;
+                    writeFileSync(indexPath, updatedContents);
+                }
+            }
+        }
+        console.log(chalk.bold(chalk.green(`added ${paradigm === "oop"
+            ? `${capitalizedString}Router`
+            : `${routesName}Routes`} to routes array in index.${extension} file`)));
+    }
+    catch (e) {
+        console.log(chalk.bold(chalk.red(e)));
+    }
+};