nest-combo 1.2.0 → 1.2.2

package/jest.config.mjs

@@ -0,0 +1,198 @@
+/**
+ * For a detailed explanation regarding each configuration property, visit:
+ * https://jestjs.io/docs/configuration
+ */
+
+/** @type {import('jest').Config} */
+const config = {
+  // All imported modules in your tests should be mocked automatically
+  // automock: false,
+
+  // Stop running tests after `n` failures
+  // bail: 0,
+
+  // The directory where Jest should store its cached dependency information
+  // cacheDirectory: "/tmp/jest_rs",
+
+  // Automatically clear mock calls, instances, contexts and results before every test
+  clearMocks: true,
+
+  // Indicates whether the coverage information should be collected while executing the test
+  collectCoverage: true,
+
+  // An array of glob patterns indicating a set of files for which coverage information should be collected
+  // collectCoverageFrom: undefined,
+
+  // The directory where Jest should output its coverage files
+  coverageDirectory: 'coverage',
+
+  // An array of regexp pattern strings used to skip coverage collection
+  // coveragePathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // Indicates which provider should be used to instrument code for coverage
+  coverageProvider: 'v8',
+
+  // A list of reporter names that Jest uses when writing coverage reports
+  // coverageReporters: [
+  //   "json",
+  //   "text",
+  //   "lcov",
+  //   "clover"
+  // ],
+
+  // An object that configures minimum threshold enforcement for coverage results
+  // coverageThreshold: undefined,
+
+  // A path to a custom dependency extractor
+  // dependencyExtractor: undefined,
+
+  // Make calling deprecated APIs throw helpful error messages
+  // errorOnDeprecated: false,
+
+  // The default configuration for fake timers
+  // fakeTimers: {
+  //   "enableGlobally": false
+  // },
+
+  // Force coverage collection from ignored files using an array of glob patterns
+  // forceCoverageMatch: [],
+
+  // A path to a module which exports an async function that is triggered once before all test suites
+  // globalSetup: undefined,
+
+  // A path to a module which exports an async function that is triggered once after all test suites
+  // globalTeardown: undefined,
+
+  // A set of global variables that need to be available in all test environments
+  // globals: {},
+
+  // The maximum amount of workers used to run your tests. Can be specified as % or a number. E.g. maxWorkers: 10% will use 10% of your CPU amount + 1 as the maximum worker number. maxWorkers: 2 will use a maximum of 2 workers.
+  // maxWorkers: "50%",
+
+  // An array of directory names to be searched recursively up from the requiring module's location
+  // moduleDirectories: [
+  //   "node_modules"
+  // ],
+
+  // An array of file extensions your modules use
+  // moduleFileExtensions: [
+  //   "js",
+  //   "mjs",
+  //   "cjs",
+  //   "jsx",
+  //   "ts",
+  //   "tsx",
+  //   "json",
+  //   "node"
+  // ],
+
+  // A map from regular expressions to module names or to arrays of module names that allow to stub out resources with a single module
+  // moduleNameMapper: {},
+
+  // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
+  // modulePathIgnorePatterns: [],
+
+  // Activates notifications for test results
+  // notify: false,
+
+  // An enum that specifies notification mode. Requires { notify: true }
+  // notifyMode: "failure-change",
+
+  // A preset that is used as a base for Jest's configuration
+  // preset: undefined,
+
+  // Run tests from one or more projects
+  // projects: undefined,
+
+  // Use this configuration option to add custom reporters to Jest
+  // reporters: undefined,
+
+  // Automatically reset mock state before every test
+  // resetMocks: false,
+
+  // Reset the module registry before running each individual test
+  // resetModules: false,
+
+  // A path to a custom resolver
+  // resolver: undefined,
+
+  // Automatically restore mock state and implementation before every test
+  // restoreMocks: false,
+
+  // The root directory that Jest should scan for tests and modules within
+  // rootDir: undefined,
+
+  // A list of paths to directories that Jest should use to search for files in
+  // roots: [
+  //   "<rootDir>"
+  // ],
+
+  // Allows you to use a custom runner instead of Jest's default test runner
+  // runner: "jest-runner",
+
+  // The paths to modules that run some code to configure or set up the testing environment before each test
+  // setupFiles: [],
+
+  // A list of paths to modules that run some code to configure or set up the testing framework before each test
+  // setupFilesAfterEnv: [],
+
+  // The number of seconds after which a test is considered as slow and reported as such in the results.
+  // slowTestThreshold: 5,
+
+  // A list of paths to snapshot serializer modules Jest should use for snapshot testing
+  // snapshotSerializers: [],
+
+  // The test environment that will be used for testing
+  // testEnvironment: "jest-environment-node",
+
+  // Options that will be passed to the testEnvironment
+  // testEnvironmentOptions: {},
+
+  // Adds a location field to test results
+  // testLocationInResults: false,
+
+  // The glob patterns Jest uses to detect test files
+  // testMatch: [
+  //   "**/__tests__/**/*.[jt]s?(x)",
+  //   "**/?(*.)+(spec|test).[tj]s?(x)"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
+  // testPathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // The regexp pattern or array of patterns that Jest uses to detect test files
+  // testRegex: [],
+
+  // This option allows the use of a custom results processor
+  // testResultsProcessor: undefined,
+
+  // This option allows use of a custom test runner
+  // testRunner: "jest-circus/runner",
+
+  // A map from regular expressions to paths to transformers
+  // transform: undefined,
+
+  // An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation
+  // transformIgnorePatterns: [
+  //   "/node_modules/",
+  //   "\\.pnp\\.[^\\/]+$"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them
+  // unmockedModulePathPatterns: undefined,
+
+  // Indicates whether each individual test should be reported during the run
+  // verbose: undefined,
+
+  // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode
+  // watchPathIgnorePatterns: [],
+
+  // Whether to use watchman for file crawling
+  // watchman: true,
+};
+
+export default config;

package/lib/generate.js

@@ -1,28 +1,6 @@
-import { execSync } from "child_process";
-import { fileURLToPath } from "url";
-import path from "path";
-import chalk from "chalk";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const getNestBinary = () => {
-  try {
-    execSync("nest --version", { stdio: "ignore" });
-    console.log(
-      chalk.bgMagenta("*** Using global Nest CLI Installation *** \n")
-    );
-    return "nest";
-  } catch (error) {
-    console.log(
-      chalk.bgBlueBright("*** Using local Nest CLI Installation *** \n")
-    );
-    return path.join(__dirname, "../node_modules/.bin/nest");
-  }
-};
-
-const nest = getNestBinary();
-
+import { execSync } from 'child_process';
+import nestCli from './nestBynary.js';
+import path from 'path';
 /**
  * Generates a NestJS component (module, controller, service, etc.).
  * @param {string} type - The type of component to generate (e.g., "mo", "co", "s").
@@ -34,29 +12,29 @@ const generateComponent = (type, resourceName, options, projectName) => {
     ? path.join(process.cwd(), projectName)
     : process.cwd();
 
-  const command = `${nest} ${type} ${resourceName} ${
-    Array.isArray(options) ? options.join(" ") : ""
+  const command = `${nestCli} ${type} ${resourceName} ${
+    Array.isArray(options) ? options.join(' ') : ''
   }`;
 
-  execSync(command, { stdio: "inherit", cwd: workingDirectory });
+  execSync(command, { stdio: 'inherit', cwd: workingDirectory });
 };
 export const generateProject = (projectName, options) =>
-  generateComponent("new", projectName, options);
+  generateComponent('new', projectName, options);
 
 export const generateModule = (resourceName, options, projectName) =>
-  generateComponent("g mo", resourceName, options, projectName);
+  generateComponent('g mo', resourceName, options, projectName);
 
 export const generateController = (resourceName, options, projectName) =>
-  generateComponent("g co", resourceName, options, projectName);
+  generateComponent('g co', resourceName, options, projectName);
 
 export const generateService = (resourceName, options, projectName) =>
-  generateComponent("g s", resourceName, options, projectName);
+  generateComponent('g s', resourceName, options, projectName);
 
 export const generateGateway = (resourceName, options, projectName) =>
-  generateComponent("g ga", resourceName, options, projectName);
+  generateComponent('g ga', resourceName, options, projectName);
 
 export const generateInterceptor = (resourceName, options, projectName) =>
-  generateComponent("g itc", resourceName, options, projectName);
+  generateComponent('g itc', resourceName, options, projectName);
 
 export const generateMiddlware = (resourceName, options, projectName) =>
-  generateComponent("g mi", resourceName, options, projectName);
+  generateComponent('g mi', resourceName, options, projectName);

package/lib/installDependencies.js

@@ -0,0 +1,65 @@
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import path from 'path';
+
+/**
+ * Installs the specified dependencies into the given project using the specified package manager.
+ *
+ * This function performs the following steps:
+ * 1. Changes the working directory to the specified project folder.
+ * 2. Logs the list of dependencies to be installed.
+ * 3. Executes the appropriate package manager command to install the dependencies.
+ *
+ * @param {string} projectName - The name of the project folder where dependencies will be installed.
+ * @param {string[]} dependencies - An array of dependency names (e.g., package names) to install.
+ * @param {string} packageManager - The package manager to use: 'npm', 'yarn', or 'pnpm'.
+ * @throws {Error} Throws an error if the installation command fails during execution.
+ */
+export default function installDependencies(
+  projectName,
+  dependencies,
+  packageManager = 'npm',
+) {
+  const workingDirectory = path.join(process.cwd(), projectName);
+
+  const supportedPackageManagers = ['npm', 'yarn', 'pnpm'];
+  if (!supportedPackageManagers.includes(packageManager)) {
+    throw new Error(
+      `Unsupported package manager: ${packageManager}. Supported options are: ${supportedPackageManagers.join(
+        ', ',
+      )}`,
+    );
+  }
+
+  try {
+    if (Array.isArray(dependencies) && dependencies.length > 0) {
+      console.log(chalk.cyan('Installing dependencies:'));
+      for (const dependency of dependencies) {
+        console.log(chalk.cyan(`- ${dependency}`));
+      }
+
+      let command;
+      switch (packageManager) {
+        case 'npm':
+          command = `npm install ${dependencies.join(' ')}`;
+          break;
+        case 'yarn':
+          command = `yarn add ${dependencies.join(' ')}`;
+          break;
+        case 'pnpm':
+          command = `pnpm add ${dependencies.join(' ')}`;
+          break;
+        default:
+          throw new Error(`Unsupported package manager: ${packageManager}`);
+      }
+
+      execSync(command, { stdio: 'inherit', cwd: workingDirectory });
+      console.log(chalk.green('Dependencies installed successfully.'));
+    } else {
+      console.log(chalk.yellow('No dependencies to install.'));
+    }
+  } catch (error) {
+    console.error(chalk.red(`Error installing dependencies: ${error.message}`));
+    throw error;
+  }
+}

package/lib/nestBynary.js

@@ -0,0 +1,38 @@
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Determines the path to the Nest CLI binary to use for project generation.
+ *
+ * This function checks if the globally installed Nest CLI is available by running `nest --version`.
+ * - If the global Nest CLI is found, it logs a message indicating that the global installation will be used and returns `"nest"`.
+ * - If the global Nest CLI is not found, it falls back to using the locally cached Nest CLI binary from the `node_modules` directory.
+ *
+ * @returns {string} The command or path to the Nest CLI binary:
+ *   - `"nest"` if the global Nest CLI is available.
+ *   - A local path (e.g., `../node_modules/.bin/nest`) if the global Nest CLI is not available.
+ */
+const getNestBinary = () => {
+  try {
+    execSync('nest --version', { stdio: 'ignore' });
+    console.log(
+      chalk.bgGreenBright('*** Using your Nest CLI Installation *** \n'),
+    );
+    return 'nest';
+  } catch (_) {
+    console.log(
+      chalk.bgBlueBright(
+        '*** Using nest-combo cached Nest CLI Installation *** \n',
+      ),
+    );
+    return path.join(__dirname, '../node_modules/.bin/nest');
+  }
+};
+
+const nestCli = getNestBinary();
+
+export default nestCli;

package/lib/outputs.js

@@ -0,0 +1,73 @@
+import chalk from 'chalk';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const { name, version } = require('../package.json');
+
+/**
+ * Print the ASCII Art Banner
+ */
+export function printBanner() {
+  console.log(
+    chalk.magenta(`      
+  ███╗   ██╗███████╗███████╗████████╗       ██████╗ ██████╗ ███╗   ███╗██████╗  ██████╗ 
+  ████╗  ██║██╔════╝██╔════╝╚══██╔══╝      ██╔════╝██╔═══██╗████╗ ████║██╔══██╗██╔═══██╗
+  ██╔██╗ ██║█████╗  ███████╗   ██║   █████╗██║     ██║   ██║██╔████╔██║██████╔╝██║   ██║
+  ██║╚██╗██║██╔══╝  ╚════██║   ██║   ╚════╝██║     ██║   ██║██║╚██╔╝██║██╔══██╗██║   ██║
+  ██║ ╚████║███████╗███████║   ██║         ╚██████╗╚██████╔╝██║ ╚═╝ ██║██████╔╝╚██████╔╝
+  ╚═╝  ╚═══╝╚══════╝╚══════╝   ╚═╝          ╚═════╝ ╚═════╝ ╚═╝     ╚═╝╚═════╝  ╚═════╝         
+      `),
+  );
+  console.log(
+    chalk.bgWhite(
+      chalk.bold(
+        `********************************************************************** version: ${version} `,
+      ),
+    ),
+  );
+}
+
+/**
+ * Show Instructions how to use nest-combo
+ */
+export function showUsage() {
+  console.log(`
+  ${chalk.yellow('Usage:')} nest-combo <<project|module>-name> [options]
+  
+  ${chalk.yellow('Options:')}
+    ${chalk.cyan('-new,   --new-project')}    Create a new project
+    ${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.bgMagenta('Optional for Modules:')}
+    ${chalk.cyan('-ns, --no-spec')}     Do not generate spec (test) files
+    ${chalk.cyan(
+      '-dr, --dry-run',
+    )}     Report actions that would be taken without writing out results.
+  
+  ${chalk.yellow('Example:')}
+    To create a new project:
+    ${chalk.cyan(
+      `nest-combo my-project-name -new ${chalk.gray(
+        '# VsCode will be opened directly into your new project',
+      )}`,
+    )}
+    
+    To create a module, controller and servide in a single line command
+    ${chalk.cyan('nest-combo users -m -c -s')} 
+  
+    To load a full project from a yml file
+    ${chalk.cyan('nest-combo -f project.yml')}
+  `);
+}
+
+/**
+ * Show current version
+ */
+export function showVersion() {
+  console.log(chalk.green(`${name} - version: ${version}`));
+}

package/lib/resources.js

@@ -0,0 +1,62 @@
+import {
+  generateModule,
+  generateController,
+  generateService,
+  generateInterceptor,
+  generateGateway,
+  generateMiddlware,
+} from './generate.js';
+
+/**
+ * An array of resource configurations used to define NestJS components
+ * such as modules, controllers, services, gateways, middleware, and interceptors.
+ *
+ * Each configuration object contains the following properties:
+ * @typedef {Object} ResourceConfig
+ * @property {string} name - The name of the resource (e.g., "module", "controller").
+ * @property {string} flag - The short flag used in the CLI command (e.g., "-m" for module).
+ * @property {string} longFlag - The long flag used in the CLI command (e.g., "--module" for module).
+ * @property {Function} generator - The function responsible for generating the resource.
+ *
+ * This array is used to dynamically generate resources based on user input.
+ * Each `generator` function is imported from the `./generate.js` file and corresponds
+ * to a specific NestJS component.
+ */
+export default [
+  {
+    name: 'module',
+    flag: '-m',
+    longFlag: '--module',
+    generator: generateModule,
+  },
+  {
+    name: 'controller',
+    flag: '-c',
+    longFlag: '--controller',
+    generator: generateController,
+  },
+  {
+    name: 'service',
+    flag: '-s',
+    longFlag: '--service',
+    generator: generateService,
+  },
+  {
+    name: 'gateway',
+    flag: '-g',
+    longFlag: '--gateway',
+    generator: generateGateway,
+  },
+  {
+    name: 'middleware',
+    flag: '-mw',
+    longFlag: '--middleware',
+    generator: generateMiddlware,
+  },
+  {
+    name: 'interceptor',
+    flag: '-itc',
+    longFlag: '--interceptor',
+    generator: generateInterceptor,
+  },
+];

package/lib/utils.js

@@ -1,26 +1,58 @@
-import chalk from "chalk";
+import chalk from 'chalk';
+import resources from './resources.js';
+import { showUsage } from '../lib/outputs.js';
+
+/**
+ * Validate resrouces creation
+ * @param {string} moduleName
+ * @param {Array} args - List of input arguments
+ */
+
+export function validateResources(moduleName, args) {
+  if (!moduleName) {
+    console.error(chalk.red('Error:') + ' Module name is required.');
+    showUsage();
+    process.exit(1);
+  }
+  const hasComponentFlags = resources.some(
+    (component) =>
+      args.includes(component.flag) || args.includes(component.longFlag),
+  );
+
+  if (!hasComponentFlags) {
+    console.error(
+      chalk.red('Error:') +
+        ` At least one flag (${resources
+          .map((resource) => resource.flag)
+          .join(',')}) is required.`,
+    );
+    showUsage();
+    process.exit(1);
+  }
+}
+
 /**
  * Validate Yml File
  * @param {Object} ymlData
  */
 export function validateYml(ymlData) {
   try {
-    if (!ymlData || typeof ymlData !== "object" || !ymlData["nest-combo"]) {
+    if (!ymlData || typeof ymlData !== 'object' || !ymlData['nest-combo']) {
       throw new Error("Invalid YAML file: Missing 'nest-combo' key.");
     }
 
-    const nestCombo = ymlData["nest-combo"];
+    const nestCombo = ymlData['nest-combo'];
 
     if (
-      !nestCombo["project-name"] ||
-      typeof nestCombo["project-name"] !== "string"
+      !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"
+      nestCombo['package-manager'] &&
+      typeof nestCombo['package-manager'] !== 'string'
     ) {
       throw new Error("Invalid 'package-manager'. Must be a string.");
     }
@@ -36,7 +68,7 @@ export function validateYml(ymlData) {
       validateModules(nestCombo.modules);
     }
 
-    console.log(chalk.green("YAML file is valid."));
+    console.log(chalk.green('YAML file is valid.'));
   } catch (error) {
     console.error(chalk.red(`Validation Error: ${error.message}`));
     process.exit(1);
@@ -49,32 +81,32 @@ export function validateYml(ymlData) {
  */
 function validateModules(modules) {
   modules.forEach((module, index) => {
-    if (!module.name || typeof module.name !== "string") {
+    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.`
+        `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.`
+        `Invalid 'resources' for module '${module.name}'. Must be an array.`,
       );
     }
     if (module.resources) {
       const validResources = [
-        "module",
-        "controller",
-        "service",
-        "gateway",
-        "middleware",
-        "interceptor",
+        '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(", ")}.`
+            }'. Valid resources are: ${validResources.join(', ')}.`,
           );
         }
       });
@@ -82,13 +114,13 @@ function validateModules(modules) {
 
     if (module.options && !Array.isArray(module.options)) {
       throw new Error(
-        `Invalid 'options' for module '${module.name}'. Must be an array.`
+        `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.`
+        `Invalid 'modules' for module '${module.name}'. Must be an array.`,
       );
     }
     if (module.modules) {