@dolphjs/cli 0.1.1 → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Dolph
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/generators/generate_controller.js

@@ -0,0 +1,65 @@
+import { existsSync, mkdirSync, writeFile } from "fs";
+import path from "path";
+import chalk from "chalk";
+import { readConfig } from "../utils/read_user_config_path.js";
+import { resolveControllerContent } from "./resolvers/resolve_controller_content.js";
+const createControllerDirectory = () => {
+    const projectRoot = path.join(process.cwd());
+    const userControllerFilePath = path.join(projectRoot, "/src/controllers");
+    if (!existsSync(userControllerFilePath)) {
+        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 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())));
+        }
+    });
+};
+export const generateController = async (name) => {
+    if (!name)
+        chalk.bold(chalk.red("Controller extension or name is required! 🤨"));
+    let controllerDir = findControllerDirectory();
+    if (!controllerDir) {
+        //TODO: create one if it doesn't exist
+        // console.log(
+        //   chalk.bold(chalk.red("controller directory doesn't exist 🤨"))
+        // );
+        // return;
+        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);
+        }
+        //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! 🙃`))}`);
+};

package/dist/generators/generate_model.js

@@ -0,0 +1,61 @@
+import { existsSync, mkdirSync, writeFile } from "fs";
+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";
+const createModelDirectory = () => {
+    const projectRoot = path.join(process.cwd());
+    const userModelFilePath = path.join(projectRoot, "/src/models");
+    if (!existsSync(userModelFilePath)) {
+        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 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())));
+        }
+    });
+};
+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();
+    }
+    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_mysql.js

@@ -0,0 +1,63 @@
+import { existsSync, mkdirSync, writeFile } from "fs";
+import path from "path";
+import chalk from "chalk";
+import { readConfig } from "../utils/read_user_config_path.js";
+import { resolveMySqlContent } from "./resolvers/resolve_model_content.js";
+const createConfigDirectory = () => {
+    const projectRoot = path.join(process.cwd());
+    const userConfigFilePath = path.join(projectRoot, "/src/configs");
+    if (!existsSync(userConfigFilePath)) {
+        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 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())));
+        }
+    });
+};
+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();
+    }
+    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,
+        );
+    }
+    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

@@ -0,0 +1,59 @@
+import { existsSync, mkdirSync, writeFile } from "fs";
+import path from "path";
+import chalk from "chalk";
+import { readConfig } from "../utils/read_user_config_path.js";
+import { resolveRoutesContent } from "./resolvers/resolve_routes_content.js";
+const createRoutesDirectory = () => {
+    const projectRoot = path.join(process.cwd());
+    const userRoutesFilePath = path.join(projectRoot, "/src/routes");
+    if (!existsSync(userRoutesFilePath)) {
+        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 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())));
+        }
+    });
+};
+export const generateRouter = async (name) => {
+    if (!name)
+        chalk.bold(chalk.red("Routes extension or name is required! 🤨"));
+    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,
+        );
+    }
+    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

@@ -0,0 +1,63 @@
+import { existsSync, mkdirSync, writeFile } from "fs";
+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";
+const createServiceDirectory = () => {
+    const projectRoot = path.join(process.cwd());
+    const userServiceFilePath = path.join(projectRoot, "/src/services");
+    if (!existsSync(userServiceFilePath)) {
+        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 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())));
+        }
+    });
+};
+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();
+    }
+    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)));
+    }
+    console.log(`${chalk.bold(chalk.green(`${name}.service.${readConfig().language} generated successfully! 🙃`))}`);
+};

package/dist/generators/resolvers/resolve_controller_content.js

@@ -0,0 +1,19 @@
+// import { readConfig } from "utils/read_user_config_path.js";
+import * as generateControllerTemplate from "../templates/controller_template.js";
+export const resolveControllerContent = (readConfig, controllerName) => {
+    if (readConfig().language === "js" && readConfig().paradigm === "oop") {
+        return generateControllerTemplate.generateOopJsTemplate(controllerName);
+    }
+    else if (readConfig().language === "js" &&
+        readConfig().paradigm === "functional") {
+        return generateControllerTemplate.generateFnJsTemplate(controllerName);
+    }
+    else if (readConfig().language === "ts" &&
+        readConfig().paradigm === "oop") {
+        return generateControllerTemplate.generateOopTsTemplate(controllerName);
+    }
+    else if (readConfig().language === "ts" &&
+        readConfig().paradigm === "functional") {
+        return generateControllerTemplate.generateFnTsTemplate(controllerName);
+    }
+};

package/dist/generators/resolvers/resolve_model_content.js

@@ -0,0 +1,37 @@
+// import { readConfig } from "utils/read_user_config_path.js";
+import * as generateModelTemplate from "../templates/model_template.js";
+import * as generateMySqlTemplate from "../templates/mysql_config_template.js";
+export const resolveModelContent = (readConfig, modelName) => {
+    if (readConfig().language === "js" && readConfig().paradigm === "oop") {
+        return generateModelTemplate.generateOopJsTemplate(modelName, readConfig().database === "mongo" ? true : false, readConfig().database === "mysql" ? true : false);
+    }
+    else if (readConfig().language === "js" &&
+        readConfig().paradigm === "functional") {
+        return generateModelTemplate.generateFnJsTemplate(modelName, readConfig().database === "mongo" ? true : false, readConfig().database === "mysql" ? true : false);
+    }
+    else if (readConfig().language === "ts" &&
+        readConfig().paradigm === "oop") {
+        return generateModelTemplate.generateOopTsTemplate(modelName, readConfig().database === "mongo" ? true : false, readConfig().database === "mysql" ? true : false);
+    }
+    else if (readConfig().language === "ts" &&
+        readConfig().paradigm === "functional") {
+        return generateModelTemplate.generateFnTsTemplate(modelName, readConfig().database === "mongo" ? true : false, readConfig().database === "mysql" ? true : false);
+    }
+};
+export const resolveMySqlContent = (readConfig) => {
+    if (readConfig().language === "js" && readConfig().paradigm === "oop") {
+        return generateMySqlTemplate.generateOopJsTemplate();
+    }
+    else if (readConfig().language === "js" &&
+        readConfig().paradigm === "functional") {
+        return generateMySqlTemplate.generateFnJsTemplate();
+    }
+    else if (readConfig().language === "ts" &&
+        readConfig().paradigm === "oop") {
+        return generateMySqlTemplate.generateOopTsTemplate();
+    }
+    else if (readConfig().language === "ts" &&
+        readConfig().paradigm === "functional") {
+        return generateMySqlTemplate.generateFnTsTemplate();
+    }
+};

package/dist/generators/resolvers/resolve_routes_content.js

@@ -0,0 +1,19 @@
+// import { readConfig } from "utils/read_user_config_path.js";
+import * as generateRoutesTemplate from "../templates/routes_template.js";
+export const resolveRoutesContent = (readConfig, routerName) => {
+    if (readConfig().language === "js" && readConfig().paradigm === "oop") {
+        return generateRoutesTemplate.generateOopJsTemplate(routerName);
+    }
+    else if (readConfig().language === "js" &&
+        readConfig().paradigm === "functional") {
+        return generateRoutesTemplate.generateFnJsTemplate(routerName);
+    }
+    else if (readConfig().language === "ts" &&
+        readConfig().paradigm === "oop") {
+        return generateRoutesTemplate.generateOopTsTemplate(routerName);
+    }
+    else if (readConfig().language === "ts" &&
+        readConfig().paradigm === "functional") {
+        return generateRoutesTemplate.generateFnTsTemplate(routerName);
+    }
+};

package/dist/generators/resolvers/resolve_service_content.js

@@ -0,0 +1,19 @@
+// import { readConfig } from "utils/read_user_config_path.js";
+import * as generateServiceTemplate from "../templates/service_template.js";
+export const resolveServiceContent = (readConfig, serviceName) => {
+    if (readConfig().language === "js" && readConfig().paradigm === "oop") {
+        return generateServiceTemplate.generateOopJsTemplate(serviceName, readConfig().database === "mongo" ? true : false, readConfig().database === "mysql" ? true : false);
+    }
+    else if (readConfig().language === "js" &&
+        readConfig().paradigm === "functional") {
+        return generateServiceTemplate.generateFnJsTemplate(serviceName);
+    }
+    else if (readConfig().language === "ts" &&
+        readConfig().paradigm === "oop") {
+        return generateServiceTemplate.generateOopTsTemplate(serviceName, readConfig().database === "mongo" ? true : false, readConfig().database === "mysql" ? true : false);
+    }
+    else if (readConfig().language === "ts" &&
+        readConfig().paradigm === "functional") {
+        return generateServiceTemplate.generateFnTsTemplate(serviceName);
+    }
+};

package/dist/generators/templates/controller_template.js

@@ -0,0 +1,83 @@
+const generateOopTsTemplate = (controllerName) => {
+    let template;
+    const capitalizeFirstLetter = (str) => {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    };
+    const className = capitalizeFirstLetter(controllerName) + "Controller";
+    template = `
+import { DolphControllerHandler } from "@dolphjs/dolph/classes";
+import {
+  Dolph,
+  SuccessResponse,
+  TryCatchAsyncDec,
+  DRequest,
+  DResponse
+} from "@dolphjs/dolph/common";
+
+export class ${className} extends DolphControllerHandler<Dolph> {
+  constructor() {
+    super();
+  }
+
+  @TryCatchAsyncDec
+  public async defaultMethod (req: DRequest, res: DResponse) {
+    SuccessResponse({ res, body: { message: "${controllerName} is working!" } });
+  }
+}
+`;
+    return template;
+};
+const generateOopJsTemplate = (controllerName) => {
+    let template;
+    const capitalizeFirstLetter = (str) => {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    };
+    const className = capitalizeFirstLetter(controllerName) + "Controller";
+    template = `
+const { DolphControllerHandler } = require("@dolphjs/dolph/classes");
+const {
+  SuccessResponse,
+  TryCatchAsyncFn,
+} = require("@dolphjs/dolph/common");
+
+class ${className} extends DolphControllerHandler {
+  constructor() {
+    super();
+  }
+
+  defaultMethod = TryCatchAsyncFn (async (req, res) => {
+    SuccessResponse({ res, body: { message: "${controllerName} is working!" } });
+  });
+}
+
+module.exports = { ${className} }
+`;
+    return template;
+};
+const generateFnTsTemplate = (controllerName) => {
+    let template;
+    template = `
+import { TryCatchAsyncFn, SuccessResponse, DRequest, DResponse } from "@dolphjs/dolph/common";
+
+export const defaultFunc = TryCatchAsyncFn(async (req: DRequest, res: DResponse) => {
+  SuccessResponse({ res, body: { message: "${controllerName} working!" } });
+});
+
+`;
+    return template;
+};
+const generateFnJsTemplate = (controllerName) => {
+    let template;
+    template = `
+const { TryCatchAsyncFn, SuccessResponse } = require("@dolphjs/dolph/common");
+
+const defaultFunc = TryCatchAsyncFn(async (req, res) => {
+  SuccessResponse({ res, body: { message: "${controllerName} working!" } });
+});
+
+module.exports = { defaultFunc };
+
+`;
+    return template;
+};
+export { generateFnJsTemplate, generateFnTsTemplate, generateOopJsTemplate, generateOopTsTemplate, };