@cosider.construction/eapp 1.0.4 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosider.construction/eapp",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Project-local CLI for Electron + Vue ERP projects",
   "type": "module",
   "bin": {

package/src/generators/entity.js

@@ -1,16 +1,16 @@
 import path from 'path';
 import chalk from 'chalk';
 import { parseEntityPath, ipcRoute, toUpper, toLower, toPascal } from '../utils/naming.js';
-import { writeFile, writeJson, exists, assertProjectRoot, loadEntityRegistry } from '../utils/fs.js';
+import { writeFile, writeJson, exists, assertProjectRoot } from '../utils/fs.js';
 import { log } from '../utils/log.js';
-import { textInput, optionsLine, fieldsTable, radioLine } from '../tui/engine.js';
+import { textInput, optionsLine, fieldsTable } from '../tui/engine.js';
 
 // ─── Default fields ───────────────────────────────────────────────────────────
 
 function defaultFillableRows(entityName) {
   return [
-    { field: `${entityName}_id`, type: 'int',     values: '', pk: true,  fk: false, group: '' },
-    { field: `${entityName}_lib`, type: 'varchar', values: '', pk: false, fk: false, group: '' },
+    { field: `${entityName}_id`,  type: 'int',     values: '', pk: true,  fk: false, group: '' },
+    { field: `${entityName}_lib`, type: 'varchar',  values: '', pk: false, fk: false, group: '' },
   ];
 }
 
@@ -29,11 +29,14 @@ const AUDIT_WIDTHS    = { field: 20, type: 10 };
 // ─── Code generators ──────────────────────────────────────────────────────────
 
 function buildModelJs({ module, entity, table, schema, fields, auditFields, pkField }) {
-  const TABLE   = toUpper(table || entity);
-  const dbAlias = schema === 'dbo' ? 'dbo' : schema;
-  const importPath = module === 'shared' ? '../../../engine/db.js' : '../../engine/db.js';
+  const TABLE      = toUpper(table || entity);
+  const dbAlias    = schema === 'dbo' ? 'dbo' : schema;
+  // import path: shared entities are 3 levels deep (shared/ENTITY/model.js → engine/db.js)
+  // module entities are also 3 levels deep (modules/MOD/ENTITY/model.js → engine/db.js)
+  const importPath = module === 'shared'
+    ? '../../../engine/db.js'
+    : '../../../engine/db.js';
 
-  const allFields  = [...fields, ...auditFields];
   const fillable   = fields.filter(f => !f.pk);
   const insertCols = fillable.map(f => f.field).join(', ');
   const insertVals = fillable.map(f => `@${f.field}`).join(', ');
@@ -44,6 +47,7 @@ function buildModelJs({ module, entity, table, schema, fields, auditFields, pkFi
 // Table  : ${TABLE}
 // Schema : ${schema}
 // PK     : ${pkField}
+// The scoped DB instance automatically prepends [database].[${schema}] to table names.
 
 export async function getAll() {
   return db.query('SELECT * FROM ${TABLE}');
@@ -56,20 +60,20 @@ export async function getById(${pkField}) {
 export async function add(data) {
   const { ${fillable.map(f => f.field).join(', ') || '/* fields */'} } = data;
   return db.execute(
-    'INSERT INTO ${TABLE} (${insertCols || '/* cols */'}) VALUES (${insertVals || '/* vals */'})',
+    \`INSERT INTO ${TABLE} (${insertCols || '/* cols */'}) VALUES (${insertVals || '/* vals */'})\`,
     data
   );
 }
 
 export async function update(${pkField}, data) {
   return db.execute(
-    'UPDATE ${TABLE} SET ${updateSet || '/* set */'} WHERE ${pkField} = @${pkField}',
+    \`UPDATE ${TABLE} SET ${updateSet || '/* set clause */'} WHERE ${pkField} = @${pkField}\`,
     { ...data, ${pkField} }
   );
 }
 
 export async function remove(${pkField}) {
-  return db.execute('DELETE FROM ${TABLE} WHERE ${pkField} = @${pkField}', { ${pkField} });
+  return db.execute(\`DELETE FROM ${TABLE} WHERE ${pkField} = @${pkField}\`, { ${pkField} });
 }
 `;
 }
@@ -77,15 +81,15 @@ export async function remove(${pkField}) {
 function buildControllerJs({ pkField }) {
   return `import * as model from './model.js';
 
-export async function getAll()              { return model.getAll(); }
-export async function getById(${pkField})   { return model.getById(${pkField}); }
-export async function add(data)             { return model.add(data); }
-export async function update(${pkField}, data) { return model.update(${pkField}, data); }
-export async function remove(${pkField})    { return model.remove(${pkField}); }
+export async function getAll()                    { return model.getAll(); }
+export async function getById(${pkField})         { return model.getById(${pkField}); }
+export async function add(data)                   { return model.add(data); }
+export async function update(${pkField}, data)    { return model.update(${pkField}, data); }
+export async function remove(${pkField})          { return model.remove(${pkField}); }
 `;
 }
 
-function buildIpcJson({ module, entity, table, schema }) {
+function buildIpcJson({ module, entity, schema }) {
   const route = ipcRoute(module, entity);
   const mod   = module === 'shared' ? 'shared' : module;
   const ent   = toLower(entity);
@@ -115,51 +119,69 @@ export default new ${ClassName}();
 `;
 }
 
-function buildMetaJson({ module, entity, schema, fields, auditFields, pkField }) {
-  return JSON.stringify({ module, entity, schema, fields, auditFields, pkField }, null, 2);
+function buildMetaJson({ module, entity, table, schema, fields, auditFields, pkField }) {
+  return JSON.stringify({ module, entity, table, schema, fields, auditFields, pkField }, null, 2);
 }
 
 // ─── Write entity files ───────────────────────────────────────────────────────
 
 async function writeEntity({ module, entity, table, schema, fields, auditFields, pkField, opts, dryRun }) {
   const cwd = process.cwd();
-  // If user typed POLE.dbo it means entity=pole, schema=dbo — show confirmation
-  const displayPath = `${module}/${entity}` + (parsedTable !== entity ? `:${parsedTable}` : '') + `.${schema}`;
+
+  // Display path
+  const displayPath = `${module}/${entity}` +
+    (table !== entity ? `:${table}` : '') +
+    `.${schema}`;
   console.log('');
   console.log(chalk.bold.white('  Entity  ') + chalk.cyan(displayPath));
-  if (parsedTable !== entity) {
-    console.log(chalk.dim(`  table name in DB will be: ${toUpper(parsedTable)}`));
+  if (table !== entity) {
+    console.log(chalk.dim(`  DB table name: ${toUpper(table)}`));
   }
 
-  const backendBase = module === 'shared' 
+  const backendBase = module === 'shared'
     ? path.join(cwd, 'src', 'backend', 'shared', toUpper(entity))
     : path.join(cwd, 'src', 'backend', 'modules', toUpper(module), toUpper(entity));
 
   const o = opts || { model: true, controller: true, crud: true, api: true, ipc: true };
 
   if (o.model) {
-    await writeFile(path.join(backendBase, 'model.js'),
-      buildModelJs({ module, entity, table: table || entity, schema, fields, auditFields, pkField }), { dryRun });
+    await writeFile(
+      path.join(backendBase, 'model.js'),
+      buildModelJs({ module, entity, table, schema, fields, auditFields, pkField }),
+      { dryRun }
+    );
   }
   if (o.controller) {
-    await writeFile(path.join(backendBase, 'controller.js'),
-      buildControllerJs({ pkField }), { dryRun });
+    await writeFile(
+      path.join(backendBase, 'controller.js'),
+      buildControllerJs({ pkField }),
+      { dryRun }
+    );
   }
   if (o.ipc) {
-    await writeFile(path.join(backendBase, 'ipc.json'),
-      buildIpcJson({ module, entity, table: table || entity, schema }), { dryRun });
+    await writeFile(
+      path.join(backendBase, 'ipc.json'),
+      buildIpcJson({ module, entity, schema }),
+      { dryRun }
+    );
   }
-  // Always write meta so registry can read it
-  await writeJson(path.join(backendBase, 'entity.meta.json'),
-    JSON.parse(buildMetaJson({ module, entity, schema, fields, auditFields, pkField })), { dryRun });
+
+  // Always write meta — entity registry reads this
+  await writeJson(
+    path.join(backendBase, 'entity.meta.json'),
+    { module, entity, table, schema, fields, auditFields, pkField },
+    { dryRun }
+  );
 
   if (o.api && o.ipc) {
-    const apiPath = path.join(cwd, 'src', 'frontend', 'api', 'modules',
-      `${toLower(module)}.${toLower(entity)}.api.js`);
+    const apiPath = path.join(
+      cwd, 'src', 'frontend', 'api', 'modules',
+      `${toLower(module)}.${toLower(entity)}.api.js`
+    );
     await writeFile(apiPath, buildApiJs({ module, entity }), { dryRun });
   }
 
-  log.success(`Entity ${chalk.cyan(module + '/' + entity + '.' + schema)} generated.`);
+  log.success(`Entity ${chalk.cyan(displayPath)} generated.`);
 }
 
 // ─── Main generator ───────────────────────────────────────────────────────────
@@ -175,10 +197,12 @@ export async function generateEntity(args, rawArgs) {
     console.log('');
     console.log(chalk.bold.cyan('  eapp entity') + chalk.dim(' <module/entity.schema>'));
     console.log('');
-    console.log(chalk.dim('  /employee          → shared/employee.dbo'));
+    console.log(chalk.dim('  /employee          → shared, employee, dbo'));
     console.log(chalk.dim('  rh/employee        → rh module, rh schema'));
     console.log(chalk.dim('  rh/employee.dbo    → rh module, dbo schema'));
-    console.log(chalk.dim('  rh/employee.hr     → rh module, custom schema hr'));
+    console.log(chalk.dim('  rh/employee.hr     → rh module, custom schema'));
+    console.log(chalk.dim('  POLE.dbo           → shared, pole entity, dbo schema'));
+    console.log(chalk.dim('  rh/agent:AGENTX    → rh module, entity=agent, table=AGENTX'));
     console.log('');
   }
 
@@ -194,38 +218,27 @@ export async function generateEntity(args, rawArgs) {
     catch (e) { log.error(e.message); process.exit(1); }
   }
 
-  const { module, entity, table: parsedTable, schema } = parsed;
-  const pkField = `${entity}_id`;
-  let tableOverride = parsedTable !== entity ? parsedTable : null;
+  const { module, entity, table, schema } = parsed;
+  const defaultPk = `${entity}_id`;
 
   // ── Check if exists ───────────────────────────────────────────────────────
   const cwd = process.cwd();
-  // If user typed POLE.dbo it means entity=pole, schema=dbo — show confirmation
-  const displayPath = `${module}/${entity}` + (parsedTable !== entity ? `:${parsedTable}` : '') + `.${schema}`;
-  console.log('');
-  console.log(chalk.bold.white('  Entity  ') + chalk.cyan(displayPath));
-  if (parsedTable !== entity) {
-    console.log(chalk.dim(`  table name in DB will be: ${toUpper(parsedTable)}`));
-  }
-
-  const backendBase = module === 'shared' 
+  const backendBase = module === 'shared'
     ? path.join(cwd, 'src', 'backend', 'shared', toUpper(entity))
     : path.join(cwd, 'src', 'backend', 'modules', toUpper(module), toUpper(entity));
 
-  const entityExists = await exists(backendBase);
-  if (entityExists) {
-    log.info(`Entity ${chalk.cyan(module + '/' + entity)} already exists.`);
-    log.dim('  Regenerating files — existing logic will be preserved in model/controller.');
+  if (await exists(backendBase)) {
+    log.info(`Entity ${chalk.cyan(module + '/' + entity)} already exists — regenerating.`);
   }
 
-  // ── --default: skip all prompts ───────────────────────────────────────────
+  // ── --default: instant generation ────────────────────────────────────────
   if (useDefault) {
     await writeEntity({
-      module, entity, table: parsedTable || entity, schema,
-      fields: defaultFillableRows(entity),
+      module, entity, table, schema,
+      fields:      defaultFillableRows(entity),
       auditFields: DEFAULT_AUDIT_ROWS,
-      pkField,
-      opts: { model: true, controller: true, crud: true, api: true, ipc: true },
+      pkField:     defaultPk,
+      opts:        { model: true, controller: true, crud: true, api: true, ipc: true },
       dryRun,
     });
     return;
@@ -242,7 +255,7 @@ export async function generateEntity(args, rawArgs) {
     { key: 'ipc',        label: 'IPC',        default: true },
   ]);
 
-  // ── Fillable fields ───────────────────────────────────────────────────────
+  // ── Fillable fields table ─────────────────────────────────────────────────
   const fillableRows = await fieldsTable(
     defaultFillableRows(entity),
     FILLABLE_COLS,
@@ -250,23 +263,23 @@ export async function generateEntity(args, rawArgs) {
     'Fillable Fields  (+ add  - remove  ← → cols  ↑ ↓ rows  space pk/fk  enter done)'
   );
 
-  // ── Audit fields ──────────────────────────────────────────────────────────
+  // ── Audit fields table ────────────────────────────────────────────────────
   const auditRows = await fieldsTable(
     [...DEFAULT_AUDIT_ROWS],
     AUDIT_COLS,
     AUDIT_WIDTHS,
-    'Audit Fields (non-fillable)  (- to remove unwanted)'
+    'Audit Fields (non-fillable)  (- to remove unwanted  enter done)'
   );
 
-  // Find PK
-  const pkRow   = fillableRows.find(r => r.pk);
-  const resolvedPk = pkRow ? pkRow.field : pkField;
+  // Resolve PK from fields
+  const pkRow      = fillableRows.find(r => r.pk);
+  const resolvedPk = pkRow ? pkRow.field : defaultPk;
 
   await writeEntity({
-    module, entity, table: tableOverride || entity, schema,
-    fields: fillableRows,
+    module, entity, table, schema,
+    fields:      fillableRows,
     auditFields: auditRows,
-    pkField: resolvedPk,
+    pkField:     resolvedPk,
     opts,
     dryRun,
   });

package/src/generators/menu.js

@@ -67,8 +67,8 @@ async function editViewMenu(menuFile, existing) {
     console.log('');
     const rows = await fieldsTable(
       existing_items,
-      ['label', 'route', 'icon', 'parent', 'permission'],
-      { label: 16, route: 20, icon: 6, parent: 14, permission: 20 },
+      ['label', 'route', 'icon', 'path', 'dot', 'nbr'],
+      { label: 16, route: 20, icon: 5, path: 14, dot: 5, nbr: 6 },
       'hMenu items  (parent = dropdown group label, empty = top level)'
     );
     const menu = { route: existing?.route || '', hMenu: { style: 'classic', items: nestItems(rows) } };

package/src/utils/naming.js

@@ -15,93 +15,89 @@ export const isValidName = (s) => /^[a-zA-Z0-9_-]+$/.test(s);
 /**
  * Parse "module/entity.schema" format
  *
- * /employee          → { module: 'shared', entity: 'employee', schema: 'dbo' }
- * rh/employee        → { module: 'rh',     entity: 'employee', schema: 'rh'  }
- * rh/employee.dbo    → { module: 'rh',     entity: 'employee', schema: 'dbo' }
- * rh/employee.hr     → { module: 'rh',     entity: 'employee', schema: 'hr'  }
- * rh/employee.       → { module: 'rh',     entity: 'employee', schema: 'rh'  } (dot alone = module)
- * employee           → { module: 'shared', entity: 'employee', schema: 'dbo' } (no slash = shared)
+ * /employee           → shared, employee, dbo
+ * rh/employee         → rh, employee, rh
+ * rh/employee.dbo     → rh, employee, dbo
+ * rh/employee.hr      → rh, employee, hr
+ * rh/employee.        → rh, employee, rh  (dot alone = module schema)
+ * employee            → shared, employee, dbo
+ * POLE.dbo            → shared, pole, dbo  (uppercase entity with schema)
+ * rh/agent:AGENTX.dbo → rh, agent, dbo, table=agentx
+ *
+ * OLD compat dot notation: rh.employee → rh/employee
+ * BUT: POLE.dbo must NOT rewrite — left has uppercase so it's not a module name
  */
 export function parseEntityPath(input) {
   if (!input) throw new Error('No entity path provided.');
 
   let raw = input.trim();
 
-  // Handle dot notation ONLY when the part before the dot could be a module name
-  // and the part after is NOT a schema keyword (dbo, etc.) — i.e. "rh.employee" → "rh/employee"
-  // BUT "POLE.dbo" must NOT be rewritten — POLE is the entity, dbo is the schema.
-  // Rule: rewrite "x.y" only when x contains no uppercase and y is not a known schema.
-  const SCHEMA_NAMES = new Set(['dbo', 'dbo2', 'hr', 'rh', 'stk', 'fin', 'crm', 'adm', 'sec', 'shared']);
+  // ── Old "module.entity" compat (only if left is strictly lowercase) ────────
   if (!raw.includes('/') && raw.includes('.') && raw.split('.').length === 2) {
     const [left, right] = raw.split('.');
-    const looksLikeSchema = SCHEMA_NAMES.has(right.toLowerCase()) || /^[a-z]+$/.test(right);
-    const looksLikeModule = /^[a-z][a-z0-9_-]*$/.test(left);
-    // Only rewrite if left looks like a lowercase module AND right does NOT look like a schema
-    if (looksLikeModule && !looksLikeSchema) {
+    const leftIsLowercaseModule = /^[a-z][a-z0-9_-]*$/.test(left);
+    const rightIsSchemaKeyword  = /^(dbo\d*|[a-z]{1,6})$/.test(right.toLowerCase());
+    if (leftIsLowercaseModule && !rightIsSchemaKeyword) {
       raw = `${left}/${right}`;
     }
+    // Otherwise treat as entity.schema without module (e.g. POLE.dbo, employee.dbo)
   }
 
-  // No slash at all → shared
+  // ── No slash → shared module ───────────────────────────────────────────────
   if (!raw.includes('/')) {
-    const _e = toLower(raw);
-  return { module: 'shared', entity: _e, table: _e, schema: 'dbo' };
+    const dotPos = raw.indexOf('.');
+    let ent, sch;
+    if (dotPos !== -1) {
+      ent = toLower(raw.slice(0, dotPos));
+      sch = raw.slice(dotPos + 1).toLowerCase() || 'dbo';
+    } else {
+      ent = toLower(raw);
+      sch = 'dbo';
+    }
+    if (!isValidName(ent)) throw new Error(`Invalid entity name "${ent}".`);
+    return { module: 'shared', entity: ent, table: ent, schema: sch };
   }
 
-  // Split on /
-  const slashIdx = raw.indexOf('/');
-  const modulePart = raw.slice(0, slashIdx);   // may be empty → shared
-  const rest       = raw.slice(slashIdx + 1);  // entity.schema or entity
-
-  const module = modulePart === '' ? 'shared' : toLower(modulePart);
-
-  // Split entity and schema on .
-  const dotIdx = rest.indexOf('.');
-  let entity, schema;
+  // ── Has slash ─────────────────────────────────────────────────────────────
+  const slashIdx  = raw.indexOf('/');
+  const modPart   = raw.slice(0, slashIdx);
+  const rest      = raw.slice(slashIdx + 1);
+  const module    = modPart === '' ? 'shared' : toLower(modPart);
 
-  // Also parse optional table alias: entity:tableName
-  // e.g.  rh/agent:agentx.dbo  →  entity=agent, table=agentx, schema=dbo
+  // ── Optional table alias: entity:TABLE.schema ──────────────────────────────
   let tableAlias = null;
-  if (rest.includes(':')) {
-    const colonIdx = rest.indexOf(':');
-    tableAlias = rest.slice(colonIdx + 1).split('.')[0];  // strip schema part
-    // rewrite rest without the alias for further parsing
-    // keep the .schema part after the alias if any
-    const afterColon = rest.slice(colonIdx + 1);
-    const schemaInAlias = afterColon.includes('.') ? afterColon.slice(afterColon.indexOf('.')) : '';
-    // rest becomes "entity.schema"
-    // rest = rest.slice(0, colonIdx) + schemaInAlias; — handled below
+  let cleanRest  = rest;
+  const colonPos = rest.indexOf(':');
+  if (colonPos !== -1) {
+    const beforeColon = rest.slice(0, colonPos);
+    const afterColon  = rest.slice(colonPos + 1);
+    const aliasDot    = afterColon.indexOf('.');
+    tableAlias        = toLower(aliasDot !== -1 ? afterColon.slice(0, aliasDot) : afterColon);
+    const schemaRest  = aliasDot !== -1 ? afterColon.slice(aliasDot) : '';
+    cleanRest         = beforeColon + schemaRest;
   }
-  const cleanRest = rest.replace(/:([^.]+)/, '');  // strip :alias for entity/schema parsing
 
-  const dotIdx2 = cleanRest.indexOf('.');
+  // ── Entity and schema ──────────────────────────────────────────────────────
+  const dotPos = cleanRest.indexOf('.');
   let entity, schema;
-  if (dotIdx2 === -1) {
+
+  if (dotPos === -1) {
     entity = toLower(cleanRest);
     schema = module === 'shared' ? 'dbo' : module;
   } else {
-    entity = toLower(cleanRest.slice(0, dotIdx2));
-    const schemaPart = cleanRest.slice(dotIdx2 + 1);
-    schema = schemaPart === '' ? (module === 'shared' ? 'dbo' : module) : toLower(schemaPart);
+    entity          = toLower(cleanRest.slice(0, dotPos));
+    const schemaPart = cleanRest.slice(dotPos + 1);
+    schema          = schemaPart === '' ? (module === 'shared' ? 'dbo' : module) : toLower(schemaPart);
   }
-  const table = tableAlias ? toLower(tableAlias) : entity;
-  // (keep legacy variable for code below that uses dotIdx)
-  const dotIdx = dotIdx2;
 
-  if (!isValidName(entity)) {
-    throw new Error(`Invalid entity name "${entity}". Use alphanumeric, hyphens, underscores only.`);
-  }
-  if (module !== 'shared' && !isValidName(module)) {
-    throw new Error(`Invalid module name "${module}".`);
-  }
+  if (!isValidName(entity)) throw new Error(`Invalid entity name "${entity}".`);
+  if (module !== 'shared' && !isValidName(module)) throw new Error(`Invalid module name "${module}".`);
 
-  return { module, entity, table: table || entity, schema };
+  return { module, entity, table: tableAlias || entity, schema };
 }
 
 /**
- * Derive IPC route
- * shared + client   → shared.CLIENT
- * rh     + employee → modules.RH.EMPLOYEE
+ * IPC route: shared.CLIENT or modules.RH.EMPLOYEE
  */
 export function ipcRoute(module, entity) {
   if (module === 'shared') return `shared.${toUpper(entity)}`;
@@ -109,11 +105,9 @@ export function ipcRoute(module, entity) {
 }
 
 /**
- * Derive the backend directory path for an entity
+ * Backend directory for an entity
  */
 export function backendEntityDir(cwd, module, entity) {
-  if (module === 'shared') {
-    return `${cwd}/src/backend/shared/${toUpper(entity)}`;
-  }
+  if (module === 'shared') return `${cwd}/src/backend/shared/${toUpper(entity)}`;
   return `${cwd}/src/backend/modules/${toUpper(module)}/${toUpper(entity)}`;
 }