ddd-backend-cli 1.0.0

package/README.md

@@ -0,0 +1,140 @@
+<h1 align="left">Backend CLI Automation</h1>
+<img src="https://i.ibb.co/0VfX0r3F/backend-Automation.png" alt="backend Automation" border="0">
+
+###
+
+<p align="left">CLI para generar automáticamente la estructura base de un módulo CRUD en un proyecto Backend usando Node.js + TypeScript + Express + EJS templates.<br><br>Este proyecto te permite crear tu propio template de Backend y personalizarlo usando solo comandos, sin necesidad de escribir todo el código repetitivo cada vez.</p>
+
+Documentación paso a paso en mi Notion, para que puedas replicar la lógica y adaptarlo a tu manera: https://www.notion.so/oscarmolina/Automatizacion-Backend-3037c9c9fb1780f5bb06db3a9fb9ef83?source=copy_link
+
+###
+
+<h2 align="left">Repositorio del CLI</h2>
+
+###
+  
+```bash
+#clonar el proyecto
+git clone https://github.com/oscarMolina1523/BackendAutomation 
+
+#navegar dentro de la carpeta
+cd backend-cli
+
+#instalar dependencias
+npm install
+
+#hacer build del proyecto
+npm run build
+
+#crear link de direccion en la pc
+npm link
+```
+###
+
+<h2 align="left">Estructura del Proyecto CLI</h2>
+
+###
+
+```bash
+backend-cli/
+│
+├── src/
+│   ├── index.ts  <-----ejcuta todos los procesos
+│   ├── initializer/
+│   │   ├── createBaseStructure.ts
+│   │   ├── createGitIgnore.ts
+│   │   ├── createPackageJson.ts
+│   │   ├── createTsConfig.ts
+│   │   ├── initProject.ts  <---ejecuta el flujo
+│   │   └── installDependencies.ts
+│   ├── generators/
+│   │   ├──modules/
+│   │   ├── baseModel.ts
+│   │   ├── containerRegistry.ts
+│   │   ├── createOpenApiBase.ts
+│   │   ├── fileCreator.ts
+│   │   ├── generateModule.ts <---ejecuta el flujo de trabajo
+│   │   ├── routeRegistry.ts
+│   │   ├── structure.ts
+│   │   ├── types.ts  
+│   │   └── openApiRegistry.ts
+├── templates/
+│   ├── controller.ejs
+│   ├── dto.ejs
+│   ├── entity.ejs
+│   ├── path.ejs
+│   ├── service.interface.ejs
+│   ├── service.impl.ejs
+│   ├── repository.interface.ejs
+│   ├── repository.impl.ejs
+│   ├── routes.ejs
+│   └── schema.ejs
+│
+├── dist/  ← Se genera automáticamente con npm run build
+├── package.json
+├── tsconfig.json
+```
+###
+
+<h2 align="left">¿Cómo funciona el CLI?</h2>
+
+Este CLI utiliza:
+Commander → Para manejar comandos en consola, 
+EJS → Para generar archivos dinámicamente usando templates, 
+fs-extra → Para manipulación de archivos, 
+TypeScript → Para tipado y compilación.
+
+Para usarlo , debes haber ejecutado los comandos mencionados anteriormente y estar seguros 
+de que esta funcionando el CLI (no es necesario qeu el proyecto CLI este corriendo, con haber ejecutado sus comandos es suficiente),
+debes ubicarte en el espacio sobre el que trabajaras, en mi caso el Escritorio(Desktop) y ejecutar los comandos a continuación.
+
+
+```bash
+
+#para iniciar el proyecto nuevo y crear una base usa el siguiente comando
+
+mycli init test-api
+
+#donde init es el comando de inicializacion y test-api el nombre del proyecto,
+# una vez creado debemos entrar en el proyecto con el comando:
+
+cd test-api
+
+#luego ejecutaremos el siguiente comando que se encargara de crearnos la estructura
+# de carpetas y archivos de manera automatizada
+
+mycli generate Product name:string price:number
+
+#El CLI:
+#Crea una carpeta src/product
+#Genera automáticamente:
+#Controller
+#Service (interface + implementación)
+#Repository (interface + implementación)
+#Routes
+#Swagger schema
+#Inserta dinámicamente los campos en el template de Swagger
+```
+###
+<h2 align="left">¿Donde ver la documentaciónde los endpoints?</h2>
+
+```bash
+#en tu navegador de preferencia luego de asegurarte de que tu backend este corriendo
+#debes escribir la siguiente ruta
+
+http:localhost:3000
+
+#tambien podrás ver la documentación y probar cada endpoint
+#desde Scalar en la web usando la siguiente ruta
+
+http:localhost:3000/api-docs
+
+```
+
+<h2 align="left">✨ Autor</h2>
+
+###
+
+<p align="left">Desarrollador Oscar Molina<br>💼 Desarrollador Web<br>GitHub: @oscarMolina1523<br>linkedin: https://www.linkedin.com/in/oscar-molina-916195309</p>
+
+###

package/dist/generators/module/baseModel.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureBaseModel = ensureBaseModel;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+//this create the base model file if it does not exist to be extended by other models
+async function ensureBaseModel(domainPath) {
+    const baseModelPath = path_1.default.join(domainPath, "entities", "base.model.ts");
+    if (await fs_extra_1.default.pathExists(baseModelPath)) {
+        return;
+    }
+    const content = `
+export default abstract class BaseModel {
+  id: string;
+
+  constructor(id: string) {
+    this.id = id;
+  }
+}
+`;
+    await fs_extra_1.default.writeFile(baseModelPath, content.trim());
+}

package/dist/generators/module/containerRegistry.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerModuleInContainer = registerModuleInContainer;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+//this register every module's dependencies in the dependency container
+async function registerModuleInContainer(webApiPath, name, moduleName) {
+    const registryPath = path_1.default.join(webApiPath, "container", "dependencyContainer.ts");
+    await fs_extra_1.default.ensureDir(path_1.default.dirname(registryPath));
+    if (!(await fs_extra_1.default.pathExists(registryPath))) {
+        await fs_extra_1.default.writeFile(registryPath, `import { container } from "tsyringe";
+// AUTO-GENERATED MODULE REGISTRATIONS
+`);
+    }
+    let content = await fs_extra_1.default.readFile(registryPath, "utf-8");
+    if (content.includes(`${name}Service`))
+        return;
+    const importBlock = `import { I${name}Repository } from "./../../Domain/repositories/${moduleName}Repository.interface";
+import { ${name}Repository } from "./../../Infrastructure/repositories/${moduleName}.repository";
+import { I${name}Service } from "./../../Application/interfaces/${moduleName}.service.interface";
+import { ${name}Service } from "./../../Application/services/${moduleName}.service";
+import { ${name}Controller } from "./../controllers/${moduleName}.controller";`;
+    const registerBlock = `// ${name}
+container.register<I${name}Repository>("I${name}Repository", { useClass: ${name}Repository });
+container.register<I${name}Service>("I${name}Service", { useClass: ${name}Service });
+container.register<${name}Controller>("${name}Controller", { useClass: ${name}Controller });`;
+    content = content.replace('import { container } from "tsyringe";', `import { container } from "tsyringe";\n${importBlock}`);
+    content = content.replace("// AUTO-GENERATED MODULE REGISTRATIONS", `// AUTO-GENERATED MODULE REGISTRATIONS\n${registerBlock}`);
+    await fs_extra_1.default.writeFile(registryPath, content);
+}

package/dist/generators/module/createOpenApiBase.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOpenApiBase = createOpenApiBase;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+async function createOpenApiBase() {
+    const docsPath = path_1.default.join("src", "WebApi", "docs");
+    await fs_extra_1.default.ensureDir(docsPath);
+    const openApiPath = path_1.default.join(docsPath, "openapi.ts");
+    if (await fs_extra_1.default.pathExists(openApiPath)) {
+        return;
+    }
+    const content = `
+export const OpenApiSpecification = {
+  openapi: "3.0.0",
+  info: {
+    title: "My API",
+    version: "1.0.0",
+    description: "Auto-generated API documentation"
+  },
+  servers: [
+    {
+      url: "http://localhost:3000",
+      description: "Local server"
+    }
+  ],
+  paths: {},
+  components: {
+    securitySchemes: {
+      BearerAuth: {
+        type: "http",
+        scheme: "bearer",
+        bearerFormat: "JWT"
+      }
+    },
+    schemas: {}
+  }
+};
+`;
+    await fs_extra_1.default.writeFile(openApiPath, content.trim());
+}

package/dist/generators/module/fileCreator.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFile = createFile;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const ejs_1 = __importDefault(require("ejs"));
+async function createFile(template, destination, data) {
+    const templatePath = path_1.default.resolve(__dirname, "../../../templates", template);
+    if (await fs_extra_1.default.pathExists(destination)) {
+        console.log(`Skipped: ${destination}`);
+        return;
+    }
+    const content = (await ejs_1.default.renderFile(templatePath, data));
+    await fs_extra_1.default.writeFile(destination, content);
+    console.log(`Created: ${destination}`);
+}

package/dist/generators/module/generateModule.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateModule = generateModule;
+const path_1 = __importDefault(require("path"));
+const structure_1 = require("./structure");
+const baseModel_1 = require("./baseModel");
+const fileCreator_1 = require("./fileCreator");
+const containerRegistry_1 = require("./containerRegistry");
+const routeRegistry_1 = require("./routeRegistry");
+const openApiRegistry_1 = require("./openApiRegistry");
+const createOpenApiBase_1 = require("./createOpenApiBase");
+async function generateModule(name, fields) {
+    const moduleName = name.toLowerCase();
+    const parsedFields = fields.map((f) => {
+        const [fieldName, type] = f.split(":");
+        return { fieldName, type };
+    });
+    const rootPath = path_1.default.join(process.cwd(), "src");
+    const { webApiPath, applicationPath, domainPath, infrastructurePath, } = await (0, structure_1.createModuleStructure)(rootPath);
+    await (0, baseModel_1.ensureBaseModel)(domainPath);
+    // WebApi
+    await (0, fileCreator_1.createFile)("controller.ejs", path_1.default.join(webApiPath, "controllers", `${moduleName}.controller.ts`), { name, moduleName, fields: parsedFields });
+    await (0, fileCreator_1.createFile)("routes.ejs", path_1.default.join(webApiPath, "routes", `${moduleName}.routes.ts`), { name, fields: parsedFields });
+    await (0, fileCreator_1.createFile)("path.ejs", path_1.default.join(webApiPath, "docs", "paths", `${moduleName}.path.ts`), { name, moduleName, fields: parsedFields });
+    await (0, fileCreator_1.createFile)("schema.ejs", path_1.default.join(webApiPath, "docs", "schemas", `${moduleName}.schema.ts`), { name, moduleName, fields: parsedFields });
+    // Application
+    await (0, fileCreator_1.createFile)("dto.ejs", path_1.default.join(applicationPath, "dtos", `${moduleName}.dto.ts`), { name, fields: parsedFields });
+    await (0, fileCreator_1.createFile)("service.interface.ejs", path_1.default.join(applicationPath, "interfaces", `${moduleName}.service.interface.ts`), { name, moduleName });
+    await (0, fileCreator_1.createFile)("service.impl.ejs", path_1.default.join(applicationPath, "services", `${moduleName}.service.ts`), { name, moduleName });
+    // Domain
+    await (0, fileCreator_1.createFile)("entity.ejs", path_1.default.join(domainPath, "entities", `${moduleName}.ts`), { name, fields: parsedFields });
+    await (0, fileCreator_1.createFile)("repository.interface.ejs", path_1.default.join(domainPath, "repositories", `${moduleName}Repository.interface.ts`), { name, moduleName });
+    // Infrastructure
+    await (0, fileCreator_1.createFile)("repository.impl.ejs", path_1.default.join(infrastructurePath, "repositories", `${moduleName}.repository.ts`), { name, moduleName });
+    await (0, containerRegistry_1.registerModuleInContainer)(webApiPath, name, moduleName);
+    (0, routeRegistry_1.registerRouteInMain)(moduleName);
+    await (0, createOpenApiBase_1.createOpenApiBase)();
+    await (0, openApiRegistry_1.registerOpenApi)(webApiPath, name, moduleName);
+    console.log(`Module ${name} created successfully ✔`);
+}

package/dist/generators/module/openApiRegistry.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerOpenApi = registerOpenApi;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+//this is to register the generated open api paths and schemas in the main openapi file
+async function registerOpenApi(webApiPath, name, moduleName) {
+    const openApiPath = path_1.default.join(webApiPath, "docs", "openapi.ts");
+    if (!(await fs_extra_1.default.pathExists(openApiPath)))
+        return;
+    let content = await fs_extra_1.default.readFile(openApiPath, "utf-8");
+    const importPaths = `import { ${name}Paths } from "./paths/${moduleName}.path";`;
+    const importSchemas = `import { ${name}Schemas } from "./schemas/${moduleName}.schema";`;
+    if (!content.includes(importPaths))
+        content = importPaths + "\n" + content;
+    if (!content.includes(importSchemas))
+        content = importSchemas + "\n" + content;
+    if (!content.includes(`...${name}Paths`))
+        content = content.replace("paths: {", `paths: {\n    ...${name}Paths,`);
+    if (!content.includes(`...${name}Schemas`))
+        content = content.replace("schemas: {", `schemas: {\n      ...${name}Schemas,`);
+    await fs_extra_1.default.writeFile(openApiPath, content);
+}

package/dist/generators/module/routeRegistry.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRouteInMain = registerRouteInMain;
+const fs_1 = __importDefault(require("fs"));
+//this register every module's routes in the main application file
+function registerRouteInMain(moduleName) {
+    const mainPath = "src/main.ts";
+    let content = fs_1.default.readFileSync(mainPath, "utf-8");
+    const importLine = `import ${moduleName}Routes from "./WebApi/routes/${moduleName}.routes";`;
+    const useLine = `app.use("/${moduleName}", ${moduleName}Routes);`;
+    if (!content.includes(importLine)) {
+        content = content.replace('import express from "express";', `import express from "express";\n${importLine}`);
+    }
+    if (!content.includes(useLine)) {
+        content = content.replace("app.use(express.json());", `app.use(express.json());\n${useLine}`);
+    }
+    fs_1.default.writeFileSync(mainPath, content);
+}

package/dist/generators/module/structure.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModuleStructure = createModuleStructure;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+//this only creates the folder structure for a module
+async function createModuleStructure(rootPath) {
+    //Base folders
+    const webApiPath = path_1.default.join(rootPath, "WebApi");
+    const applicationPath = path_1.default.join(rootPath, "Application");
+    const domainPath = path_1.default.join(rootPath, "Domain");
+    const infrastructurePath = path_1.default.join(rootPath, "Infrastructure");
+    //subfolders of WebApi
+    await fs_extra_1.default.ensureDir(path_1.default.join(webApiPath, "controllers"));
+    await fs_extra_1.default.ensureDir(path_1.default.join(webApiPath, "routes"));
+    await fs_extra_1.default.ensureDir(path_1.default.join(webApiPath, "docs"));
+    await fs_extra_1.default.ensureDir(path_1.default.join(webApiPath, "docs", "paths"));
+    await fs_extra_1.default.ensureDir(path_1.default.join(webApiPath, "docs", "schemas"));
+    //subfolders of Application
+    await fs_extra_1.default.ensureDir(path_1.default.join(applicationPath, "dtos"));
+    await fs_extra_1.default.ensureDir(path_1.default.join(applicationPath, "interfaces"));
+    await fs_extra_1.default.ensureDir(path_1.default.join(applicationPath, "services"));
+    //subfolders of Domain
+    await fs_extra_1.default.ensureDir(path_1.default.join(domainPath, "entities"));
+    await fs_extra_1.default.ensureDir(path_1.default.join(domainPath, "repositories"));
+    //subfolders of Infrastructure
+    await fs_extra_1.default.ensureDir(path_1.default.join(infrastructurePath, "repositories"));
+    return { webApiPath, applicationPath, domainPath, infrastructurePath };
+}

package/dist/generators/module/types.js

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

package/dist/index.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const initProject_1 = require("./initializer/initProject");
+const generateModule_1 = require("./generators/module/generateModule");
+const program = new commander_1.Command();
+program
+    .name("ddd-backend-cli")
+    .version("1.0.0");
+// ==============================
+// INIT PROJECT
+// ==============================
+program
+    .command("init <projectName>")
+    .description("Initialize a new TypeScript layered project")
+    .action(async (projectName) => {
+    try {
+        await (0, initProject_1.initProject)(projectName);
+    }
+    catch (error) {
+        console.error("Error initializing project:", error);
+    }
+});
+// ==============================
+// GENERATE MODULE
+// ==============================
+program
+    .command("generate-model <name> [fields...]")
+    .description("Generate CRUD module")
+    .action(async (name, fields) => {
+    try {
+        await (0, generateModule_1.generateModule)(name, fields || []);
+    }
+    catch (error) {
+        console.error("Error generating module:", error);
+    }
+});
+program.parse(process.argv);

package/dist/initializer/createBaseStructure.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBaseStructure = createBaseStructure;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+async function createBaseStructure() {
+    //create src folder
+    await fs_extra_1.default.ensureDir("src");
+}

package/dist/initializer/createGitIgnore.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGitignore = createGitignore;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+async function createGitignore() {
+    const content = `
+node_modules
+dist
+.env
+  `;
+    await fs_extra_1.default.writeFile(".gitignore", content.trim());
+}

package/dist/initializer/createMainFile.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMainFile = createMainFile;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+async function createMainFile() {
+    const content = `
+import "reflect-metadata";
+import "./WebApi/container/dependencyContainer";
+import express from "express";
+import { OpenApiSpecification } from "./WebApi/docs/openapi";
+import { apiReference } from "@scalar/express-api-reference";
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+app.use(express.urlencoded({ extended: false }));
+app.use(express.json());
+
+app.use(
+  "/api-docs",
+  apiReference({
+    spec: {
+      content: OpenApiSpecification,
+    },
+  })
+);
+
+app.listen(PORT, () => {
+  console.log(\`Server running on port \${PORT}\`);
+});
+`;
+    await fs_extra_1.default.writeFile("src/main.ts", content.trim());
+}

package/dist/initializer/createPackageJson.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPackageJson = createPackageJson;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+async function createPackageJson(projectName) {
+    const packageJson = {
+        name: projectName,
+        version: "1.0.0",
+        main: "dist/main.js",
+        scripts: {
+            build: "tsc",
+            start: "node dist/main.js",
+            dev: "ts-node-dev --respawn src/main.ts",
+        },
+    };
+    await fs_extra_1.default.writeJson("package.json", packageJson, { spaces: 2 });
+}

package/dist/initializer/createTsConfig.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTsConfig = createTsConfig;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+async function createTsConfig() {
+    const tsconfig = {
+        compilerOptions: {
+            rootDir: "./src",
+            outDir: "./dist",
+            module: "Commonjs",
+            target: "ES2020",
+            lib: ["ES2020"],
+            types: ["node"],
+            sourceMap: true,
+            declaration: true,
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            experimentalDecorators: true,
+            emitDecoratorMetadata: true,
+        },
+        include: ["src"],
+        exclude: ["node_modules", "dist"],
+    };
+    await fs_extra_1.default.writeJson("tsconfig.json", tsconfig, { spaces: 2 });
+}

package/dist/initializer/initProject.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initProject = initProject;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const createPackageJson_1 = require("./createPackageJson");
+const createTsConfig_1 = require("./createTsConfig");
+const createGitIgnore_1 = require("./createGitIgnore");
+const createBaseStructure_1 = require("./createBaseStructure");
+const createMainFile_1 = require("./createMainFile");
+const installDependencies_1 = require("./installDependencies");
+async function initProject(projectName) {
+    const rootPath = path_1.default.join(process.cwd(), projectName);
+    if (await fs_extra_1.default.pathExists(rootPath)) {
+        console.log("Project already exists");
+        return;
+    }
+    await fs_extra_1.default.ensureDir(rootPath);
+    process.chdir(rootPath);
+    await (0, createPackageJson_1.createPackageJson)(projectName);
+    await (0, createTsConfig_1.createTsConfig)();
+    await (0, createGitIgnore_1.createGitignore)();
+    await (0, createBaseStructure_1.createBaseStructure)();
+    await (0, createMainFile_1.createMainFile)();
+    await (0, installDependencies_1.installDependencies)();
+    console.log("Project initialized successfully ✔");
+}

package/dist/initializer/installDependencies.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installDependencies = installDependencies;
+const child_process_1 = require("child_process");
+async function installDependencies() {
+    console.log("Installing dependencies...");
+    try {
+        (0, child_process_1.execSync)("npm install express tsyringe reflect-metadata @scalar/express-api-reference", { stdio: "inherit" });
+        (0, child_process_1.execSync)("npm install -D typescript ts-node-dev @types/node @types/express", { stdio: "inherit" });
+    }
+    catch {
+        console.error("Dependency installation failed");
+    }
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "ddd-backend-cli",
+  "version": "1.0.0",
+  "description": "CLI para generar proyectos backend con DDD",
+  "main": "dist/index.js",
+  "bin": {
+    "ddd-backend-cli": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "cli",
+    "ddd",
+    "backend",
+    "generator"
+  ],
+  "author": "Oscar Molina",
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w"
+  },
+  "dependencies": {
+    "commander": "^14.0.3",
+    "ejs": "^3.1.10",
+    "fs-extra": "^11.3.3"
+  },
+  "devDependencies": {
+    "@types/ejs": "^3.1.5",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.11.30",
+    "typescript": "^5.3.3"
+  }
+}