@expressots/cli 1.4.0 → 1.6.0

package/bin/@types/config.d.ts

@@ -4,6 +4,14 @@ export declare const enum Pattern {
     PASCAL_CASE = "PascalCase",
     CAMEL_CASE = "camelCase"
 }
+interface IProviders {
+    prisma?: {
+        schemaName: string;
+        schemaPath: string;
+        entitiesPath: string;
+        entityNamePattern: string;
+    };
+}
 /**
  * The configuration object for the Expresso CLI.
  *
@@ -17,4 +25,6 @@ export interface ExpressoConfig {
     scaffoldPattern: Pattern;
     sourceRoot: string;
     opinionated: boolean;
+    providers?: IProviders;
 }
+export {};

package/bin/cli.js

@@ -7,14 +7,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CLI_VERSION = void 0;
 const yargs_1 = __importDefault(require("yargs"));
 const helpers_1 = require("yargs/helpers");
+const project_commands_1 = require("./commands/project.commands");
 const generate_1 = require("./generate");
 const info_1 = require("./info");
 const new_1 = require("./new");
+const providers_1 = require("./providers");
 exports.CLI_VERSION = "1.3.4";
 console.log(`\n[🐎 Expressots]\n`);
 (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
     .scriptName("expressots")
+    .command(project_commands_1.runCommandModule)
     .command((0, new_1.createProject)())
+    .command((0, providers_1.generateProviders)())
     .command((0, generate_1.generateProject)())
     .command((0, info_1.infoProject)())
     .example("$0 new expressots-demo", "Create interactively")

package/bin/commands/project.commands.d.ts

@@ -0,0 +1,8 @@
+import { CommandModule } from "yargs";
+export declare const runCommandModule: CommandModule<{}, {
+    command: string;
+}>;
+declare const runCommand: ({ command }: {
+    command: string;
+}) => Promise<void>;
+export { runCommand };

package/bin/commands/project.commands.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommand = exports.runCommandModule = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const compiler_1 = __importDefault(require("../utils/compiler"));
+/**
+ * Load the configuration from the compiler
+ * @param compiler The compiler to load the configuration from
+ * @returns The configuration
+ */
+const opinionatedConfig = [
+    "--transpile-only",
+    "-r",
+    "dotenv/config",
+    "-r",
+    "tsconfig-paths/register",
+    "./src/main.ts",
+];
+const nonOpinionatedConfig = [
+    "--transpile-only",
+    "-r",
+    "dotenv/config",
+    "./src/main.ts",
+];
+/**
+ * Helper function to execute a command
+ * @param command The command to execute
+ * @param args The arguments to pass to the command
+ * @param cwd The current working directory to execute the command in
+ * @returns A promise that resolves when the command completes successfully
+ */
+function execCmd(command, args, cwd = process.cwd()) {
+    return new Promise((resolve, reject) => {
+        const proc = (0, child_process_1.spawn)(command, args, {
+            stdio: "inherit",
+            shell: true,
+            cwd,
+        });
+        proc.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`Command failed with code ${code}`));
+            }
+        });
+    });
+}
+// Helper to delete the dist directory
+const cleanDist = async () => {
+    await fs_1.promises.rm("./dist", { recursive: true, force: true });
+};
+// Helper to compile TypeScript
+const compileTypescript = async () => {
+    await execCmd("npx", ["tsc", "-p", "tsconfig.build.json"]);
+};
+// Helper to copy files
+const copyFiles = async () => {
+    const { opinionated } = await compiler_1.default.loadConfig();
+    let filesToCopy = [];
+    if (opinionated) {
+        filesToCopy = [
+            "./register-path.js",
+            "tsconfig.build.json",
+            "package.json",
+        ];
+    }
+    else {
+        filesToCopy = ["tsconfig.json", "package.json"];
+    }
+    filesToCopy.forEach((file) => {
+        fs_1.promises.copyFile(file, path_1.default.join("./dist", path_1.default.basename(file)));
+    });
+};
+// eslint-disable-next-line @typescript-eslint/ban-types
+exports.runCommandModule = {
+    command: "run <command>",
+    describe: "Runs a specified command (dev, build, prod)",
+    builder: (yargs) => {
+        return yargs.positional("command", {
+            describe: "The command to run",
+            type: "string",
+            choices: ["dev", "build", "prod"],
+        });
+    },
+    handler: async (argv) => {
+        const { command } = argv;
+        // Now call your original runCommand function with the command
+        // Ensure runCommand is properly defined to handle these commands
+        await runCommand({ command });
+    },
+};
+const runCommand = async ({ command }) => {
+    const { opinionated } = await compiler_1.default.loadConfig();
+    try {
+        switch (command) {
+            case "dev":
+                // Use execSync or spawn to run ts-node-dev programmatically
+                execCmd("tsnd", opinionated ? opinionatedConfig : nonOpinionatedConfig);
+                break;
+            case "build":
+                await cleanDist();
+                await compileTypescript();
+                await copyFiles();
+                break;
+            case "prod":
+                let config = [];
+                if (opinionated) {
+                    config = [
+                        "-r",
+                        "dotenv/config",
+                        "-r",
+                        "./dist/register-path.js",
+                        "./dist/src/main.js",
+                    ];
+                }
+                else {
+                    config = ["-r", "dotenv/config", "./dist/main.js"];
+                }
+                // Ensure environment variables are set
+                execCmd("node", config);
+                break;
+            default:
+                console.log(`Unknown command: ${command}`);
+        }
+    }
+    catch (error) {
+        console.error("Error executing command:", error);
+    }
+};
+exports.runCommand = runCommand;

package/bin/generate/cli.js

@@ -16,8 +16,10 @@ const coerceSchematicAliases = (arg) => {
             return "provider";
         case "e":
             return "entity";
-        case "m":
+        case "mo":
             return "module";
+        case "m":
+            return "middleware";
         default:
             return arg;
     }
@@ -37,6 +39,7 @@ const generateProject = () => {
                     "provider",
                     "entity",
                     "module",
+                    "middleware",
                 ],
                 describe: "The schematic to generate",
                 type: "string",

package/bin/generate/form.js

@@ -271,7 +271,6 @@ const splitTarget = async ({ target, schematic, }) => {
     if (target.includes("/") ||
         target.includes("\\") ||
         target.includes("//")) {
-        //pathContent = target.split("/").filter((item) => item !== "");
         if (schematic === "service")
             schematic = "controller";
         if (schematic === "service" ||
@@ -366,6 +365,10 @@ const schematicFolder = (schematic) => {
             return "providers";
         case "entity":
             return "entities";
+        case "middleware":
+            return "providers/middlewares";
+        case "module":
+            return "useCases";
     }
     return undefined;
 };

package/bin/generate/templates/middleware.tpl

@@ -0,0 +1,10 @@
+import { ExpressoMiddleware } from "@expressots/core";
+import { NextFunction, Request, Response } from "express";
+import { provide } from "inversify-binding-decorators";
+
+@provide({{className}}Middleware)
+export class {{className}}Middleware extends ExpressoMiddleware {
+    use(req: Request, res: Response, next: NextFunction): void | Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+}

package/bin/generate/templates/module-default.tpl

@@ -1,3 +1,4 @@
+import { ContainerModule } from "inversify";
 import { CreateModule } from "@expressots/core";
 
-export const {{moduleName}}Module = CreateModule([]);
+export const {{moduleName}}Module: ContainerModule = CreateModule([]);

package/bin/generate/templates/module.tpl

@@ -1,4 +1,5 @@
+import { ContainerModule } from "inversify";
 import { CreateModule } from "@expressots/core";
 import { {{className}}Controller } from "{{{path}}}";
 
-export const {{moduleName}}Module = CreateModule([{{className}}Controller]);
+export const {{moduleName}}Module: ContainerModule = CreateModule([{{className}}Controller]);

package/bin/new/cli.d.ts

@@ -1,4 +1,4 @@
 import { CommandModule } from "yargs";
-type CommandModuleArgs = {};
+type CommandModuleArgs = object;
 declare const createProject: () => CommandModule<CommandModuleArgs, any>;
 export { createProject };

package/bin/new/cli.js

@@ -2,41 +2,43 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createProject = void 0;
 const form_1 = require("./form");
+const packageManagers = [
+    "npm",
+    "yarn",
+    "pnpm",
+    ...(process.platform !== "win32" ? ["bun"] : []),
+];
+const commandOptions = (yargs) => {
+    return yargs
+        .positional("project-name", {
+        describe: "The name of the project",
+        type: "string",
+    })
+        .option("template", {
+        describe: "The project template to use",
+        type: "string",
+        choices: ["opinionated", "non-opinionated"],
+        alias: "t",
+    })
+        .option("package-manager", {
+        describe: "The package manager to use",
+        type: "string",
+        choices: packageManagers,
+        alias: "p",
+    })
+        .option("directory", {
+        describe: "The directory for new project",
+        type: "string",
+        alias: "d",
+    })
+        .implies("package-manager", "template")
+        .implies("template", "package-manager");
+};
 const createProject = () => {
-    const packageManagers = ["npm", "yarn", "pnpm"];
-    if (process.platform !== "win32") {
-        packageManagers.push("bun");
-    }
     return {
         command: "new <project-name> [package-manager] [template] [directory]",
         describe: "Create a new project",
-        builder: (yargs) => {
-            yargs
-                .positional("project-name", {
-                describe: "The name of the project",
-                type: "string",
-            })
-                .option("template", {
-                describe: "The project template to use",
-                type: "string",
-                choices: ["non-opinionated", "opinionated"],
-                alias: "t",
-            })
-                .option("package-manager", {
-                describe: "The package manager to use",
-                type: "string",
-                choices: packageManagers,
-                alias: "p",
-            })
-                .option("directory", {
-                describe: "The directory for new project",
-                type: "string",
-                alias: "d",
-            })
-                .implies("package-manager", "template")
-                .implies("template", "package-manager");
-            return yargs;
-        },
+        builder: commandOptions,
         handler: async ({ projectName, packageManager, template, directory, }) => {
             return await (0, form_1.projectForm)(projectName, [
                 packageManager,

package/bin/new/form.js

@@ -61,8 +61,8 @@ function changePackageName({ directory, name, }) {
 }
 var Template;
 (function (Template) {
-    Template["non-opinionated"] = "Non-Opinionated :: A simple ExpressoTS project.";
-    Template["opinionated"] = "Opinionated :: A complete ExpressoTS project with an opinionated structure and features.";
+    Template["non-opinionated"] = "Non-Opinionated :: Allows users to choose where to scaffold resources, offering flexible project organization.";
+    Template["opinionated"] = "Opinionated :: Automatically scaffolds resources into a preset project structure. (Recommended)";
 })(Template || (Template = {}));
 const projectForm = async (projectName, args) => {
     let answer;
@@ -117,8 +117,8 @@ const projectForm = async (projectName, args) => {
                 name: "template",
                 message: "Select a template",
                 choices: [
-                    "Non-Opinionated :: A simple ExpressoTS project.",
-                    "Opinionated :: A complete ExpressoTS project with an opinionated structure and features.",
+                    `Opinionated :: Automatically scaffolds resources into a preset project structure. (${chalk_1.default.yellow("Recommended")})`,
+                    "Non-Opinionated :: Allows users to choose where to scaffold resources, offering flexible project organization.",
                 ],
             },
             {
@@ -185,7 +185,7 @@ const projectForm = async (projectName, args) => {
         progressBar.update(100);
         progressBar.stop();
         console.log("\n");
-        console.log("🐎 Project ", chalk_1.default.green(answer.name), "created successfully!");
+        console.log("🐎 Project", chalk_1.default.green(answer.name), "created successfully!");
         console.log("🤙 Run the following commands to start the project:\n");
         console.log(chalk_1.default.bold.gray(`$ cd ${answer.name}`));
         switch (answer.packageManager) {
@@ -206,6 +206,7 @@ const projectForm = async (projectName, args) => {
         console.log(chalk_1.default.bold.green((0, center_text_1.centerText)("Happy coding!")));
         console.log(chalk_1.default.bold.gray((0, center_text_1.centerText)("Please consider donating to support the project.\n")));
         console.log(chalk_1.default.bold.white((0, center_text_1.centerText)("💖 Sponsor: https://github.com/sponsors/expressots")));
+        console.log("\n");
     }
 };
 exports.projectForm = projectForm;

package/bin/providers/cli.d.ts

@@ -0,0 +1,4 @@
+import { CommandModule } from "yargs";
+type CommandModuleArgs = {};
+declare const generateProviders: () => CommandModule<CommandModuleArgs, any>;
+export { generateProviders };

package/bin/providers/cli.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateProviders = void 0;
+const prisma_provider_1 = require("./prisma/prisma.provider");
+const generateProviders = () => {
+    return {
+        command: "add <provider> [library-version] [provider-version]",
+        describe: "Scaffold a new provider",
+        aliases: ["a"],
+        builder: (yargs) => {
+            yargs
+                .positional("provider", {
+                choices: ["prisma"],
+                describe: "The provider to add to the project",
+                type: "string",
+            })
+                .option("library-version", {
+                describe: "The library version to install",
+                type: "string",
+                default: "latest",
+                alias: "v",
+            })
+                .option("provider-version", {
+                describe: "The version of the provider to install",
+                type: "string",
+                default: "latest",
+                alias: "vp",
+            });
+            return yargs;
+        },
+        handler: async ({ provider, libraryVersion, providerVersion }) => {
+            if (provider === "prisma") {
+                await (0, prisma_provider_1.prismaProvider)(libraryVersion, providerVersion);
+            }
+        },
+    };
+};
+exports.generateProviders = generateProviders;

package/bin/providers/index.d.ts

@@ -0,0 +1 @@
+export * from "./cli";

package/bin/providers/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cli"), exports);

package/bin/providers/prisma/prisma.provider.d.ts

@@ -0,0 +1,2 @@
+declare const prismaProvider: (version: string, providerVersion: string) => Promise<void>;
+export { prismaProvider };

package/bin/providers/prisma/prisma.provider.js

@@ -0,0 +1,277 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prismaProvider = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const cli_ui_1 = require("../../utils/cli-ui");
+const node_path_1 = __importDefault(require("node:path"));
+const node_process_1 = require("node:process");
+const compiler_1 = __importDefault(require("../../utils/compiler"));
+const find_folder_1 = require("../../utils/find-folder");
+const prismaProvider = async (version, providerVersion) => {
+    var _a;
+    const choices = [
+        { name: "CockroachDB", value: "cockroachdb" },
+        { name: "Microsoft SQL Server", value: "sqlserver" },
+        { name: "MongoDB", value: "mongodb" },
+        { name: "MySQL", value: "mysql" },
+        { name: "PostgreSQL", value: "postgresql" },
+        { name: "SQLite", value: "sqlite" },
+    ];
+    const drivers = {
+        PostgreSQL: "pg",
+        MySQL: "mysql2",
+        SQLite: "sqlite3",
+        "Microsoft SQL Server": "mssql",
+        MongoDB: "mongodb",
+        CockroachDB: "pg",
+    };
+    const answerPt1 = await inquirer_1.default.prompt([
+        {
+            type: "input",
+            name: "prismaClientVersion",
+            message: "Type the prisma client version (default=latest):",
+            default: "latest",
+            transformer: (input) => {
+                return chalk_1.default.yellow(chalk_1.default.bold(input));
+            },
+        },
+        {
+            type: "input",
+            name: "schemaName",
+            message: "Type the schema name (default=schema):",
+            default: "schema",
+            transformer: (input) => {
+                return chalk_1.default.yellow(chalk_1.default.bold(input));
+            },
+        },
+        {
+            type: "input",
+            name: "schemaPath",
+            message: "Where do you want to save your prisma schema (default=./):",
+            default: ".",
+            transformer: (input) => {
+                return chalk_1.default.yellow(chalk_1.default.bold(input));
+            },
+        },
+        {
+            type: "list",
+            name: "databaseName",
+            message: "Select your database:",
+            choices: choices.map((choice) => choice.name),
+        },
+    ]);
+    const answerPt2 = await inquirer_1.default.prompt([
+        {
+            type: "confirm",
+            name: "installDriver",
+            message: `Do you want to install the latest recommended database driver for ${answerPt1.databaseName}?`,
+            default: true,
+        },
+        {
+            type: "confirm",
+            name: "baseRepository",
+            message: "Do you want to add BaseRepository Pattern in this project?\nthis will replace the existing BaseRepository and BaseRespositoryInterface if it exists.",
+            default: true,
+        },
+        {
+            type: "confirm",
+            name: "confirm",
+            message: "Do you want to add prisma provider in this project?",
+            default: true,
+        },
+    ]);
+    const answer = Object.assign(Object.assign({}, answerPt1), answerPt2);
+    if (answer.confirm) {
+        // Find which package manager the user has used to install the desired prisma version
+        const packageManager = node_fs_1.default.existsSync("package-lock.json" || "yarn.lock" || "pnpm-lock.yaml")
+            ? "npm"
+            : node_fs_1.default.existsSync("yarn.lock")
+                ? "yarn"
+                : node_fs_1.default.existsSync("pnpm-lock.yaml")
+                    ? "pnpm"
+                    : null;
+        if (packageManager) {
+            // Install prisma in the project
+            console.log(`Installing prisma with ${packageManager}...`);
+            await execProcess({
+                commandArg: packageManager,
+                args: ["add", `prisma@${providerVersion}`, "-D"],
+                directory: process.cwd(),
+            });
+            // Install Prisma Client
+            console.log(`Installing Prisma Client with ${packageManager}...`);
+            await execProcess({
+                commandArg: packageManager,
+                args: ["add", `@prisma/client@${answer.prismaClientVersion}`],
+                directory: process.cwd(),
+            });
+            if (answer.installDriver) {
+                // Install database driver
+                console.log(`Installing the latest recommended database driver for ${answer.databaseName}: ${drivers[answer.databaseName]} ...`);
+                await execProcess({
+                    commandArg: packageManager,
+                    args: ["add", drivers[answer.databaseName]],
+                    directory: process.cwd(),
+                });
+            }
+            // Install @expressots/prisma in the project
+            console.log(`Installing @expressots/prisma with ${packageManager}...`);
+            await execProcess({
+                commandArg: packageManager,
+                args: ["add", `@expressots/prisma@${version}`],
+                directory: process.cwd(),
+            });
+        }
+        else {
+            (0, cli_ui_1.printError)(`Could not find a package manager installed in this project.\nPlease install prisma and @expressots/prisma manually.`, "prisma");
+            process.exit(1);
+        }
+        // Map choices to find the corresponding value
+        answer.databaseName = (_a = choices.find((choice) => choice.name === answer.databaseName)) === null || _a === void 0 ? void 0 : _a.value;
+        // Init prisma
+        console.log(`Initializing prisma...`);
+        const prismaFolder = (0, find_folder_1.hasFolder)(process.cwd(), ["node_modules", ".git"]);
+        if (prismaFolder.found) {
+            const prismaEnquirer = await inquirer_1.default.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: "Prisma is already initialized. Do you want to override it?",
+                    default: true,
+                },
+            ]);
+            if ((prismaEnquirer === null || prismaEnquirer === void 0 ? void 0 : prismaEnquirer.confirm) === false) {
+                console.log(chalk_1.default.red("Prisma init aborted!"));
+                return;
+            }
+            node_fs_1.default.rmSync(prismaFolder.path, {
+                recursive: true,
+                force: true,
+            });
+        }
+        await execProcess({
+            commandArg: "npx",
+            args: [
+                "prisma",
+                "init",
+                "--datasource-provider",
+                answer.databaseName,
+            ],
+            directory: process.cwd(),
+        });
+        const oldFileName = node_path_1.default.join(process.cwd(), "/prisma/schema.prisma");
+        const newFileName = node_path_1.default.join(process.cwd(), `/prisma/${answer.schemaName}.prisma`);
+        node_fs_1.default.renameSync(oldFileName, newFileName);
+        // Move the folder to the destination
+        const schemaPath = node_path_1.default.join(process.cwd(), `${answer.schemaPath}/prisma/${answer.schemaName}.prisma`);
+        if (!node_fs_1.default.existsSync(schemaPath)) {
+            node_fs_1.default.mkdirSync(node_path_1.default.join(process.cwd(), `${answer.schemaPath}/prisma`), { recursive: true });
+        }
+        node_fs_1.default.renameSync(newFileName, schemaPath);
+        // Remove the source folder
+        if (newFileName !== schemaPath) {
+            node_fs_1.default.rmSync(node_path_1.default.join(process.cwd(), "/prisma"), { recursive: true });
+        }
+        // Add prisma to package.json
+        prismaPackage(answer);
+        if (answer.baseRepository) {
+            const { opinionated, sourceRoot } = await compiler_1.default.loadConfig();
+            let folderMatch = "";
+            if (opinionated) {
+                folderMatch = "repositories";
+            }
+            else {
+                folderMatch = "";
+            }
+            const repositoryDir = `${sourceRoot}/${folderMatch}`;
+            console.log(`Generating BaseRepository Pattern...`);
+            const baseRepositoryInterfaceTplPath = node_path_1.default.join(__dirname, "./templates/base-repository.interface.tpl");
+            const baseRepositoryTplPath = node_path_1.default.join(__dirname, "./templates/base-repository.tpl");
+            const baseRepositoryInterfaceTemplate = node_fs_1.default.readFileSync(baseRepositoryInterfaceTplPath, "utf8");
+            const baseRepositoryTemplate = node_fs_1.default.readFileSync(baseRepositoryTplPath, "utf8");
+            node_fs_1.default.writeFileSync(node_path_1.default.join(repositoryDir, "base-repository.interface.ts"), baseRepositoryInterfaceTemplate);
+            node_fs_1.default.writeFileSync(node_path_1.default.join(repositoryDir, "base-repository.ts"), baseRepositoryTemplate);
+        }
+        // Install @expressots/prisma in the project
+        console.log(`Mapping configurations to expressots.config...`);
+        await addProviderConfigInExpressotsConfig(answer.schemaName, `${answer.schemaPath}/prisma`);
+        console.log("Now configure your database connection in the project.");
+        console.log(chalk_1.default.green("\n👍 Prisma provider added successfully!"));
+    }
+    else {
+        console.log(chalk_1.default.red("Prisma provider not added!"));
+    }
+};
+exports.prismaProvider = prismaProvider;
+async function execProcess({ commandArg, args, directory, }) {
+    return new Promise((resolve, reject) => {
+        const isWindows = process.platform === "win32";
+        const command = isWindows ? `${commandArg}.cmd` : commandArg;
+        const installProcess = (0, node_child_process_1.spawn)(command, args, {
+            cwd: directory,
+        });
+        console.log(chalk_1.default.bold.blue(`Executing: ${command} ${args.join(" ")}`));
+        console.log(chalk_1.default.yellow("---------------------------------------"));
+        installProcess.stdout.on("data", (data) => {
+            console.log(chalk_1.default.green(data.toString().trim())); // Display regular messages in green
+        });
+        installProcess.stderr.on("data", (data) => {
+            console.error(chalk_1.default.red(data.toString().trim())); // Display error messages in red
+        });
+        installProcess.on("close", (code) => {
+            if (code === 0) {
+                console.log(chalk_1.default.bold.green("---------------------------------------"));
+                console.log(chalk_1.default.bold.green("Installation Done!"));
+                resolve("Installation Done!");
+            }
+            else {
+                console.error(chalk_1.default.bold.red("---------------------------------------"));
+                console.error(chalk_1.default.bold.red(`Command ${command} ${args.join(" ")} exited with code ${code}`));
+                reject(new Error(`Command ${command} ${args.join(" ")} exited with code ${code}`));
+                (0, node_process_1.exit)(1);
+            }
+        });
+    });
+}
+function prismaPackage(answer) {
+    // Get the absolute path of the input directory parameter
+    const absDirPath = node_path_1.default.resolve(process.cwd());
+    // Load the package.json file
+    const packageJsonPath = node_path_1.default.join(absDirPath, "package.json");
+    const fileContents = node_fs_1.default.readFileSync(packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(fileContents);
+    // Add the Prisma configuration to the package.json
+    packageJson.prisma = {
+        schema: `${answer.schemaPath}/prisma/${answer.schemaName}.prisma`,
+    };
+    // Add the Prisma script to the package.json
+    packageJson.scripts = Object.assign(Object.assign({}, packageJson.scripts), { prisma: "npx @expressots/prisma codegen" });
+    // Save the package.json file
+    node_fs_1.default.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+}
+async function addProviderConfigInExpressotsConfig(schemaName, schemaPath) {
+    const absDirPath = node_path_1.default.resolve(process.cwd());
+    const expressotsConfigPath = node_path_1.default.join(absDirPath, "expressots.config.ts");
+    let fileContents = node_fs_1.default.readFileSync(expressotsConfigPath, "utf-8");
+    const config = await compiler_1.default.loadConfig();
+    const providersObject = `opinionated: ${config.opinionated},\n\tproviders: {
+		prisma: {
+			schemaName: "${schemaName}",
+			schemaPath: "${schemaPath}",
+			entitiesPath: "entities",
+			entityNamePattern: "entity",
+		},
+	},`;
+    if (config.providers) {
+        // delete the providers object until the last closing curly brace
+        fileContents = fileContents.replace(/\n([\s]*?)providers: {([\s\S]*?)};/, "\n};");
+    }
+    const newFileContents = fileContents.replace(/opinionated: (.*)/, providersObject);
+    node_fs_1.default.writeFileSync(expressotsConfigPath, newFileContents);
+}

package/bin/providers/prisma/templates/base-repository.interface.tpl

@@ -0,0 +1,57 @@
+import { Prisma, PrismaClient } from "@prisma/client";
+import {
+    CreateInput,
+    ModelsOf,
+    DeleteWhere,
+    Select,
+    PrismaAction,
+} from "@expressots/prisma";
+
+interface IBaseRepository<ModelName extends ModelsOf<PrismaClient>> {
+    aggregate: (args: PrismaAction<ModelName, "aggregate">) => Promise<any>;
+    count: (args: PrismaAction<ModelName, "count">) => Promise<number>;
+    create: (
+        data:
+            | CreateInput<ModelName>["data"]
+            | {
+                  data: CreateInput<ModelName>["data"];
+                  select?: Select<ModelName, "create">["select"];
+              },
+    ) => Promise<ModelName | never>;
+    delete: (
+        where: DeleteWhere<ModelName>["where"],
+        response?: Select<ModelName, "delete">["select"],
+    ) => Promise<ModelName | never>;
+    deleteMany: (
+        args?: PrismaAction<ModelName, "deleteMany">,
+    ) => Promise<Prisma.BatchPayload>;
+    findFirst: (
+        args: PrismaAction<ModelName, "findFirst">,
+    ) => Promise<ModelName | null>;
+    findFirstOrThrow: (
+        args?: PrismaAction<ModelName, "findFirstOrThrow">,
+    ) => Promise<ModelName | never>;
+    findMany: (
+        args: PrismaAction<ModelName, "findMany">,
+    ) => Promise<ModelName[]>;
+    findUnique: (
+        args: PrismaAction<ModelName, "findUnique">,
+    ) => Promise<ModelName | null>;
+    findUniqueOrThrow: (
+        args?: PrismaAction<ModelName, "findFirstOrThrow">,
+    ) => Promise<ModelName | never>;
+    groupBy: (
+        args: PrismaAction<ModelName, "groupBy">,
+    ) => Promise<ModelName | never>;
+    update: (
+        args: PrismaAction<ModelName, "update">,
+    ) => Promise<ModelName | never>;
+    updateMany: (
+        args: PrismaAction<ModelName, "updateMany">,
+    ) => Promise<Prisma.BatchPayload>;
+    upsert: (
+        args: PrismaAction<ModelName, "upsert">,
+    ) => Promise<ModelName | never>;
+}
+
+export { IBaseRepository };

package/bin/providers/prisma/templates/base-repository.tpl

@@ -0,0 +1,146 @@
+import { PrismaClient, Prisma } from "@prisma/client";
+import {
+    CreateInput,
+    ModelsOf,
+    DeleteWhere,
+    Select,
+    PrismaAction,
+} from "@expressots/prisma";
+import { provide } from "inversify-binding-decorators";
+import { IBaseRepository } from "./base-repository.interface";
+
+@provide(BaseRepository)
+class BaseRepository<ModelName extends ModelsOf<PrismaClient>>
+    implements IBaseRepository<ModelName>
+{
+    protected prismaModel: any;
+    protected prismaClient: PrismaClient;
+    constructor(modelName: keyof PrismaClient) {
+        this.prismaClient = new PrismaClient();
+        this.prismaModel = this.prismaClient[modelName];
+    }
+
+    async aggregate(args: PrismaAction<ModelName, "aggregate">): Promise<any> {
+        return await this.prismaModel.aggregate(args);
+    }
+
+    async count(args: PrismaAction<ModelName, "count">): Promise<number> {
+        return await this.prismaModel.count(args);
+    }
+
+    async create(
+        data:
+            | CreateInput<ModelName>["data"]
+            | {
+                  data: CreateInput<ModelName>["data"];
+                  select?: Select<ModelName, "create">["select"];
+              },
+    ): Promise<ModelName | never> {
+        if (!data) {
+            throw new Error("Data cannot be null or undefined");
+        }
+
+        if (typeof data === "object" && "data" in data) {
+            return await this.prismaModel.create(data);
+        }
+
+        return await this.prismaModel.create({ data });
+    }
+
+    async delete(
+        where: DeleteWhere<ModelName>["where"],
+        select?: Select<ModelName, "delete">["select"],
+    ): Promise<ModelName | never> {
+        if (!where) {
+            throw new Error("Data cannot be null or undefined");
+        }
+
+        const obj = await this.prismaModel.delete({ where });
+
+        if (select) {
+            const entries = Object.entries(select);
+
+            const hasTrueField = entries.some(([, value]) => value);
+
+            if (hasTrueField) {
+                const result: any = {};
+                for (const [key, value] of entries) {
+                    if (value) {
+                        result[key] = obj[key as keyof typeof obj];
+                    }
+                }
+                return result as ModelName;
+            } else {
+                for (const [key, value] of entries) {
+                    if (!value) {
+                        delete obj[key as keyof typeof obj];
+                    }
+                }
+            }
+        }
+
+        return obj;
+    }
+
+    async deleteMany(
+        args?: PrismaAction<ModelName, "deleteMany">,
+    ): Promise<Prisma.BatchPayload> {
+        return await this.prismaModel.deleteMany(args);
+    }
+
+    async findFirst(
+        args?: PrismaAction<ModelName, "findFirst">,
+    ): Promise<ModelName | null> {
+        return await this.prismaModel.findFirst(args);
+    }
+
+    async findFirstOrThrow(
+        args?: PrismaAction<ModelName, "findFirstOrThrow">,
+    ): Promise<ModelName | never> {
+        return await this.prismaModel.findFirstOrThrow(args);
+    }
+
+    async findMany(
+        args: PrismaAction<ModelName, "findMany">,
+    ): Promise<ModelName[]> {
+        return await this.prismaModel.findMany(args);
+    }
+
+    async findUnique(
+        args: PrismaAction<ModelName, "findUnique">,
+    ): Promise<ModelName | null> {
+        return this.prismaModel.findUnique(args);
+    }
+
+    async findUniqueOrThrow(
+        args?: PrismaAction<ModelName, "findUniqueOrThrow">,
+    ): Promise<ModelName | never> {
+        return await this.prismaModel.findUniqueOrThrow(args);
+    }
+
+    async groupBy(
+        args: PrismaAction<ModelName, "groupBy">,
+    ): Promise<ModelName | never> {
+        return await this.prismaModel.groupBy(args);
+    }
+
+    async update(
+        args: PrismaAction<ModelName, "update">,
+    ): Promise<ModelName | never> {
+        return await this.prismaModel.update(args);
+    }
+
+    async updateMany(
+        args: PrismaAction<ModelName, "updateMany">,
+    ): Promise<Prisma.BatchPayload> {
+        return await this.prismaModel.updateMany(args);
+    }
+
+    async upsert(
+        args: PrismaAction<ModelName, "upsert">,
+    ): Promise<ModelName | never> {
+        return await this.prismaModel.upsert(args);
+    }
+}
+
+export { BaseRepository };

package/bin/utils/find-folder.d.ts

@@ -0,0 +1,5 @@
+declare function hasFolder(rootDir: string, ignoreList?: Array<string>): {
+    found: boolean;
+    path: string | null;
+};
+export { hasFolder };

package/bin/utils/find-folder.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasFolder = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function hasFolder(rootDir, ignoreList = []) {
+    function searchDir(directory) {
+        const files = fs_1.default.readdirSync(directory);
+        for (const file of files) {
+            if (ignoreList.includes(file))
+                continue; // Skip if the file/folder is in the ignore list
+            const filePath = path_1.default.join(directory, file);
+            const stats = fs_1.default.statSync(filePath);
+            if (stats.isDirectory()) {
+                if (file === "prisma") {
+                    return filePath; // Return full path of the 'prisma' folder
+                }
+                else {
+                    const result = searchDir(filePath); // Search inside other directories recursively
+                    if (result) {
+                        return result;
+                    }
+                }
+            }
+        }
+        return null; // 'prisma' folder was not found in this directory
+    }
+    const foundPath = searchDir(rootDir);
+    return {
+        found: !!foundPath,
+        path: foundPath,
+    };
+}
+exports.hasFolder = hasFolder;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@expressots/cli",
-	"version": "1.4.0",
+	"version": "1.6.0",
 	"description": "Expressots CLI - modern, fast, lightweight nodejs web framework (@cli)",
 	"author": "Richard Zampieri",
 	"license": "MIT",
@@ -36,7 +36,7 @@
 		"start": "node ./bin/cli.js",
 		"start:dev": "tsnd ./src/cli.ts",
 		"build": "npm run clean && tsc -p tsconfig.json && yarn cp:templates && chmod +x ./bin/cli.js",
-		"cp:templates": "cp -r ./src/generate/templates ./bin/generate/templates",
+		"cp:templates": "cp -r ./src/generate/templates ./bin/generate/templates && cp -r ./src/providers/prisma/templates ./bin/providers/prisma/templates",
 		"clean": "rimraf ./bin",
 		"format": "prettier --write \"./src/**/*.ts\" --cache",
 		"lint": "eslint \"./src/**/*.ts\"",
@@ -77,7 +77,8 @@
 		"husky": "^8.0.3",
 		"prettier": "^2.8.4",
 		"release-it": "^16.1.5",
-		"rimraf": "^4.1.2",
+		"rimraf": "^5.0.5",
+		"shx": "^0.3.4",
 		"ts-node-dev": "^2.0.0",
 		"typescript": "^4.9.5",
 		"vite": "^4.4.9",