@neohm/nh-cli 1.0.0 → 1.0.1

package/README.md

@@ -50,7 +50,7 @@ The project root is auto-detected by walking up from the current directory for a
 $ nh gen
 ? Module name (e.g. business): business
 ? Entity name (e.g. BusinessClient): BusinessClient
-? Table name (e.g. nh_business_clients): nh_business_clients
+? Table name (e.g. nh_user_details): nh_user_details
 ? Create controller (BusinessClientController)? Yes
 ? Create DTO (AddBusinessClientDataDto)? Yes
 ? Create data processor (BusinessClientDataProcessor)? Yes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neohm/nh-cli",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "nh — Command Line Interface for neohm. NestJS projects",
   "main": "src/index.js",
   "bin": {

package/src/commands/gen.js

@@ -1,15 +1,15 @@
-'use strict';
+"use strict";
 
-const fs = require('fs');
-const path = require('path');
-const inquirer = require('inquirer');
-const chalk = require('chalk');
+const fs = require("fs");
+const path = require("path");
+const inquirer = require("inquirer");
+const chalk = require("chalk");
 
-const { projectPaths, MODULE_SUBFOLDERS } = require('../lib/paths');
-const naming = require('../lib/naming');
-const tpl = require('../lib/templates');
-const { writeFile, report, log, ensureDir } = require('../lib/fs.utils');
-const sync = require('../lib/sync.engine');
+const { projectPaths, MODULE_SUBFOLDERS } = require("../lib/paths");
+const naming = require("../lib/naming");
+const tpl = require("../lib/templates");
+const { writeFile, report, log, ensureDir } = require("../lib/fs.utils");
+const sync = require("../lib/sync.engine");
 
 async function gen() {
   const paths = projectPaths();
@@ -18,10 +18,10 @@ async function gen() {
   // 1. Module ---------------------------------------------------------------
   const { moduleNameRaw } = await inquirer.prompt([
     {
-      type: 'input',
-      name: 'moduleNameRaw',
-      message: 'Module name (e.g. business):',
-      validate: (v) => (v && v.trim() ? true : 'Module name is required'),
+      type: "input",
+      name: "moduleNameRaw",
+      message: "Module name:",
+      validate: (v) => (v && v.trim() ? true : "Module name is required"),
     },
   ]);
   const moduleDot = naming.toDotCase(moduleNameRaw);
@@ -44,20 +44,16 @@ async function gen() {
     path.join(moduleDir, `${moduleDot}.module.ts`),
     paths.root,
   );
-  const es6Path = path.join(moduleDir, 'es6.classes.ts');
-  report(
-    writeFile(es6Path, tpl.emptyEs6Classes()),
-    es6Path,
-    paths.root,
-  );
+  const es6Path = path.join(moduleDir, "es6.classes.ts");
+  report(writeFile(es6Path, tpl.emptyEs6Classes()), es6Path, paths.root);
 
   // 2. Entity ---------------------------------------------------------------
   const { entityName } = await inquirer.prompt([
     {
-      type: 'input',
-      name: 'entityName',
-      message: 'Entity name (e.g. BusinessClient):',
-      validate: (v) => (v && v.trim() ? true : 'Entity name is required'),
+      type: "input",
+      name: "entityName",
+      message: "Entity name (PascalCase):",
+      validate: (v) => (v && v.trim() ? true : "Entity name is required"),
     },
   ]);
   const n = tpl.names(entityName);
@@ -65,66 +61,79 @@ async function gen() {
   // 3. Table ----------------------------------------------------------------
   const { tableName } = await inquirer.prompt([
     {
-      type: 'input',
-      name: 'tableName',
-      message: 'Table name (e.g. nh_business_clients):',
-      default: `nh_${naming.toWords(entityName).join('_')}s`,
-      validate: (v) => (v && v.trim() ? true : 'Table name is required'),
+      type: "input",
+      name: "tableName",
+      message: "Table name:",
+      default: `nh_${naming.toWords(entityName).join("_")}s`,
+      validate: (v) => (v && v.trim() ? true : "Table name is required"),
     },
   ]);
 
-  const entityPath = path.join(moduleDir, 'entities', n.entityFile);
+  // Always generate: attributes DTO, entity, subscriber, job
+  const attrDtoPath = path.join(moduleDir, "dtos", n.attributesDtoFile);
+  report(writeFile(attrDtoPath, tpl.attributesDto(entityName)), attrDtoPath, paths.root);
+
+  const entityPath = path.join(moduleDir, "entities", n.entityFile);
   report(
     writeFile(entityPath, tpl.entity(entityName, tableName)),
     entityPath,
     paths.root,
   );
 
-  // 4-7. Optional artifacts -------------------------------------------------
-  const answers = await inquirer.prompt([
-    { type: 'confirm', name: 'controller', message: `Create controller (${n.controllerClass})?`, default: true },
-    { type: 'confirm', name: 'dto', message: `Create DTO (${n.dtoClass})?`, default: true },
-    { type: 'confirm', name: 'processor', message: `Create data processor (${n.processorClass})?`, default: true },
-    { type: 'confirm', name: 'migration', message: `Create migration (M-Add${n.pascal}Table)?`, default: true },
+  const jobPath = path.join(moduleDir, "jobs", n.jobFile);
+  report(writeFile(jobPath, tpl.job(entityName)), jobPath, paths.root);
+
+  const subscriberPath = path.join(moduleDir, "subscribers", n.subscriberFile);
+  report(writeFile(subscriberPath, tpl.subscriber(entityName)), subscriberPath, paths.root);
+
+  // 4. Optional: controller -------------------------------------------------
+  const { controller } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "controller",
+      message: `Create controller (${n.controllerClass})?`,
+      default: true,
+    },
   ]);
 
-  if (answers.controller) {
-    const p = path.join(moduleDir, 'controllers', n.controllerFile);
+  if (controller) {
+    const p = path.join(moduleDir, "controllers", n.controllerFile);
     report(writeFile(p, tpl.controller(entityName)), p, paths.root);
   }
 
-  // A processor depends on its DTO type, so generate the DTO when either the
-  // DTO step or the processor step is selected.
-  if (answers.dto || answers.processor) {
-    if (!answers.dto) {
-      log.warn(`DTO ${n.dtoClass} is generated because the data processor depends on it.`);
-    }
-    const p = path.join(moduleDir, 'dtos', n.dtoFile);
-    report(writeFile(p, tpl.dto(entityName)), p, paths.root);
-  }
+  // 5. Optional: data processor (includes Add*DataDto) ----------------------
+  const { processor } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "processor",
+      message: `Create data processor (${n.processorClass})?`,
+      default: true,
+    },
+  ]);
 
-  if (answers.processor) {
-    const p = path.join(moduleDir, 'libraries', n.processorFile);
-    report(writeFile(p, tpl.processor(entityName)), p, paths.root);
-  }
+  if (processor) {
+    const dtoPath = path.join(moduleDir, "dtos", n.dtoFile);
+    report(writeFile(dtoPath, tpl.dto(entityName)), dtoPath, paths.root);
 
-  if (answers.migration) {
-    const ts = Date.now();
-    const file = `${ts}M-Add${n.pascal}Table.ts`;
-    const p = path.join(paths.migrationsDir, file);
-    report(writeFile(p, tpl.genMigration(entityName, tableName, ts)), p, paths.root);
+    const procPath = path.join(moduleDir, "libraries", n.processorFile);
+    report(writeFile(procPath, tpl.processor(entityName)), procPath, paths.root);
   }
 
   // Auto-wire: rebuild this module's barrel and register it in app.module.ts.
-  log.info('\nWiring imports...');
-  const mod = sync.scanModule(moduleDir, path.join(moduleDir, `${moduleDot}.module.ts`));
+  log.info("\nWiring imports...");
+  const mod = sync.scanModule(
+    moduleDir,
+    path.join(moduleDir, `${moduleDot}.module.ts`),
+  );
   const plan = sync.buildPlan(paths, [mod]);
   const written = sync.applyPlan(plan);
-  for (const w of written) report('overwritten', w, paths.root);
-  if (!written.length) log.info('  (already in sync)');
+  for (const w of written) report("overwritten", w, paths.root);
+  if (!written.length) log.info("  (already in sync)");
 
   log.done(`Module "${moduleDot}" scaffolded.`);
-  console.log(chalk.dim('Run `nh sync` anytime to re-wire imports after manual edits.'));
+  console.log(
+    chalk.dim("Run `nh sync` anytime to re-wire imports after manual edits."),
+  );
 }
 
 module.exports = gen;

package/src/commands/migration.js

@@ -1,35 +1,39 @@
-'use strict';
+"use strict";
 
-const path = require('path');
-const inquirer = require('inquirer');
+const path = require("path");
+const inquirer = require("inquirer");
 
-const { projectPaths } = require('../lib/paths');
-const naming = require('../lib/naming');
-const tpl = require('../lib/templates');
-const { writeFile, report, log } = require('../lib/fs.utils');
+const { projectPaths } = require("../lib/paths");
+const naming = require("../lib/naming");
+const tpl = require("../lib/templates");
+const { writeFile, report, log } = require("../lib/fs.utils");
 
 async function migration() {
   const paths = projectPaths();
 
   const { tableName, migrationName } = await inquirer.prompt([
     {
-      type: 'input',
-      name: 'tableName',
-      message: 'Table name (e.g. nh_business_clients):',
-      validate: (v) => (v && v.trim() ? true : 'Table name is required'),
+      type: "input",
+      name: "tableName",
+      message: "Table name (e.g. nh_user_details):",
+      validate: (v) => (v && v.trim() ? true : "Table name is required"),
     },
     {
-      type: 'input',
-      name: 'migrationName',
-      message: 'Migration name (e.g. AddBusinessClientTable):',
-      validate: (v) => (v && v.trim() ? true : 'Migration name is required'),
+      type: "input",
+      name: "migrationName",
+      message: "Migration name (e.g. AddBusinessClientTable):",
+      validate: (v) => (v && v.trim() ? true : "Migration name is required"),
     },
   ]);
 
   const ts = Date.now();
   const file = `${ts}M-${naming.toPascalCase(migrationName)}.ts`;
   const p = path.join(paths.migrationsDir, file);
-  report(writeFile(p, tpl.migration(migrationName, tableName, ts)), p, paths.root);
+  report(
+    writeFile(p, tpl.migration(migrationName, tableName, ts)),
+    p,
+    paths.root,
+  );
   log.done(`Migration created (${file}).`);
 }
 

package/src/commands/seed.js

@@ -1,28 +1,28 @@
-'use strict';
+"use strict";
 
-const path = require('path');
-const inquirer = require('inquirer');
+const path = require("path");
+const inquirer = require("inquirer");
 
-const { projectPaths } = require('../lib/paths');
-const naming = require('../lib/naming');
-const tpl = require('../lib/templates');
-const { writeFile, report, log } = require('../lib/fs.utils');
+const { projectPaths } = require("../lib/paths");
+const naming = require("../lib/naming");
+const tpl = require("../lib/templates");
+const { writeFile, report, log } = require("../lib/fs.utils");
 
 async function seed() {
   const paths = projectPaths();
 
   const { tableName, seedName } = await inquirer.prompt([
     {
-      type: 'input',
-      name: 'tableName',
-      message: 'Table name (e.g. nh_business_clients):',
-      validate: (v) => (v && v.trim() ? true : 'Table name is required'),
+      type: "input",
+      name: "tableName",
+      message: "Table name (e.g. nh_user_details):",
+      validate: (v) => (v && v.trim() ? true : "Table name is required"),
     },
     {
-      type: 'input',
-      name: 'seedName',
-      message: 'Seed name (e.g. SeedBusinessClients):',
-      validate: (v) => (v && v.trim() ? true : 'Seed name is required'),
+      type: "input",
+      name: "seedName",
+      message: "Seed name (e.g. SeedBusinessClients):",
+      validate: (v) => (v && v.trim() ? true : "Seed name is required"),
     },
   ]);
 

package/src/lib/sync.engine.js

@@ -18,6 +18,8 @@ const path = require('path');
 const CATEGORIES = [
   { key: 'controllers', folder: 'controllers' },
   { key: 'services', folder: 'services' },
+  { key: 'libraries', folder: 'libraries' },
+  { key: 'dtos', folder: 'dtos' },
   { key: 'jobs', folder: 'jobs' },
   { key: 'subscribers', folder: 'subscribers' },
 ];

package/src/lib/templates.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { toDotCase, toPascalCase, toKebabCase } = require('./naming');
+const { toDotCase, toPascalCase, toKebabCase, toCamelCase } = require('./naming');
 
 /**
  * Code templates. All generated code imports shared base classes from the
@@ -14,18 +14,26 @@ const { toDotCase, toPascalCase, toKebabCase } = require('./naming');
 function names(base) {
   const dot = toDotCase(base);
   const pascal = toPascalCase(base);
+  const camel = toCamelCase(base);
   return {
     dot,
     pascal,
+    camel,
     kebab: toKebabCase(base),
     entityClass: `${pascal}Entity`,
     entityFile: `${dot}.entity.ts`,
+    attributesDtoClass: `${pascal}AttributesDto`,
+    attributesDtoFile: `${dot}.attributes.dto.ts`,
     controllerClass: `${pascal}Controller`,
     controllerFile: `${dot}.controller.ts`,
     dtoClass: `Add${pascal}DataDto`,
     dtoFile: `add.${dot}.data.dto.ts`,
     processorClass: `${pascal}DataProcessor`,
     processorFile: `${dot}.data.processor.ts`,
+    subscriberClass: `${pascal}Subscriber`,
+    subscriberFile: `${dot}.subscriber.ts`,
+    jobClass: `${pascal}Job`,
+    jobFile: `${dot}.job.ts`,
   };
 }
 
@@ -33,12 +41,20 @@ function entity(base, tableName) {
   const n = names(base);
   return `import { Column, Entity } from 'typeorm';
 import { CommonEntity } from '@neohm/nestend';
+import { ${n.attributesDtoClass} } from '../dtos/${n.dot}.attributes.dto';
 
 @Entity({ name: '${tableName}' })
 export class ${n.entityClass} extends CommonEntity {
-  // TODO: declare columns for ${n.pascal}.
   @Column({ type: 'jsonb' })
-  attributes: Record<string, any>;
+  attributes: ${n.attributesDtoClass};
+}
+`;
+}
+
+function attributesDto(base) {
+  const n = names(base);
+  return `export class ${n.attributesDtoClass} {
+  // TODO: declare attribute fields for ${n.pascal}.
 }
 `;
 }
@@ -94,6 +110,50 @@ export class ${n.processorClass} extends CommonDataProcessor {
 `;
 }
 
+function subscriber(base) {
+  const n = names(base);
+  return `import { CommonSubscriber } from '@neohm/nestend';
+import { EventSubscriber } from 'typeorm';
+import { ${n.entityClass} } from '../entities/${n.dot}.entity';
+import { DataSource } from 'typeorm';
+import { ${n.jobClass} } from '../jobs/${n.dot}.job';
+
+@EventSubscriber()
+export class ${n.subscriberClass} extends CommonSubscriber<${n.entityClass}> {
+  constructor(
+    protected readonly datasource: DataSource,
+    protected readonly entityJob: ${n.jobClass},
+  ) {
+    super();
+    datasource.subscribers.push(this);
+  }
+
+  listenTo() {
+    return ${n.entityClass};
+  }
+}
+`;
+}
+
+function job(base) {
+  const n = names(base);
+  return `import { CommonJob, QueueService } from '@neohm/nestend';
+import { Injectable } from '@nestjs/common';
+import { JobMap } from '../../constants/job.constants';
+
+@Injectable()
+export class ${n.jobClass} extends CommonJob {
+  constructor(protected readonly queueService: QueueService) {
+    super(JobMap.${n.camel}Job);
+  }
+
+  async handle(event: any): Promise<void> {
+    return;
+  }
+}
+`;
+}
+
 /**
  * Migration generated as part of `nh gen`, stubbed with the columns the
  * generated entity carries (rootPrimary + created_by FK from CommonEntity,
@@ -165,6 +225,8 @@ function emptyEs6Classes() {
   return `export const es6Classes = {
   controllers: [],
   services: [],
+  libraries: [],
+  dtos: [],
   jobs: [],
   subscribers: [],
 };
@@ -187,6 +249,7 @@ import { es6Classes } from './es6.classes';
   controllers: [...es6Classes.controllers],
   providers: [
     ...es6Classes.services,
+    ...es6Classes.libraries,
     ...es6Classes.jobs,
     ...es6Classes.subscribers,
   ],
@@ -198,9 +261,12 @@ export class ${pascal}Module {}
 module.exports = {
   names,
   entity,
+  attributesDto,
   controller,
   dto,
   processor,
+  subscriber,
+  job,
   genMigration,
   migration,
   seed,