@expressots/cli 1.0.1 → 1.1.0

package/README.md

@@ -8,11 +8,6 @@
 
 The Expresso TS CLI is a command-line interface tool that helps you to create `ExpressoTS` projects, develop, and maintain your applications and resources created. It assists in multiple ways, including scaffolding the project as well as the services offered by the application such as use cases, controllers, providers and more.
 
-### This is an example of the CLI for the Expresso TS framework.
-
-[![asciicast](https://asciinema.org/a/7diTOTyY653mpdA0JtugjRn9a.svg)](https://asciinema.org/a/7diTOTyY653mpdA0JtugjRn9a)
-
-
 ## Installation 💻
 
 ```
@@ -21,7 +16,7 @@ npm install -g @expressots/cli
 
 ## Usage
 
-Learn more in the official documentation
+Learn more in the [official documentation](https://expresso-ts.com/docs/category/cli)
 
 ## Stay in touch
 

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

@@ -0,0 +1,20 @@
+export declare const enum Pattern {
+    LOWER_CASE = "lowercase",
+    KEBAB_CASE = "kebab-case",
+    PASCAL_CASE = "PascalCase",
+    CAMEL_CASE = "camelCase"
+}
+/**
+ * The configuration object for the Expresso CLI.
+ *
+ * @property {Pattern} scaffoldPattern - The pattern to use when scaffolding files.
+ * @property {string} sourceRoot - The root directory for the source files.
+ * @property {boolean} opinionated - Whether or not to use the opinionated configuration.
+ *
+ * @see [ExpressoConfig](https://expresso-ts.com/docs)
+ */
+export interface ExpressoConfig {
+    scaffoldPattern: Pattern;
+    sourceRoot: string;
+    opinionated: boolean;
+}

package/bin/@types/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/bin/@types/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("./config"), exports);

package/bin/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/bin/cli.js

@@ -6,10 +6,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const yargs_1 = __importDefault(require("yargs"));
 const helpers_1 = require("yargs/helpers");
+const generate_1 = require("./generate");
 const new_1 = require("./new");
 (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
     .example("$0 new <project-name>", "Create a new Expresso TS project")
     .command((0, new_1.createProject)())
+    .command((0, generate_1.generateProject)())
     .demandCommand(1, "You need at least one command before moving on")
     .epilog("For more information, visit https://expresso-ts.com")
     .help()

package/bin/generate/cli.d.ts

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

package/bin/generate/cli.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateProject = void 0;
+const form_1 = require("./form");
+const chalk_1 = __importDefault(require("chalk"));
+const generateProject = () => {
+    return {
+        command: "generate [schematic] [path..]",
+        describe: "Generate a schematic",
+        aliases: ["g"],
+        builder: (yargs) => {
+            yargs.positional("schematic", {
+                choices: [
+                    "usecase",
+                    "controller",
+                    "dto",
+                    "service",
+                    "provider",
+                ],
+                describe: "The schematic to generate",
+                type: "string",
+                coerce: coerceSchematicAliases,
+            });
+            yargs.positional("path..", {
+                describe: "The path to generate the schematic",
+                type: "string",
+            });
+            return yargs;
+        },
+        handler: async ({ schematic, path }) => {
+            const file = await (0, form_1.createTemplate)({ schematic, path: path.join(" ") });
+            console.log(chalk_1.default.green(`> ${file.split(".")[0]} ${schematic} created! 🚀`));
+        },
+    };
+};
+exports.generateProject = generateProject;
+const coerceSchematicAliases = (arg) => {
+    switch (arg) {
+        case "u":
+            return "usecase";
+        case "c":
+            return "controller";
+        case "d":
+            return "dto";
+        case "s":
+            return "service";
+        case "p":
+            return "provider";
+        default:
+            return arg;
+    }
+};

package/bin/generate/form.d.ts

@@ -0,0 +1,6 @@
+type CreateTemplateProps = {
+    schematic: string;
+    path: string;
+};
+export declare const createTemplate: ({ schematic, path: target, }: CreateTemplateProps) => Promise<string>;
+export {};

package/bin/generate/form.js

@@ -0,0 +1,206 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTemplate = void 0;
+const nodePath = __importStar(require("path"));
+const node_fs_1 = require("node:fs");
+const mustache_1 = require("mustache");
+const fs_1 = require("fs");
+const chalk_1 = __importDefault(require("chalk"));
+const boost_ts_1 = require("@expressots/boost-ts");
+const compiler_1 = __importDefault(require("../utils/compiler"));
+function getFileNameWithoutExtension(filePath) {
+    return filePath.split('.')[0];
+}
+const messageColors = {
+    usecase: (text) => chalk_1.default.cyan(text),
+    controller: (text) => chalk_1.default.magenta(text),
+    "controller-service": (text) => chalk_1.default.magenta(text),
+    dto: (text) => chalk_1.default.blue(text),
+    provider: (text) => chalk_1.default.yellow(text),
+    module: (text) => chalk_1.default.red(text),
+};
+const createTemplate = async ({ schematic, path: target, }) => {
+    var _a, e_1, _b, _c;
+    const withinSource = schematicFolder(schematic);
+    if (!withinSource)
+        return;
+    const { path, file, className } = await splitTarget({ target, schematic });
+    const { sourceRoot } = await compiler_1.default.loadConfig();
+    const usecaseDir = `${sourceRoot}/${withinSource}`;
+    (0, node_fs_1.mkdirSync)(`${usecaseDir}/${path}`, { recursive: true });
+    if (schematic !== "service") {
+        console.log(messageColors[schematic](`> [${schematic}] Creating ${file}...`));
+        writeTemplate({
+            outputPath: `${usecaseDir}/${path}${file}`,
+            template: {
+                path: `./templates/${schematic}.tpl`,
+                data: {
+                    className,
+                    route: path.replace(/\/$/, ''),
+                    construct: (0, boost_ts_1.anyCaseToKebabCase)(className),
+                },
+            },
+        });
+    }
+    else {
+        try {
+            for (var _d = true, _e = __asyncValues(["controller-service", "usecase", "dto"]), _f; _f = await _e.next(), _a = _f.done, !_a;) {
+                _c = _f.value;
+                _d = false;
+                try {
+                    const currentSchematic = _c;
+                    const schematicFile = file.replace(`controller.ts`, `${currentSchematic}.ts`);
+                    console.log(messageColors[currentSchematic](`> [${currentSchematic}] Creating ${schematicFile.replace("controller-service", "controller")}...`));
+                    writeTemplate({
+                        outputPath: `${usecaseDir}/${path}${schematicFile.replace("controller-service", "controller")}`,
+                        template: {
+                            path: `./templates/${currentSchematic}.tpl`,
+                            data: {
+                                className,
+                                fileName: getFileNameWithoutExtension(file),
+                                useCase: (0, boost_ts_1.anyCaseToCamelCase)(className),
+                                route: path.replace(/\/$/, ''),
+                                construct: (0, boost_ts_1.anyCaseToKebabCase)(className),
+                            },
+                        },
+                    });
+                }
+                finally {
+                    _d = true;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    const moduleName = path.split("/")[0];
+    if (["controller", "service"].includes(schematic) && !(0, fs_1.existsSync)(`${usecaseDir}/${moduleName}/${moduleName}.module.ts`)) {
+        console.log(messageColors.module(`> [module] Creating ${moduleName}.module.ts...`));
+        writeTemplate({
+            outputPath: `${usecaseDir}/${moduleName}/${moduleName}.module.ts`,
+            template: {
+                path: `./templates/module.tpl`,
+                data: {
+                    moduleName: moduleName[0].toUpperCase() + moduleName.slice(1),
+                    className,
+                    path: `${path.split("/")[1]}/${file.slice(0, file.lastIndexOf('.'))}`
+                },
+            },
+        });
+    }
+    return file;
+};
+exports.createTemplate = createTemplate;
+const writeTemplate = ({ outputPath, template: { path, data }, }) => {
+    (0, fs_1.writeFileSync)(outputPath, (0, mustache_1.render)((0, node_fs_1.readFileSync)(nodePath.join(__dirname, path), "utf8"), data));
+};
+const schematicFolder = (schematic) => {
+    switch (schematic) {
+        case "usecase":
+            return "useCases";
+        case "controller":
+            return "useCases";
+        case "dto":
+            return "useCases";
+        case "service":
+            return "useCases";
+        case "provider":
+            return "providers";
+    }
+    return undefined;
+};
+const splitTarget = async ({ target, schematic, }) => {
+    if (schematic === "provider")
+        return await splitTargetProviderEdgeCase({ target, schematic });
+    if (schematic === "service")
+        schematic = "controller"; // Anything just to generate
+    // 1. Extract the name (first part of the target)
+    const [name, ...remainingPath] = target.split("/");
+    // 2. Check if the name is camelCase or kebab-case
+    const camelCaseRegex = /[A-Z]/;
+    const kebabCaseRegex = /[_\-\s]+/;
+    const isCamelCase = camelCaseRegex.test(name);
+    const isKebabCase = kebabCaseRegex.test(name);
+    if (isCamelCase || isKebabCase) {
+        const [wordName, ...path] = name === null || name === void 0 ? void 0 : name.split(isCamelCase ? /(?=[A-Z])/ : kebabCaseRegex).map((word) => word.toLowerCase());
+        return {
+            path: `${wordName}/${pathEdgeCase(path)}${pathEdgeCase(remainingPath)}`,
+            file: `${await getNameWithScaffoldPattern(name)}.${schematic}.ts`,
+            className: (0, boost_ts_1.anyCaseToPascalCase)(name),
+        };
+    }
+    // 3. Return the base case
+    return {
+        path: `${name}/${pathEdgeCase(remainingPath)}`,
+        file: `${await getNameWithScaffoldPattern(name)}.${schematic}.ts`,
+        className: (0, boost_ts_1.anyCaseToPascalCase)(name),
+    };
+};
+const splitTargetProviderEdgeCase = async ({ target, schematic, }) => {
+    // Check if the last path ends with a slash, if it does it's supposed to be a folder
+    // and the name of the file will be the same as the folder
+    const isFolder = target.endsWith("/");
+    const path = target.split("/").slice(0, -1);
+    const name = isFolder
+        ? path[path.length - 1]
+        : target.split("/")[target.split("/").length - 1];
+    return {
+        path: pathEdgeCase(path),
+        file: `${await getNameWithScaffoldPattern(name)}.${schematic}.ts`,
+        className: (0, boost_ts_1.anyCaseToPascalCase)(name),
+    };
+};
+const getNameWithScaffoldPattern = async (name) => {
+    const configObject = await compiler_1.default.loadConfig();
+    switch (configObject.scaffoldPattern) {
+        case "lowercase" /* Pattern.LOWER_CASE */:
+            return (0, boost_ts_1.anyCaseToLowerCase)(name);
+        case "kebab-case" /* Pattern.KEBAB_CASE */:
+            return (0, boost_ts_1.anyCaseToKebabCase)(name);
+        case "PascalCase" /* Pattern.PASCAL_CASE */:
+            return (0, boost_ts_1.anyCaseToPascalCase)(name);
+        case "camelCase" /* Pattern.CAMEL_CASE */:
+            return (0, boost_ts_1.anyCaseToCamelCase)(name);
+    }
+};
+const pathEdgeCase = (path) => {
+    return `${path.join("/")}${path.length > 0 ? "/" : ""}`;
+};

package/bin/generate/index.d.ts

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

package/bin/generate/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/generate/templates/controller-service.tpl

@@ -0,0 +1,23 @@
+import { BaseController, StatusCode } from "@expressots/core";
+import { controller, httpGet, response } from "inversify-express-utils";
+import { {{className}}UseCase } from "./{{fileName}}.usecase";
+import { I{{className}}ResponseDTO } from "./{{fileName}}.dto";
+
+@controller("/{{{route}}}")
+class {{className}}Controller extends BaseController {
+
+  constructor(private {{useCase}}UseCase: {{className}}UseCase ) {
+		super("{{construct}}-controller")
+	}
+
+  @httpGet("/")
+  execute(@response() res: any): I{{className}}ResponseDTO {
+    return this.callUseCase(
+            this.{{useCase}}UseCase.execute(),
+            res,
+            StatusCode.Ok,
+        );
+  }
+}
+
+export { {{className}}Controller };

package/bin/generate/templates/controller.tpl

@@ -0,0 +1,17 @@
+import { BaseController } from "@expressots/core";
+import { controller, httpGet, response } from "inversify-express-utils";
+
+@controller("/{{{route}}}")
+class {{className}}Controller extends BaseController {
+
+  constructor() {
+		super("{{construct}}-controller")
+	}
+
+  @httpGet("/")
+  execute(@response() res: any) {
+    return res.send("Hello Expresso TS");
+  }
+}
+
+export { {{className}}Controller };

package/bin/generate/templates/dto.tpl

@@ -0,0 +1,5 @@
+interface I{{className}}RequestDTO { }
+
+interface I{{className}}ResponseDTO { }
+
+export { I{{className}}RequestDTO, I{{className}}ResponseDTO };

package/bin/generate/templates/module.tpl

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

package/bin/generate/templates/provider.tpl

@@ -0,0 +1,10 @@
+import { provide } from "inversify-binding-decorators";
+
+@provide({{className}}Provider)
+class {{className}}Provider {
+
+    constructor() {}
+
+}
+
+export { {{className}}Provider };

package/bin/generate/templates/usecase.tpl

@@ -0,0 +1,13 @@
+import { provide } from "inversify-binding-decorators";
+
+@provide({{className}}UseCase)
+class {{className}}UseCase {
+
+    constructor() {}
+
+    execute(): string {
+        return "your use case";
+    }
+}
+
+export { {{className}}UseCase };

package/bin/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./generate";
+export * from "./utils";
+export * from "./new";

package/bin/index.js

@@ -0,0 +1,20 @@
+"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("./types"), exports);
+__exportStar(require("./generate"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./new"), exports);

package/bin/new/cli.d.ts

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

package/bin/new/cli.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProject = void 0;
+const form_1 = require("./form");
+const createProject = () => {
+    return {
+        command: "new [project-name]",
+        describe: "Create a new Expresso TS project",
+        builder: (yargs) => {
+            yargs.positional("project-name", {
+                describe: "The name of the project",
+                type: "string",
+            });
+            return yargs;
+        },
+        handler: async ({ projectName }) => {
+            return await (0, form_1.projectForm)(projectName);
+        },
+    };
+};
+exports.createProject = createProject;

package/bin/new/form.d.ts

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

package/bin/new/form.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.projectForm = void 0;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const degit_1 = __importDefault(require("degit"));
+const child_process_1 = require("child_process");
+const cli_progress_1 = require("cli-progress");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+async function packageManagerInstall({ packageManager, directory, progressBar, }) {
+    return new Promise((resolve, reject) => {
+        const isWindows = process.platform === "win32";
+        const command = isWindows
+            ? `${packageManager}.cmd`
+            : packageManager;
+        const installProcess = (0, child_process_1.spawn)(command, ["install"], {
+            cwd: directory,
+        });
+        installProcess.stdout.on("data", (data) => {
+            progressBar.increment(5, {
+                doing: `${data.toString().trim()}`,
+            });
+        });
+        installProcess.on("close", (code) => {
+            if (code === 0) {
+                resolve("Installation Done!");
+            }
+            else {
+                reject(new Error(`npm install exited with code ${code}`));
+            }
+        });
+    });
+}
+async function checkIfPackageManagerExists(packageManager) {
+    try {
+        (0, child_process_1.execSync)(`${packageManager} --version`);
+        return true;
+    }
+    catch (_) {
+        throw new Error(`Package manager ${packageManager} is not installed`);
+    }
+}
+// Change the package.json name to the user's project name
+function changePackageName({ directory, name, }) {
+    // Get the absolute path of the input directory parameter
+    const absDirPath = node_path_1.default.resolve(directory);
+    // 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);
+    // Change the name
+    packageJson.name = name;
+    // Save the package.json file
+    node_fs_1.default.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+}
+const projectForm = async (projectName) => {
+    const answer = await inquirer_1.default.prompt([
+        {
+            type: "input",
+            name: "name",
+            message: "Project name",
+            default: projectName,
+            transformer: (input) => {
+                return chalk_1.default.yellow(chalk_1.default.bold(input));
+            },
+        },
+        {
+            type: "list",
+            name: "packageManager",
+            message: "Package manager",
+            choices: ["npm", "yarn", "pnpm"],
+        },
+        {
+            type: "list",
+            name: "template",
+            message: "Select a template",
+            choices: [
+                "Non-Opinionated :: A simple ExpressoTS project.",
+                "Opinionated :: A complete ExpressoTS project with an opinionated structure and features.",
+            ],
+        },
+        {
+            type: "confirm",
+            name: "confirm",
+            message: "Do you want to create this project?",
+            default: true,
+        },
+    ]);
+    // Hashmap of templates and their directories
+    const templates = {
+        "Non-Opinionated": "non_opinionated",
+        Opinionated: "opinionated",
+    };
+    if (answer.confirm) {
+        // Check if the package manager exists
+        await checkIfPackageManagerExists(answer.packageManager).catch((err) => {
+            console.log(chalk_1.default.red(err.message));
+            process.exit(1);
+        });
+        const progressBar = new cli_progress_1.SingleBar({
+            format: "Progress |" + chalk_1.default.green("{bar}") + "| {percentage}% || {doing}",
+            hideCursor: true,
+        }, cli_progress_1.Presets.shades_classic);
+        progressBar.start(100, 0, {
+            doing: "Cloning project",
+        });
+        const [_, template] = answer.template.match(/(.*) ::/);
+        const emitter = (0, degit_1.default)(`expressots/expressots/templates/${templates[template]}`);
+        await emitter.clone(answer.name);
+        progressBar.update(50, {
+            doing: "Installing dependencies",
+        });
+        // Run the package manager install in the directory
+        await packageManagerInstall({
+            packageManager: answer.packageManager,
+            directory: answer.name,
+            progressBar,
+        });
+        progressBar.update(90);
+        changePackageName({
+            directory: answer.name,
+            name: answer.name,
+        });
+        progressBar.update(100);
+        progressBar.stop();
+        console.log(chalk_1.default.green("Project created successfully!"));
+        console.log("Run the following commands to start the project:");
+        console.log(chalk_1.default.bold(`cd ${answer.name}`));
+        console.log(chalk_1.default.bold(`${answer.packageManager} start`));
+    }
+};
+exports.projectForm = projectForm;

package/bin/new/index.d.ts

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

package/bin/new/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/types.d.ts

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

package/bin/types.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("./@types"), exports);

package/bin/utils/compiler.d.ts

@@ -0,0 +1,15 @@
+import { Service } from "ts-node";
+import { ExpressoConfig } from "../types";
+/**
+ * Singleton compiler class
+ */
+declare class Compiler {
+    private static instance;
+    private constructor();
+    static get Instance(): Compiler;
+    getService(): Promise<Service>;
+    private static interopRequireDefault;
+    private static findConfig;
+    static loadConfig(): Promise<ExpressoConfig>;
+}
+export default Compiler;

package/bin/utils/compiler.js

@@ -0,0 +1,88 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const path_1 = __importDefault(require("path"));
+/**
+ * The path to the expressots.config.ts file
+ */
+const EXPRESSOTS_CONFIG = path_1.default.join(process.cwd(), "expressots.config.ts");
+/**
+ * The config object
+ */
+let globalConfigObject = null;
+/**
+ * The ts-node register options
+ */
+const regOpt = {
+    compilerOptions: {
+        module: "commonjs",
+    },
+    moduleTypes: {
+        "**": "cjs",
+    },
+};
+/**
+ * Singleton compiler class
+ */
+class Compiler {
+    constructor() { }
+    static get Instance() {
+        if (!Compiler.instance) {
+            Compiler.instance = new Compiler();
+        }
+        return Compiler.instance;
+    }
+    async getService() {
+        const tsnode = await Promise.resolve().then(() => __importStar(require("ts-node")));
+        const compiler = tsnode.register(regOpt);
+        return compiler;
+    }
+    static interopRequireDefault(obj) {
+        const module = require(obj);
+        return module && module.__esModule ? module : { default: module };
+    }
+    static async findConfig(dir) {
+        const configPath = path_1.default.join(dir, "expressots.config.ts");
+        const exists = (0, node_fs_1.existsSync)(configPath);
+        if (exists)
+            return configPath;
+        const parentDir = path_1.default.join(dir, "..");
+        if (parentDir === dir)
+            throw new Error("No config file found");
+        return Compiler.findConfig(parentDir);
+    }
+    static async loadConfig() {
+        const compiler = await Compiler.Instance.getService();
+        compiler.enabled(true);
+        globalConfigObject = Compiler.interopRequireDefault(await Compiler.findConfig(process.cwd()));
+        compiler.enabled(false);
+        return globalConfigObject.default;
+    }
+}
+exports.default = Compiler;

package/bin/utils/index.d.ts

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

package/bin/utils/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("./compiler"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expressots/cli",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Expressots CLI - modern, fast, lightweight nodejs web framework (@cli)",
   "author": "Richard Zampieri",
   "license": "MIT",
@@ -34,20 +34,21 @@
     "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 && chmod +x ./bin/cli.js",
+    "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",
     "clean": "rimraf ./bin",
     "lint": "eslint .eslintrc.js --ext .ts,.tsx,.js,.jsx .",
     "release": "release-it",
     "prepare": "husky install"
   },
-  "files": [
-    "bin/cli.js"
-  ],
   "dependencies": {
+    "@expressots/boost-ts": "^1.1.1",
     "chalk-animation": "^1",
     "cli-progress": "^3.11.2",
     "degit": "^2.8.4",
     "inquirer": "^8.0.0",
+    "mustache": "^4.2.0",
+    "ts-node": "^10.9.1",
     "yargs": "^17.6.2"
   },
   "devDependencies": {
@@ -55,6 +56,7 @@
     "@types/cli-progress": "^3.11.0",
     "@types/degit": "^2.8.3",
     "@types/inquirer": "^9.0.3",
+    "@types/mustache": "^4.2.2",
     "@types/node": "^18.11.19",
     "@types/yargs": "^17.0.22",
     "@typescript-eslint/eslint-plugin": "^5.53.0",