@expressots/cli 1.3.4 → 1.5.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/app.container.js

@@ -6,4 +6,4 @@ const appContainer = new AppContainer();
 
 const container = appContainer.create([// Add your modules here, UserModule, UserModule, UserModule]);
 
-export { container };*/ 
+export { container };*/

package/bin/cli.js

@@ -10,11 +10,13 @@ const helpers_1 = require("yargs/helpers");
 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((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/generate/cli.js

@@ -16,6 +16,8 @@ const coerceSchematicAliases = (arg) => {
             return "provider";
         case "e":
             return "entity";
+        case "m":
+            return "module";
         default:
             return arg;
     }
@@ -34,6 +36,7 @@ const generateProject = () => {
                     "service",
                     "provider",
                     "entity",
+                    "module",
                 ],
                 describe: "The schematic to generate",
                 type: "string",
@@ -45,13 +48,7 @@ const generateProject = () => {
                 alias: "d",
             });
             yargs.positional("method", {
-                choices: [
-                    "get",
-                    "post",
-                    "put",
-                    "patch",
-                    "delete",
-                ],
+                choices: ["get", "post", "put", "patch", "delete"],
                 describe: "HTTP method",
                 type: "string",
                 alias: "m",

package/bin/generate/form.js

@@ -77,12 +77,17 @@ const createTemplate = async ({ schematic, path: target, method, }) => {
         else {
             routeSchema = path.replace(/\/$/, "");
         }
+        let templateBasedSchematic = schematic;
+        if (schematic === "module") {
+            templateBasedSchematic = "module-default";
+        }
         writeTemplate({
             outputPath: `${usecaseDir}/${path}/${file}`,
             template: {
-                path: `./templates/${schematic}.tpl`,
+                path: `./templates/${templateBasedSchematic}.tpl`,
                 data: {
                     className,
+                    moduleName: className,
                     route: routeSchema,
                     construct: (0, boost_ts_1.anyCaseToKebabCase)(className),
                     method: getHttpMethod(method),

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

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

package/bin/new/cli.js

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createProject = void 0;
 const form_1 = require("./form");
 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",
@@ -21,7 +25,7 @@ const createProject = () => {
                 .option("package-manager", {
                 describe: "The package manager to use",
                 type: "string",
-                choices: ["npm", "yarn", "pnpm"],
+                choices: packageManagers,
                 alias: "p",
             })
                 .option("directory", {
@@ -33,8 +37,12 @@ const createProject = () => {
                 .implies("template", "package-manager");
             return yargs;
         },
-        handler: async ({ projectName, packageManager, template, directory }) => {
-            return await (0, form_1.projectForm)(projectName, [packageManager, template, directory]);
+        handler: async ({ projectName, packageManager, template, directory, }) => {
+            return await (0, form_1.projectForm)(projectName, [
+                packageManager,
+                template,
+                directory,
+            ]);
         },
     };
 };

package/bin/new/form.js

@@ -73,7 +73,10 @@ const projectForm = async (projectName, args) => {
     // Resolving the argument order problem
     for (const arg of args) {
         if (args.length >= 3) {
-            if (arg === "npm" || arg === "yarn" || arg === "pnpm") {
+            if (arg === "npm" ||
+                arg === "yarn" ||
+                arg === "pnpm" ||
+                arg === "bun") {
                 packageManager = arg;
             }
             else if (arg === "non-opinionated" || arg === "opinionated") {
@@ -107,7 +110,7 @@ const projectForm = async (projectName, args) => {
                 type: "list",
                 name: "packageManager",
                 message: "Package manager",
-                choices: ["npm", "yarn", "pnpm"],
+                choices: ["npm", "yarn", "pnpm", "bun"],
             },
             {
                 type: "list",
@@ -141,10 +144,17 @@ const projectForm = async (projectName, args) => {
         Opinionated: "opinionated",
     };
     if (answer.confirm) {
+        // Check if package manager is bun and OS is Windows
+        if (answer.packageManager === "bun" && process.platform === "win32") {
+            (0, cli_ui_1.printError)("bun is not supported on Windows. Please use", "npm, yarn or pnpm");
+            process.exit(1);
+        }
         await checkIfPackageManagerExists(answer.packageManager);
         console.log("\n");
         const progressBar = new cli_progress_1.SingleBar({
-            format: "Progress |" + chalk_1.default.green("{bar}") + "| {percentage}% || {doing}",
+            format: "Progress |" +
+                chalk_1.default.green("{bar}") +
+                "| {percentage}% || {doing}",
             hideCursor: true,
         }, cli_progress_1.Presets.shades_classic);
         progressBar.start(100, 0, {
@@ -188,6 +198,9 @@ const projectForm = async (projectName, args) => {
             case "pnpm":
                 console.log(chalk_1.default.bold.gray("$ pnpm run dev"));
                 break;
+            case "bun":
+                console.log(chalk_1.default.bold.gray("$ bun dev"));
+                break;
         }
         console.log("\n");
         console.log(chalk_1.default.bold.green((0, center_text_1.centerText)("Happy coding!")));

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/add-controller-to-module.js

@@ -6,11 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.addControllerToModule = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
 async function addControllerToModule(filePath, controllerName, controllerPath) {
-    const fileContent = await node_fs_1.default.promises.readFile(filePath, 'utf8');
+    const fileContent = await node_fs_1.default.promises.readFile(filePath, "utf8");
     const imports = [];
     const notImports = [];
-    fileContent.split('\n').forEach((line) => {
-        if (line.startsWith('import')) {
+    fileContent.split("\n").forEach((line) => {
+        if (line.startsWith("import")) {
             imports.push(line);
         }
         else {
@@ -27,14 +27,20 @@ async function addControllerToModule(filePath, controllerName, controllerPath) {
     if (!moduleDeclarationMatch) {
         return;
     }
-    const controllers = moduleDeclarationMatch[1].trim().split(',').map((c) => c.trim()).filter((c) => c);
+    const controllers = moduleDeclarationMatch[1]
+        .trim()
+        .split(",")
+        .map((c) => c.trim())
+        .filter((c) => c);
     if (controllers.includes(controllerName)) {
         return;
     }
     controllers.push(controllerName);
-    const newControllers = controllers.join(', ');
+    const newControllers = controllers.join(", ");
     const newModuleDeclaration = `CreateModule([${newControllers}]`;
-    const newFileContent = [...imports, ...notImports].join('\n').replace(moduleDeclarationRegex, newModuleDeclaration);
-    await node_fs_1.default.promises.writeFile(filePath, newFileContent, 'utf8');
+    const newFileContent = [...imports, ...notImports]
+        .join("\n")
+        .replace(moduleDeclarationRegex, newModuleDeclaration);
+    await node_fs_1.default.promises.writeFile(filePath, newFileContent, "utf8");
 }
 exports.addControllerToModule = addControllerToModule;

package/bin/utils/add-module-to-container.js

@@ -14,14 +14,17 @@ async function validateAppContainer() {
     const { sourceRoot } = await compiler_1.default.loadConfig();
     const imports = [];
     const notImports = [];
-    const path = (0, glob_1.globSync)(`./${sourceRoot}/${APP_CONTAINER}`, { absolute: true, ignore: '**/node_modules/**' });
+    const path = (0, glob_1.globSync)(`./${sourceRoot}/${APP_CONTAINER}`, {
+        absolute: true,
+        ignore: "**/node_modules/**",
+    });
     if (!path.length) {
-        (0, cli_ui_1.printError)('Module not added to Container. Container file not found!', APP_CONTAINER);
+        (0, cli_ui_1.printError)("Module not added to Container. Container file not found!", APP_CONTAINER);
         process.exit(1);
     }
-    const fileContent = await node_fs_1.default.promises.readFile(path[0], 'utf8');
-    fileContent.split('\n').forEach((line) => {
-        if (line.startsWith('import')) {
+    const fileContent = await node_fs_1.default.promises.readFile(path[0], "utf8");
+    fileContent.split("\n").forEach((line) => {
+        if (line.startsWith("import")) {
             imports.push(line);
         }
         else {
@@ -32,17 +35,21 @@ async function validateAppContainer() {
     const moduleDeclarationRegex = /.create\(\s*\[([\s\S]*?)]/;
     const moduleDeclarationMatch = fileContent.match(moduleDeclarationRegex);
     if (!moduleDeclarationMatch) {
-        (0, cli_ui_1.printError)('Container format incorrect!', APP_CONTAINER);
+        (0, cli_ui_1.printError)("Container format incorrect!", APP_CONTAINER);
         process.exit(1);
     }
-    const modules = moduleDeclarationMatch[1].trim().split(',').filter((m) => m.trim() !== "").map((m) => m.trim());
+    const modules = moduleDeclarationMatch[1]
+        .trim()
+        .split(",")
+        .filter((m) => m.trim() !== "")
+        .map((m) => m.trim());
     return {
         regex: moduleDeclarationRegex,
         path: path[0],
         content: moduleDeclarationMatch,
         modules,
         imports,
-        notImports
+        notImports,
     };
 }
 async function addModuleToContainer(name, modulePath, path) {
@@ -59,7 +66,7 @@ async function addModuleToContainer(name, modulePath, path) {
     let newImport = "";
     const modulePathRegex = /^[^/]=$/;
     if (!modulePathRegex.test(modulePath)) {
-        if (path.split('/').length > 1) {
+        if (path.split("/").length > 1) {
             newImport = `import { ${moduleName}Module } from "${usecaseDir}${modulePath}/${name}.module";`;
         }
         else {
@@ -69,16 +76,21 @@ async function addModuleToContainer(name, modulePath, path) {
     else {
         newImport = `import { ${moduleName}Module } from "${usecaseDir}${name}/${name}.module";`;
     }
-    if (containerData.imports.includes(newImport) && containerData.modules.includes(`${moduleName}Module`)) {
+    if (containerData.imports.includes(newImport) &&
+        containerData.modules.includes(`${moduleName}Module`)) {
         return;
     }
     containerData.imports.push(newImport);
     containerData.modules.push(`${moduleName}Module`);
-    const newModule = containerData.modules.join(', ');
+    const newModule = containerData.modules.join(", ");
     const newModuleDeclaration = `.create([${newModule}]`;
-    const newFileContent = [...containerData.imports, ...containerData.notImports]
-        .join('\n').replace(containerData.regex, newModuleDeclaration);
+    const newFileContent = [
+        ...containerData.imports,
+        ...containerData.notImports,
+    ]
+        .join("\n")
+        .replace(containerData.regex, newModuleDeclaration);
     console.log(" ", chalk_1.default.greenBright(`[container]`.padEnd(14)), chalk_1.default.bold.white(`${moduleName}Module added to ${APP_CONTAINER}! ✔️`));
-    await node_fs_1.default.promises.writeFile(containerData.path, newFileContent, 'utf8');
+    await node_fs_1.default.promises.writeFile(containerData.path, newFileContent, "utf8");
 }
 exports.addModuleToContainer = addModuleToContainer;

package/bin/utils/center-text.js

@@ -4,7 +4,7 @@ exports.centerText = void 0;
 function centerText(text) {
     const terminalWidth = process.stdout.columns;
     const padding = Math.floor((terminalWidth - text.length) / 2);
-    const centeredText = ' '.repeat(padding) + text;
+    const centeredText = " ".repeat(padding) + text;
     return centeredText;
 }
 exports.centerText = centerText;

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/bin/utils/verify-file-exists.js

@@ -18,9 +18,9 @@ async function verifyIfFileExists(path) {
                 default: true,
             },
         ]);
-        const fileName = path.split('/').pop();
+        const fileName = path.split("/").pop();
         if (!answer.confirm) {
-            (0, cli_ui_1.printError)('File not created!', fileName);
+            (0, cli_ui_1.printError)("File not created!", fileName);
             process.exit(1);
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@expressots/cli",
-	"version": "1.3.4",
+	"version": "1.5.0",
 	"description": "Expressots CLI - modern, fast, lightweight nodejs web framework (@cli)",
 	"author": "Richard Zampieri",
 	"license": "MIT",
@@ -31,26 +31,31 @@
 		"Scaffolding"
 	],
 	"scripts": {
+		"prepare": "husky install",
 		"start:build": "npm run build && npm run start",
 		"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",
-		"lint": "eslint .eslintrc.js --ext .ts,.tsx,.js,.jsx .",
+		"format": "prettier --write \"./src/**/*.ts\" --cache",
+		"lint": "eslint \"./src/**/*.ts\"",
+		"lint:fix": "eslint \"./src/**/*.ts\" --fix",
 		"release": "release-it",
-		"prepare": "husky install"
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"test:coverage": "vitest run --coverage"
 	},
 	"dependencies": {
-		"@expressots/boost-ts": "^1.1.1",
-		"chalk-animation": "^1",
-		"cli-progress": "^3.11.2",
-		"degit": "^2.8.4",
-		"glob": "^10.2.6",
-		"inquirer": "^8.0.0",
-		"mustache": "^4.2.0",
-		"ts-node": "^10.9.1",
-		"yargs": "^17.6.2"
+		"@expressots/boost-ts": "1.1.1",
+		"chalk-animation": "2.0.3",
+		"cli-progress": "3.11.2",
+		"degit": "2.8.4",
+		"glob": "10.2.6",
+		"inquirer": "8.0.0",
+		"mustache": "4.2.0",
+		"ts-node": "10.9.1",
+		"yargs": "17.6.2"
 	},
 	"devDependencies": {
 		"@commitlint/cli": "^17.7.1",
@@ -74,7 +79,9 @@
 		"release-it": "^16.1.5",
 		"rimraf": "^4.1.2",
 		"ts-node-dev": "^2.0.0",
-		"typescript": "^4.9.5"
+		"typescript": "^4.9.5",
+		"vite": "^4.4.9",
+		"vitest": "^0.34.4"
 	},
 	"release-it": {
 		"git": {