@dolphjs/cli 0.1.1 → 1.0.1

package/dist/registers/server_file_routes.js

@@ -0,0 +1,74 @@
+import chalk from "chalk";
+import { existsSync, writeFileSync } from "fs";
+import path from "path";
+// removed other possible dirs to enforce dolphjs style guide
+const findBaseDirectory = () => {
+    const rootDir = process.cwd();
+    const possibleDirs = [
+        "/src",
+        //  "/"
+    ];
+    const routesDir = possibleDirs.find((dir) => existsSync(path.join(rootDir, dir)));
+    return routesDir ? path.join(rootDir, routesDir) : null;
+};
+export const addServerFile = (readConfig) => {
+    let extension;
+    let database;
+    extension = readConfig().language;
+    database = readConfig().database;
+    const baseDirectory = findBaseDirectory();
+    const indexPath = path.join(baseDirectory, `server.${extension}`);
+    let importStatement = ``;
+    let otherFileContent = "";
+    if (extension === "ts" && database === "mysql") {
+        importStatement = `import { DolphFactory } from "@dolphjs/dolph";
+import { routes } from "./routes";
+import { sequelizeInstance } from "@/configs/db.configs";
+import { autoInitMySql } from "@dolphjs/dolph/packages";
+`;
+    }
+    else if (extension === "ts") {
+        importStatement = `import { DolphFactory } from "@dolphjs/dolph";
+import { routes } from "./routes";`;
+    }
+    else if (extension === "js" && database === "mysql") {
+        importStatement = `const { DolphFactory } = require("@dolphjs/dolph");
+const { routes } = require("./routes");
+const { sequelizeInstance } = require("@/configs/db.configs");
+const { autoInitMySql } = require("@dolphjs/dolph/packages");
+`;
+    }
+    else if (extension === "js") {
+        importStatement = `const { DolphFactory } = require("@dolphjs/dolph");
+const { routes } = require("./routes");`;
+    }
+    else {
+        console.log(chalk.bold(chalk.red("dolphjs only supports '.js' & '.ts' file extensions ")));
+    }
+    if (database === "mysql") {
+        otherFileContent = `const dolph = new DolphFactory(routes, []);
+autoInitMySql(sequelizeInstance);
+
+dolph.start();`;
+    }
+    else {
+        otherFileContent = `const dolph = new DolphFactory(routes, []);
+dolph.start();`;
+    }
+    try {
+        // check if file exists
+        if (!existsSync(indexPath)) {
+            // if it doesn't exist, create file and add import statement
+            const fileContent = `${importStatement}\n\n${otherFileContent}\n`;
+            writeFileSync(indexPath, fileContent);
+        }
+        else {
+            const fileContent = `${importStatement}\n\n${otherFileContent}\n`;
+            writeFileSync(indexPath, fileContent);
+        }
+        console.log(chalk.bold(chalk.green(`added server.${extension} file to base directory`)));
+    }
+    catch (e) {
+        console.log(chalk.bold(chalk.red(e)));
+    }
+};

package/dist/types/config.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/get_root_dir_path.js

@@ -0,0 +1,11 @@
+import path from "path";
+import { config } from "dotenv";
+config();
+export const getRootDirectory = () => {
+    let projectRoot;
+    projectRoot =
+        process.env?.mode === "dev"
+            ? path.join(process.cwd(), "src")
+            : path.join(process.cwd());
+    return projectRoot;
+};

package/dist/utils/get_user_config_path.js

@@ -0,0 +1,10 @@
+import { existsSync } from "fs";
+import path from "path";
+export const getUserConfigFilePath = () => {
+    const userConfigFolderPath = path.join(process.cwd());
+    const userConfigFilePath = path.join(userConfigFolderPath, "dolph-cli.yaml");
+    if (existsSync(userConfigFilePath)) {
+        return userConfigFilePath;
+    }
+    return path.join(userConfigFilePath, "../../", "dolph-cli.yaml");
+};

package/dist/utils/init_helper_function.js

@@ -0,0 +1,90 @@
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import inquirer from "inquirer";
+import path from "path";
+import yaml from "js-yaml";
+import chalk from "chalk";
+import { writeSwcrc } from "./write_swrcc.js";
+import { writeTsConfigFile } from "./write_tsconfig.js";
+import { writeDolphConfig } from "./write_dolph_config.js";
+import { writePackageJsonFile } from "./write_package_json.js";
+import { writeGitignore } from "./write_gitignore.js";
+export const initDolphCli = (appname) => {
+    let projectName = appname;
+    if (appname.length === 0) {
+        console.log(chalk.red(chalk.bold("Provide a name for you project or indicate with a '.' to use current directory ")));
+        return;
+    }
+    if (appname !== ".") {
+        mkdirSync(appname);
+        process.chdir(appname);
+    }
+    else {
+        projectName = process.cwd().split("/").pop();
+    }
+    const configFolderPath = path.join(process.cwd());
+    const srcPath = path.join(configFolderPath, "src");
+    const userConfigFilePath = path.join(configFolderPath, "dolph-cli.yaml");
+    if (!existsSync(configFolderPath)) {
+        mkdirSync(configFolderPath);
+    }
+    if (!existsSync(srcPath)) {
+        mkdirSync(srcPath);
+    }
+    const defaultConfig = {
+        language: "ts",
+        paradigm: "oop",
+        database: "mongo",
+        generateFolder: true,
+    };
+    if (!existsSync(userConfigFilePath)) {
+        inquirer
+            .prompt([
+            {
+                type: "list",
+                name: "language",
+                message: "Select your preferred language",
+                choices: ["ts", "js"],
+                default: "ts",
+            },
+            {
+                type: "list",
+                name: "paradigm",
+                message: "Choose the programming paradigm for your app (recommended is 'oop' )",
+                choices: ["oop", "functional"],
+                default: "oop",
+            },
+            {
+                type: "list",
+                name: "database",
+                message: "Which database will you be using?",
+                choices: ["mongo", "mysql", "postgresql", "other"],
+                default: "mongo",
+            },
+            // {
+            //   type: "list",
+            //   name: "generateFolder",
+            //   message:
+            //     "Generate folder and files for the Services, Models, Controllers and Routes",
+            //   choices: ["true", "false"],
+            //   default: "true",
+            // },
+        ])
+            .then((replies) => {
+            const userConfig = { ...defaultConfig, ...replies };
+            const yamlString = yaml.dump(userConfig);
+            writeFileSync(userConfigFilePath, yamlString, "utf8");
+            if (userConfig.language === "ts") {
+                writeSwcrc();
+                writeTsConfigFile();
+            }
+            writeDolphConfig();
+            writePackageJsonFile(projectName, userConfig.language);
+            writeGitignore();
+            console.log(chalk.green(chalk.bold("dolph cli configurations have been initialized successfully 😎.")));
+            console.log(chalk.green(chalk.bold("run yarn install to install dependencies in project directory and start coding 😉.")));
+        });
+    }
+    else {
+        console.log(chalk.bold(chalk.cyan("I see you already have your dolph cli configurations present 😉.")));
+    }
+};

package/dist/utils/package_description.js

@@ -0,0 +1,6 @@
+import chalk from "chalk";
+import { program } from "commander";
+import { description, version } from "./read_package_json.js";
+export const packageDescription = () => {
+    program.version(version).description(chalk.cyan(description));
+};

package/dist/utils/package_generator.js

@@ -0,0 +1,73 @@
+import { program } from "commander";
+import chalk from "chalk";
+import * as controllerGen from "../generators/generate_controller.js";
+import * as serviceGen from "../generators/generate_service.js";
+import * as routesGen from "../generators/generate_routes.js";
+import * as modelGen from "../generators/generate_model.js";
+import * as mysqlGen from "../generators/generate_mysql.js";
+import { readConfig } from "./read_user_config_path.js";
+import { addRoutesIndexFile } from "../registers/register_routes.js";
+import { addServerFile } from "../registers/server_file_routes.js";
+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, --routes" + chalk.bold(chalk.blue("<name>")), "Generates a dolphjs routes file.")
+        .option("-m, --models" + chalk.bold(chalk.blue("<name>")), "Generates a dolphjs models file.")
+        .option("-a, --all" + chalk.bold(chalk.blue("<name>")), "Generates dolphjs ocntrollers, routes, models and services files for the name paramter.")
+        // .option(
+        //   "-in, --interfaces" + chalk.bold(chalk.blue("<name>")),
+        //   "Generates a dolphjs interfaces file."
+        // )
+        // .option(
+        //   "-hp, --helper" + chalk.bold(chalk.blue("<name>")),
+        //   "Generates a dolphjs helper file."
+        // )
+        .action(async (name, _options) => {
+        Object.entries(name).forEach(([key, value]) => {
+            // generates controller files for the paramter name
+            if (key && key.toLowerCase().includes("controller") && value) {
+                controllerGen.generateController(value.toString());
+            }
+            // generates service files for the paramter name
+            if (key && key.toLowerCase().includes("service") && value) {
+                serviceGen.generateService(value.toString());
+            }
+            // generatess routes files for the paramter name
+            if (key && key.toLowerCase().includes("routes") && value) {
+                routesGen.generateRouter(value.toString());
+                addRoutesIndexFile(value.toString(), readConfig);
+            }
+            // generatess model fles for the paramter name
+            if (key && key.toLowerCase().includes("models") && value) {
+                modelGen.generateModel(value.toString());
+                if (readConfig().database === "mysql") {
+                    mysqlGen.generateConfig(value.toString());
+                }
+            }
+            // generates files for all the above options
+            if (key && key.toLowerCase().includes("all") && value) {
+                modelGen.generateModel(value.toString());
+                if (readConfig().database === "mysql") {
+                    mysqlGen.generateConfig(value.toString());
+                }
+                serviceGen.generateService(value.toString());
+                controllerGen.generateController(value.toString());
+                routesGen.generateRouter(value.toString());
+                addRoutesIndexFile(value.toString(), readConfig);
+                addServerFile(readConfig);
+            }
+        });
+        //   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/dist/utils/package_init.js

@@ -0,0 +1,11 @@
+import { program } from "commander";
+import { initDolphCli } from "./init_helper_function.js";
+export const InitDolphCli = () => {
+    program
+        .command("new <project-name>")
+        .alias("nw")
+        .description("Creates a new dolphjs app")
+        .action((appname) => {
+        initDolphCli(appname);
+    });
+};

package/dist/utils/read_package_json.js

@@ -0,0 +1,9 @@
+import { readFileSync } from "fs";
+import path from "path";
+const packageJsonPath = path.join(process.cwd(), "package.json");
+const packageJsonContent = readFileSync(packageJsonPath, "utf8");
+const packageJson = JSON.parse(packageJsonContent);
+const version = packageJson.version;
+const name = packageJson.name;
+const description = packageJson.description;
+export { version, name, description };

package/dist/utils/read_user_config.js

@@ -0,0 +1,67 @@
+import { program } from "commander";
+import chalk from "chalk";
+import { readConfig } from "./read_user_config_path.js";
+import { writeConfig } from "./write_user_config.js";
+const dbOptions = ["mongo", "postgresql", "mysql", "other"];
+export const configurePackage = () => {
+    program
+        .command("config")
+        .alias("cf")
+        .description("Set default configurations")
+        .option("-l, --language" + chalk.bold(chalk.blue("<language>")), "Set the default coding language (ts or js)")
+        .option("-p, --paradigm" + chalk.bold(chalk.blue("<paradigm>")), "Set the default programming paradigm (oop or functional)")
+        .option("-d, --database" + chalk.bold(chalk.blue("<database>")), "Set the default project database (mongo, mysql, postresql or other)")
+        .option("-gf, --generateFolder" + chalk.bold(chalk.blue("<boolean>")), "Generates a folder file for the Services, Models, Controllers and Routes (true or false)")
+        .action((options) => {
+        const config = readConfig();
+        // validate language choosen
+        if (options.language) {
+            if (options.language !== "js" && options.language !== "ts") {
+                console.log(options.language);
+                console.log(chalk.red(`Invalid project language, format must be either ${chalk.bold("js")} or ${chalk.bold("ts")}`));
+                return;
+            }
+            config.language = options.language;
+            writeConfig(config);
+            console.log(chalk.cyan(`Default project language is now ${chalk.bold(config.language)}`));
+            return;
+        }
+        // validate paradigm choosen
+        if (options.paradigm) {
+            if (options.paradigm !== "oop" && options.paradigm !== "functional") {
+                console.log(chalk.red(`Invalid programming paradigm, must be either ${chalk.bold("oop")} or ${chalk.bold("functional")}`));
+                return;
+            }
+            config.paradigm = options.paradigm;
+            writeConfig(config);
+            console.log(chalk.cyan(`Default programming paradigm is now ${chalk.bold(config.paradigm)}`));
+            return;
+        }
+        // validate database choosen
+        if (options.database) {
+            if (!dbOptions.includes(options.database)) {
+                console.log(chalk.red(`Invalid database value, must be either of these: ${dbOptions.join(", ")} `));
+                return;
+            }
+            config.database = options.database;
+            writeConfig(config);
+            console.log(chalk.cyan(`Default project database is now ${chalk.bold(config.database)}`));
+            return;
+        }
+        // validate generateFolder
+        if (options.generateFolder) {
+            if (options.generateFolder !== "true" &&
+                options.generateFolder !== "false") {
+                console.log(chalk.red(`Invalid folder generation value, value must be ${chalk.bold("true")} or ${chalk.bold("false")}`));
+                return;
+            }
+            config.generateFolder = options.generateFolder;
+            writeConfig(config);
+            console.log(chalk.cyan(`Generation of folder files for the Services, Models, Controllers and Routes  set to ${chalk.bold(config.generateFolder)}`));
+            return;
+        }
+        if (Object.keys(options).length === 0) {
+            console.log(chalk.yellow(chalk.bold(`No configurations applied, run ${chalk.white("dolph-cli config --help")} to see available commands`)));
+        }
+    });
+};

package/dist/utils/read_user_config_path.js

@@ -0,0 +1,19 @@
+import chalk from "chalk";
+import { getUserConfigFilePath } from "./get_user_config_path.js";
+import { readFileSync } from "fs";
+import yaml from "js-yaml";
+const filePath = getUserConfigFilePath();
+export const readConfig = () => {
+    try {
+        const data = readFileSync(filePath, "utf8");
+        const yamlData = yaml.load(data);
+        const jsonData = JSON.stringify(yamlData);
+        return JSON.parse(jsonData.toString());
+    }
+    catch (e) {
+        console.log(e);
+        console.log(chalk.bold(chalk.red("Error encountered reading config file, please run 'dolph-cli tr' to initialize config file 🥹")));
+        process.exit(1);
+        return {};
+    }
+};

package/dist/utils/write_dolph_config.js

@@ -0,0 +1,9 @@
+import * as fs from "fs";
+import { getRootDirectory } from "./get_root_dir_path.js";
+import { join } from "path";
+export function writeDolphConfig() {
+    const dolphConfigContent = `port: 3300    
+`;
+    const filePath = join(getRootDirectory(), "dolph_config.yaml");
+    fs.writeFileSync(filePath, dolphConfigContent, { encoding: "utf-8" });
+}

package/dist/utils/write_gitignore.js

@@ -0,0 +1,12 @@
+import * as fs from "fs";
+import { getRootDirectory } from "./get_root_dir_path.js";
+import { join } from "path";
+export function writeGitignore() {
+    const gitignoreContent = `node_modules
+.env
+logs
+yarn-error.log
+`;
+    const filePath = join(getRootDirectory(), ".gitignore");
+    fs.writeFileSync(filePath, gitignoreContent, { encoding: "utf-8" });
+}

package/dist/utils/write_package_json.js

@@ -0,0 +1,68 @@
+import * as fs from "fs";
+import { join } from "path";
+import { getRootDirectory } from "./get_root_dir_path.js";
+export function writePackageJsonFile(name, extension) {
+    const packageJsonContent = extension === "ts"
+        ? `{
+  "name": "${name}",
+  "version": "1.0.0",
+  "main": "app/server.js",
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "dev:start": "cross-env NODE_ENV=development nodemon",
+    "dev:docker:start": "docker-compose -f docker-compose-dev.yml up",
+    "dev:docker:stop": "docker-compose -f docker-compose-dev.yml down",
+    "build": "swc src -d app --source-maps --copy-files",
+    "build:tsc": "tsc && tsc-alias",
+    "prod:start": "node app/server.js",
+    "clean": "rm -r app && rm -r logs",
+    "start": "npm run build && npm run prod:start"
+  },
+  "dependencies": {
+    "@dolphjs/dolph": "^1.1.0"
+  },
+  "devDependencies": {
+    "@swc/cli": "^0.1.62",
+    "@swc/core": "^1.3.91",
+    "@types/express": "^4.17.18",
+    "@types/node": "^20.8.2",
+    "cross-env": "^7.0.3",
+    "ts-node": "^10.9.1",
+    "tsc-alias": "^1.8.8",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.2.2"
+  }
+}
+`
+        : `{
+  "name": "${name}",
+  "version": "1.0.0",
+  "main": "src/server.js",
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "dev:start": "cross-env NODE_ENV=development nodemon",
+    "dev:docker:start": "docker-compose -f docker-compose-dev.yml up",
+    "dev:docker:stop": "docker-compose -f docker-compose-dev.yml down",
+    "prod:start": "node src/server.js",
+    "clean": "rm -r logs",
+    "start": "npm run prod:start"
+  },
+  "dependencies": {
+    "@dolphjs/dolph": "^1.1.0"
+  },
+  "devDependencies": {
+    "cross-env": "^7.0.3"
+  }
+}
+`;
+    const filePath = join(getRootDirectory(), "package.json");
+    fs.writeFileSync(filePath, packageJsonContent, { encoding: "utf-8" });
+}

package/dist/utils/write_swrcc.js

@@ -0,0 +1,48 @@
+import * as fs from "fs";
+import { getRootDirectory } from "./get_root_dir_path.js";
+import { join } from "path";
+export function writeSwcrc() {
+    const swcrcContent = `{
+  "jsc": {
+    "parser": {
+      "syntax": "typescript",
+      "tsx": false,
+      "dynamicImport": true,
+      "decorators": true
+    },
+    "transform": {
+      "legacyDecorator": true,
+      "decoratorMetadata": true
+    },
+    "target": "es2022",
+    "externalHelpers": false,
+    "keepClassNames": true,
+    "loose": false,
+    "minify": {
+      "compress": false,
+      "mangle": false
+    },
+    "baseUrl": "src",
+    "paths": {
+      "@/*": ["*"],
+      "@/configs/*": ["configs/*"],
+      "@/controllers/*": ["controllers/*"],
+      "@/dtos/*": ["dtos/*"],
+      "@/interfaces/*": ["interfaces/*"],
+      "@/middlewares/*": ["middlewares/*"],
+      "@/models/*": ["models/*"],
+      "@/routes/*": ["routes/*"],
+      "@/services/*": ["services/*"],
+      "@/utils/*": ["utils/*"],
+      "@/constants/*": ["constants/*"],
+      "@/validations/*": ["validations/*"]
+    }
+  },
+  "module": {
+    "type": "commonjs"
+  }
+}    
+`;
+    const filePath = join(getRootDirectory(), ".swcrc");
+    fs.writeFileSync(filePath, swcrcContent, { encoding: "utf-8" });
+}

package/dist/utils/write_tsconfig.js

@@ -0,0 +1,45 @@
+import * as fs from "fs";
+import { getRootDirectory } from "./get_root_dir_path.js";
+import { join } from "path";
+export function writeTsConfigFile() {
+    const tsConfigContent = `{
+  "exclude": ["node_modules"],
+  "compilerOptions": {
+    "allowJs": false,
+    "declaration": false,
+    "experimentalDecorators": true,
+    "sourceMap": false,
+    "useUnknownInCatchVariables": false,
+    "strictFunctionTypes": false,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "target": "ES2022",
+    "baseUrl": "src",
+    "outDir": "app",
+    "pretty": true,
+    "module": "commonjs",
+    "paths": {
+      "@/*": ["*"],
+      "@/configs/*": ["configs/*"],
+      "@/controllers/*": ["controllers/*"],
+      "@/dtos/*": ["dtos/*"],
+      "@/interfaces/*": ["interfaces/*"],
+      "@/middlewares/*": ["middlewares/*"],
+      "@/models/*": ["models/*"],
+      "@/routes/*": ["routes/*"],
+      "@/services/*": ["services/*"],
+      "@/utils/*": ["utils/*"],
+      "@/constants/*": ["constants/*"],
+    }
+  },
+  "include": ["src/", ".env"],
+  "ts-node": {
+    "compilerOptions": {
+      "module": "CommonJS"
+    }
+  }
+}`;
+    const filePath = join(getRootDirectory(), "tsconfig.json");
+    fs.writeFileSync(filePath, tsConfigContent, { encoding: "utf-8" });
+}

package/dist/utils/write_user_config.js

@@ -0,0 +1,16 @@
+import chalk from "chalk";
+import yaml from "js-yaml";
+import { getUserConfigFilePath } from "./get_user_config_path.js";
+import { writeFileSync } from "fs";
+const filePath = getUserConfigFilePath();
+export const writeConfig = (config) => {
+    try {
+        const yamlString = yaml.dump(config);
+        writeFileSync(filePath, yamlString, "utf8");
+        console.log(chalk.green("Configurations saved successfully! 😎."));
+    }
+    catch (e) {
+        console.log(chalk.bold(chalk.red("Error encountered reading config file, please run 'dolph-cli tr' to initialize config file 🥹")));
+        process.exit(1);
+    }
+};