nest-combo 1.0.2 → 1.1.1

package/bin/cli.js

@@ -1,5 +1,9 @@
 #!/usr/bin/env node
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
 import chalk from "chalk";
+import yaml from "js-yaml";
 import {
   generateModule,
   generateController,
@@ -7,9 +11,13 @@ import {
   generateInterceptor,
   generateGateway,
   generateMiddlware,
+  generateProject,
 } from "../lib/generate.js";
+import { installDependencies } from "../lib/install.js";
 import { createRequire } from "module";
+import { validateYml } from "../lib/utils.js";
 const require = createRequire(import.meta.url);
+const { name, version } = require("../package.json");
 
 const args = process.argv.slice(2);
 const resources = [
@@ -52,20 +60,40 @@ const resources = [
 ];
 
 function main() {
-  const { askForHelp, askForVersion, moduleName, hasDryRun, hasNoSpec } =
-    getArgs();
+  printBanner();
+  const {
+    askForHelp,
+    askForVersion,
+    moduleName,
+    hasDryRun,
+    hasNoSpec,
+    hasYmlFile,
+  } = getArgs();
 
-  if (askForVersion) {
-    showVersion();
-    process.exit(0);
-  }
-  if (askForHelp) {
-    showUsage();
-    process.exit(0);
+  switch (true) {
+    case askForVersion:
+      showVersion();
+      process.exit(0);
+      break;
+
+    case askForHelp:
+      showUsage();
+      process.exit(0);
+      break;
+
+    case hasYmlFile:
+      const file = args[1];
+      loadFromYml(file);
+      process.exit(0);
+      break;
+
+    default:
+      execute(moduleName, hasNoSpec, hasDryRun);
   }
+}
 
+function execute(moduleName, hasNoSpec, hasDryRun) {
   validate(moduleName);
-
   resources.forEach((component) => {
     if (args.includes(component.flag) || args.includes(component.longFlag)) {
       console.log(
@@ -95,6 +123,9 @@ function getArgs() {
   const askForHelp = args.includes("-h") || args.includes("--help");
   const hasNoSpec = args.includes("-ns") || args.includes("--no-spec");
   const hasDryRun = args.includes("-dr") || args.includes("--dry-run");
+  const hasYmlFile = args.includes("-f") || args.includes("--file");
+  const validateYmlFile =
+    args.includes("-vf") || args.includes("--validate-yml");
 
   return {
     moduleName,
@@ -102,6 +133,8 @@ function getArgs() {
     askForHelp,
     hasNoSpec,
     hasDryRun,
+    hasYmlFile,
+    validateYmlFile,
   };
 }
 
@@ -110,12 +143,14 @@ function showUsage() {
 ${chalk.yellow("Usage:")} nest-combo <module-name> [options]
 
 ${chalk.yellow("Options:")}
-  ${chalk.cyan("-m,   --module")}        Generate a Module
-  ${chalk.cyan("-c,   --controller")}    Generate a Controller
-  ${chalk.cyan("-s,   --service")}       Generate a Service
-  ${chalk.cyan("-g,   --gateway")}       Generate a Gateway
-  ${chalk.cyan("-mw,  --middleware")}    Generate Middleware
-  ${chalk.cyan("-itc, --interceptor")}   Generate an Interceptor
+  ${chalk.cyan("-m,   --module")}         Generate a Module
+  ${chalk.cyan("-c,   --controller")}     Generate a Controller
+  ${chalk.cyan("-s,   --service")}        Generate a Service
+  ${chalk.cyan("-g,   --gateway")}        Generate a Gateway
+  ${chalk.cyan("-mw,  --middleware")}     Generate Middleware
+  ${chalk.cyan("-itc, --interceptor")}    Generate an Interceptor
+  ${chalk.cyan("-f,   --file")}           Generate project from yml file
+  ${chalk.cyan("-vf,   --validate-yml")}  Validate Yml File
 
 ${chalk.bgMagenta("Optional:")}
   ${chalk.cyan("-ns, --no-spec")}     Do not generate spec (test) files
@@ -125,11 +160,11 @@ ${chalk.bgMagenta("Optional:")}
 
 ${chalk.yellow("Example:")}
   nest-combo users -m -c -s
+  nest-combo -f project.yml
 `);
 }
 
 function showVersion() {
-  const { name, version } = require("../package.json");
   console.log(chalk.green(`${name} - version: ${version}`));
 }
 
@@ -156,4 +191,118 @@ function validate(moduleName) {
   }
 }
 
+function loadFromYml(file) {
+  try {
+    const fileContent = fs.readFileSync(file, "utf-8");
+    const ymlData = yaml.load(fileContent);
+
+    validateYml(ymlData);
+
+    const content = ymlData["nest-combo"];
+    const projectName = content["project-name"];
+    const packageManager = content["package-manager"] || "npm";
+    const dependencies = Array.isArray(content["dependencies"])
+      ? content["dependencies"]
+      : [];
+    const modules = Array.isArray(content["modules"]) ? content["modules"] : [];
+
+    const openVsCode = content["open-vscode"];
+
+    console.log(chalk.green(`Generating project: ${projectName}`));
+    generateProject(projectName, [`-p ${packageManager}`]);
+
+    if (dependencies.length > 0) {
+      console.log(chalk.blue("Installing dependencies..."));
+      installDependencies(projectName, dependencies);
+    } else {
+      console.log(chalk.yellow("No dependencies to install."));
+    }
+
+    const recursiveAddModule = (parentModule, modules) => {
+      for (const genModule of modules) {
+        const {
+          name,
+          resources: moduleResources,
+          options,
+          modules: subModules,
+        } = genModule;
+
+        const pathModule = parentModule ? `${parentModule}/${name}` : name;
+
+        console.log(chalk.cyan(`Processing module: ${pathModule}`));
+
+        if (!Array.isArray(moduleResources)) {
+          console.warn(
+            chalk.yellow(
+              `Invalid resources for module: ${pathModule}. Skipping.`
+            )
+          );
+          continue;
+        }
+
+        moduleResources.forEach((resourceName) => {
+          const resource = resources.find((r) => r.name === resourceName);
+
+          if (!resource) {
+            console.warn(
+              chalk.yellow(`Unknown resource type: ${resourceName}. Skipping.`)
+            );
+            return;
+          }
+
+          console.log(
+            chalk.magenta(`Generating ${resourceName} for ${pathModule}`)
+          );
+          resource.generator(pathModule, options, projectName);
+          console.log(
+            chalk.green("---------------------------------------------------")
+          );
+        });
+
+        if (subModules && subModules.length > 0) {
+          recursiveAddModule(pathModule, subModules);
+        }
+      }
+    };
+
+    recursiveAddModule(null, modules);
+
+    if (openVsCode) {
+      const workingDirectory = path.join(process.cwd(), projectName);
+      const command = "code .";
+      execSync(command, { cwd: workingDirectory });
+    }
+
+    console.log(
+      chalk.green(
+        "**************** succefully finished ************************** "
+      )
+    );
+    showVersion();
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+function printBanner() {
+  console.log(
+    chalk.magenta(`      
+███╗   ██╗███████╗███████╗████████╗       ██████╗ ██████╗ ███╗   ███╗██████╗  ██████╗ 
+████╗  ██║██╔════╝██╔════╝╚══██╔══╝      ██╔════╝██╔═══██╗████╗ ████║██╔══██╗██╔═══██╗
+██╔██╗ ██║█████╗  ███████╗   ██║   █████╗██║     ██║   ██║██╔████╔██║██████╔╝██║   ██║
+██║╚██╗██║██╔══╝  ╚════██║   ██║   ╚════╝██║     ██║   ██║██║╚██╔╝██║██╔══██╗██║   ██║
+██║ ╚████║███████╗███████║   ██║         ╚██████╗╚██████╔╝██║ ╚═╝ ██║██████╔╝╚██████╔╝
+╚═╝  ╚═══╝╚══════╝╚══════╝   ╚═╝          ╚═════╝ ╚═════╝ ╚═╝     ╚═╝╚═════╝  ╚═════╝         
+    `)
+  );
+  console.log(
+    chalk.bgWhite(
+      chalk.bold(
+        `********************************************************************** version: ${version} `
+      )
+    )
+  );
+}
+
 main();

package/lib/generate.js

@@ -21,34 +21,42 @@ const getNestBinary = () => {
   }
 };
 
+const nest = getNestBinary();
+
 /**
  * Generates a NestJS component (module, controller, service, etc.).
  * @param {string} type - The type of component to generate (e.g., "mo", "co", "s").
- * @param {string} moduleName - The name of the module to generate.
+ * @param {string} resourceName - The name of the resource to generate.
  * @param {Object} options - Additional options for the command.
  */
-const generateComponent = (type, moduleName, options) => {
-  const command = `${nest} g ${type} ${moduleName} ${options.join(" ")}`;
-  // console.log(`Running command: ${command}`);
-  execSync(command, { stdio: "inherit" });
-};
+const generateComponent = (type, resourceName, options, projectName) => {
+  const workingDirectory = projectName
+    ? path.join(process.cwd(), projectName)
+    : process.cwd();
 
-export const generateModule = (moduleName, options) =>
-  generateComponent("mo", moduleName, options);
+  const command = `${nest} ${type} ${resourceName} ${
+    Array.isArray(options) ? options.join(" ") : ""
+  }`;
 
-export const generateController = (moduleName, options) =>
-  generateComponent("co", moduleName, options);
+  execSync(command, { stdio: "inherit", cwd: workingDirectory });
+};
+export const generateProject = (projectName, options) =>
+  generateComponent("new", projectName, options);
 
-export const generateService = (moduleName, options) =>
-  generateComponent("s", moduleName, options);
+export const generateModule = (resourceName, options, projectName) =>
+  generateComponent("g mo", resourceName, options, projectName);
 
-export const generateGateway = (moduleName, options) =>
-  generateComponent("ga", moduleName, options);
+export const generateController = (resourceName, options, projectName) =>
+  generateComponent("g co", resourceName, options, projectName);
 
-export const generateInterceptor = (moduleName, options) =>
-  generateComponent("itc", moduleName, options);
+export const generateService = (resourceName, options, projectName) =>
+  generateComponent("g s", resourceName, options, projectName);
 
-export const generateMiddlware = (moduleName, options) =>
-  generateComponent("mi", moduleName, options);
+export const generateGateway = (resourceName, options, projectName) =>
+  generateComponent("g ga", resourceName, options, projectName);
 
-const nest = getNestBinary();
+export const generateInterceptor = (resourceName, options, projectName) =>
+  generateComponent("g itc", resourceName, options, projectName);
+
+export const generateMiddlware = (resourceName, options, projectName) =>
+  generateComponent("g mi", resourceName, options, projectName);

package/lib/install.js

@@ -0,0 +1,16 @@
+import { execSync } from "child_process";
+import path from "path";
+function installDependencies(projectName, dependencies) {
+  const cdCommand = `cd ${projectName}`;
+  const workingDirectory = path.join(process.cwd(), projectName);
+
+  execSync(cdCommand, { stdio: "inherit" });
+  if (Array.isArray(dependencies)) {
+    const command = `npm i ${dependencies
+      .map((dependency) => dependency.name)
+      .join(" ")}`;
+    execSync(command, { stdio: "inherit", cwd: workingDirectory });
+  }
+}
+
+export { installDependencies };

package/lib/utils.js

@@ -0,0 +1,107 @@
+import chalk from "chalk";
+/**
+ * Validate Yml File
+ * @param {Object} ymlData
+ */
+export function validateYml(ymlData) {
+  try {
+    if (!ymlData || typeof ymlData !== "object" || !ymlData["nest-combo"]) {
+      throw new Error("Invalid YAML file: Missing 'nest-combo' key.");
+    }
+
+    const nestCombo = ymlData["nest-combo"];
+
+    if (
+      !nestCombo["project-name"] ||
+      typeof nestCombo["project-name"] !== "string"
+    ) {
+      throw new Error("Missing or invalid 'project-name'. Must be a string.");
+    }
+
+    if (
+      nestCombo["package-manager"] &&
+      typeof nestCombo["package-manager"] !== "string"
+    ) {
+      throw new Error("Invalid 'package-manager'. Must be a string.");
+    }
+
+    if (nestCombo.dependencies && !Array.isArray(nestCombo.dependencies)) {
+      throw new Error("Invalid 'dependencies'. Must be an array.");
+    }
+    if (nestCombo.dependencies) {
+      nestCombo.dependencies.forEach((dep, index) => {
+        if (!dep.name || typeof dep.name !== "string") {
+          throw new Error(
+            `Invalid dependency at index ${index}. Each dependency must have a 'name' field as a string.`
+          );
+        }
+      });
+    }
+
+    if (nestCombo.modules && !Array.isArray(nestCombo.modules)) {
+      throw new Error("Invalid 'modules'. Must be an array.");
+    }
+    if (nestCombo.modules) {
+      validateModules(nestCombo.modules);
+    }
+
+    console.log(chalk.green("YAML file is valid."));
+  } catch (error) {
+    console.error(chalk.red(`Validation Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Recursively validate modules and sub-modules.
+ * @param {Array} modules - The list of modules to validate.
+ */
+function validateModules(modules) {
+  modules.forEach((module, index) => {
+    if (!module.name || typeof module.name !== "string") {
+      throw new Error(
+        `Invalid module at index ${index}. Each module must have a 'name' field as a string.`
+      );
+    }
+
+    if (module.resources && !Array.isArray(module.resources)) {
+      throw new Error(
+        `Invalid 'resources' for module '${module.name}'. Must be an array.`
+      );
+    }
+    if (module.resources) {
+      const validResources = [
+        "module",
+        "controller",
+        "service",
+        "gateway",
+        "middleware",
+        "interceptor",
+      ];
+      module.resources.forEach((resource, resIndex) => {
+        if (!validResources.includes(resource)) {
+          throw new Error(
+            `Invalid resource '${resource}' at index ${resIndex} for module '${
+              module.name
+            }'. Valid resources are: ${validResources.join(", ")}.`
+          );
+        }
+      });
+    }
+
+    if (module.options && !Array.isArray(module.options)) {
+      throw new Error(
+        `Invalid 'options' for module '${module.name}'. Must be an array.`
+      );
+    }
+
+    if (module.modules && !Array.isArray(module.modules)) {
+      throw new Error(
+        `Invalid 'modules' for module '${module.name}'. Must be an array.`
+      );
+    }
+    if (module.modules) {
+      validateModules(module.modules);
+    }
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nest-combo",
-  "version": "1.0.2",
+  "version": "1.1.1",
   "main": "lib/generate.js",
   "description": "A CLI tool to generate NestJS modules, controllers, and services, etc with single line commands.",
   "type": "module",
@@ -25,6 +25,11 @@
   "license": "MIT",
   "dependencies": {
     "@nestjs/cli": "^11.0.5",
-    "chalk": "^5.4.1"
+    "chalk": "^5.4.1",
+    "js-yaml": "^4.1.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vinisalves/nest-combo.git"
   }
 }

package/project.example.yml

@@ -0,0 +1,48 @@
+#YML example for loading a full project from scracth
+nest-combo:
+  project-name: my-new-project
+  open-vscode: true # open vscode when process is finished
+  package-manager: npm # npm | yarn | pnmp
+  dependencies:
+    - name: "@nestjs/config"    
+    - name: "@nestjs/bull"
+    - name: "class-transformer"
+    - name: "class-validator"
+    - name: "nestjs-twilio"
+  modules:
+    - name: core
+      resources:
+          - module
+      modules:
+        - name: user
+          resources:
+            - module
+            - controller
+            - service
+          options:
+              - --no-spec            
+          modules:
+            - name: subUsers
+              resources:
+              - module
+              - controller
+              - service
+              options:
+                - --no-spec
+              
+        - name: auth
+          resources: 
+            - module
+            - controller
+            - service
+            - interceptor
+    - name: product
+      resources:
+        - module
+        - controller
+        - service
+    - name: payment
+      resources:
+        - module
+        - controller
+        - service