@cosider.construction/eapp 1.0.3 → 1.0.4

package/package.json

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

package/src/generators/entity.js

@@ -28,8 +28,8 @@ const AUDIT_WIDTHS    = { field: 20, type: 10 };
 
 // ─── Code generators ──────────────────────────────────────────────────────────
 
-function buildModelJs({ module, entity, schema, fields, auditFields, pkField }) {
-  const TABLE   = toUpper(entity);
+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';
 
@@ -85,7 +85,7 @@ export async function remove(${pkField})    { return model.remove(${pkField}); }
 `;
 }
 
-function buildIpcJson({ module, entity, schema }) {
+function buildIpcJson({ module, entity, table, schema }) {
   const route = ipcRoute(module, entity);
   const mod   = module === 'shared' ? 'shared' : module;
   const ent   = toLower(entity);
@@ -121,9 +121,17 @@ function buildMetaJson({ module, entity, schema, fields, auditFields, pkField })
 
 // ─── Write entity files ───────────────────────────────────────────────────────
 
-async function writeEntity({ module, entity, schema, fields, auditFields, pkField, opts, dryRun }) {
+async function writeEntity({ module, entity, table, schema, fields, auditFields, pkField, opts, dryRun }) {
   const cwd = process.cwd();
-  const backendBase = module === 'shared'
+  // 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' 
     ? path.join(cwd, 'src', 'backend', 'shared', toUpper(entity))
     : path.join(cwd, 'src', 'backend', 'modules', toUpper(module), toUpper(entity));
 
@@ -131,7 +139,7 @@ async function writeEntity({ module, entity, schema, fields, auditFields, pkFiel
 
   if (o.model) {
     await writeFile(path.join(backendBase, 'model.js'),
-      buildModelJs({ module, entity, schema, fields, auditFields, pkField }), { dryRun });
+      buildModelJs({ module, entity, table: table || entity, schema, fields, auditFields, pkField }), { dryRun });
   }
   if (o.controller) {
     await writeFile(path.join(backendBase, 'controller.js'),
@@ -139,7 +147,7 @@ async function writeEntity({ module, entity, schema, fields, auditFields, pkFiel
   }
   if (o.ipc) {
     await writeFile(path.join(backendBase, 'ipc.json'),
-      buildIpcJson({ module, entity, schema }), { dryRun });
+      buildIpcJson({ module, entity, table: table || entity, schema }), { dryRun });
   }
   // Always write meta so registry can read it
   await writeJson(path.join(backendBase, 'entity.meta.json'),
@@ -186,12 +194,21 @@ export async function generateEntity(args, rawArgs) {
     catch (e) { log.error(e.message); process.exit(1); }
   }
 
-  const { module, entity, schema } = parsed;
+  const { module, entity, table: parsedTable, schema } = parsed;
   const pkField = `${entity}_id`;
+  let tableOverride = parsedTable !== entity ? parsedTable : null;
 
   // ── Check if exists ───────────────────────────────────────────────────────
   const cwd = process.cwd();
-  const backendBase = module === 'shared'
+  // 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' 
     ? path.join(cwd, 'src', 'backend', 'shared', toUpper(entity))
     : path.join(cwd, 'src', 'backend', 'modules', toUpper(module), toUpper(entity));
 
@@ -204,7 +221,7 @@ export async function generateEntity(args, rawArgs) {
   // ── --default: skip all prompts ───────────────────────────────────────────
   if (useDefault) {
     await writeEntity({
-      module, entity, schema,
+      module, entity, table: parsedTable || entity, schema,
       fields: defaultFillableRows(entity),
       auditFields: DEFAULT_AUDIT_ROWS,
       pkField,
@@ -246,7 +263,7 @@ export async function generateEntity(args, rawArgs) {
   const resolvedPk = pkRow ? pkRow.field : pkField;
 
   await writeEntity({
-    module, entity, schema,
+    module, entity, table: tableOverride || entity, schema,
     fields: fillableRows,
     auditFields: auditRows,
     pkField: resolvedPk,

package/src/generators/menu.js

@@ -12,11 +12,12 @@ function flattenItems(items = [], parentLabel = '') {
   const rows = [];
   for (const item of items) {
     rows.push({
-      label:      item.label || '',
-      route:      item.route || '',
-      icon:       item.icon  || '',
-      parent:     parentLabel,
-      permission: item.permission || '',
+      label:      item.label      || '',
+      icon:       item.icon       || '',
+      path:       parentLabel,
+      route:      item.route      || '',
+      dot:        item.dot        ? 'on' : 'off',
+      nbr:        item.nbr        || '',
     });
     if (item.children?.length) {
       rows.push(...flattenItems(item.children, item.label));
@@ -28,17 +29,19 @@ function flattenItems(items = [], parentLabel = '') {
 // ─── Rebuild nested menu items from flat rows ─────────────────────────────────
 
 function nestItems(rows) {
-  const top      = rows.filter(r => !r.parent);
-  const children = rows.filter(r => r.parent);
+  const top      = rows.filter(r => !r.path);
+  const children = rows.filter(r =>  r.path);
 
   return top.map(r => {
-    const item = { label: r.label, route: r.route, icon: r.icon };
-    if (r.permission) item.permission = r.permission;
-    const kids = children.filter(c => c.parent === r.label);
+    const item = { label: r.label, icon: r.icon, route: r.route };
+    if (r.dot === 'on') item.dot = true;
+    if (r.nbr)          item.nbr = r.nbr;
+    const kids = children.filter(c => c.path === r.label);
     if (kids.length) {
       item.children = kids.map(c => ({
-        label: c.label, route: c.route, icon: c.icon,
-        ...(c.permission ? { permission: c.permission } : {}),
+        label: c.label, icon: c.icon, route: c.route,
+        ...(c.dot === 'on' ? { dot: true } : {}),
+        ...(c.nbr          ? { nbr: c.nbr } : {}),
       }));
     }
     return item;
@@ -59,7 +62,7 @@ async function editViewMenu(menuFile, existing) {
     // Classic — same item table as module menu
     const existing_items = flattenItems(existing?.hMenu?.items || []);
     if (!existing_items.length) {
-      existing_items.push({ label: 'Action', route: '', icon: '', parent: '', permission: '' });
+      existing_items.push({ label: 'Action', icon: '', path: '', route: '', dot: 'off', nbr: '' });
     }
     console.log('');
     const rows = await fieldsTable(
@@ -185,14 +188,14 @@ export async function generateMenu(args, rawArgs) {
   console.log(chalk.bold.white(`  ${toPascal(module)} — hMenu`));
   const hRows = flattenItems(existing.hMenu?.items || []);
   if (!hRows.length) {
-    hRows.push({ label: `${toPascal(module)} Home`, route: `/${module}`, icon: '', parent: '', permission: '' });
+    hRows.push({ label: `${toPascal(module)} Home`, icon: '', path: '', route: `/${module}`, dot: 'off', nbr: '' });
   }
 
   const updatedH = await fieldsTable(
     hRows,
-    ['label', 'route', 'icon', 'parent', 'permission'],
-    { label: 16, route: 20, icon: 6, parent: 14, permission: 20 },
-    'hMenu  (parent = dropdown group label, empty = top level   enter done)'
+    ['label', 'icon', 'path', 'route', 'dot', 'nbr'],
+    { label: 16, icon: 5, path: 14, route: 20, dot: 5, nbr: 6 },
+    'hMenu  (path = parent group label, dot = show dot indicator, nbr = badge)'
   );
 
   // Pass 2 — vMenu
@@ -200,14 +203,14 @@ export async function generateMenu(args, rawArgs) {
   console.log(chalk.bold.white(`  ${toPascal(module)} — vMenu`));
   const vRows = flattenItems(existing.vMenu?.items || []);
   if (!vRows.length) {
-    vRows.push({ label: toPascal(module), route: `/${module}`, icon: '', parent: '', permission: '' });
+    vRows.push({ label: toPascal(module), icon: '', path: '', route: `/${module}`, dot: 'off', nbr: '' });
   }
 
   const updatedV = await fieldsTable(
     vRows,
-    ['label', 'route', 'icon', 'parent', 'permission'],
-    { label: 16, route: 20, icon: 6, parent: 14, permission: 20 },
-    'vMenu  (parent = collapsible group label, empty = top level   enter done)'
+    ['label', 'icon', 'path', 'route', 'dot', 'nbr'],
+    { label: 16, icon: 5, path: 14, route: 20, dot: 5, nbr: 6 },
+    'vMenu  (path = collapsible group label, dot = show dot indicator, nbr = badge)'
   );
 
   // Also check hMenu style

package/src/generators/module.js

@@ -121,7 +121,7 @@ export async function generateModule(args, rawArgs) {
     return {
       module:  lower,
       layout:  `${toPascal(lower)}Layout`,
-      vmenu:   'own',
+      hmenu:   'own',
       home:    'on',
       grid:    'on',
     };
@@ -138,7 +138,7 @@ export async function generateModule(args, rawArgs) {
     newName = toLower(newName.trim());
     if (!isValidName(newName)) { log.error('Invalid module name.'); process.exit(1); }
     if (!existing.find(e => toLower(e) === newName)) {
-      rows.push({ module: newName, layout: `${toPascal(newName)}Layout`, vmenu: 'own', home: 'on', grid: 'on' });
+      rows.push({ module: newName, layout: `${toPascal(newName)}Layout`, hmenu: 'own', home: 'on', grid: '3x2' });
     }
   }
 
@@ -146,17 +146,18 @@ export async function generateModule(args, rawArgs) {
   console.log('');
   const updated = await fieldsTable(
     rows,
-    ['module', 'layout', 'vmenu', 'home', 'grid'],
-    { module: 14, layout: 18, vmenu: 8, home: 6, grid: 6 },
-    'Modules  (edit layout name, vmenu: own|share, home/grid: on|off   enter to save)'
+    ['module', 'layout', 'hmenu', 'home', 'grid'],
+    { module: 14, layout: 18, hmenu: 8, home: 6, grid: 8 },
+    'Modules  (hmenu: own|share|none  home: on|off  grid: 0 or NxM e.g. 3x2   enter to save)'
   );
 
   // ── Write new/updated modules ──────────────────────────────────────────────
   for (const row of updated) {
     const name      = toLower(row.module);
     const hasHome   = row.home  !== 'off';
-    const hasGrid   = row.grid  !== 'off';
-    const ownVMenu  = row.vmenu !== 'share';
+    const gridVal   = row.grid  || '0';  // '0' = no grid, 'NxM' = N cols x M rows
+    const hasGrid   = gridVal !== '0' && gridVal !== 'off';
+    const hMenuScope = row.hmenu || 'own';  // own | share | none
     const layoutName = row.layout || `${toPascal(name)}Layout`;
 
     const backendDir  = path.join(cwd, 'src', 'backend',  'modules', toUpper(name));

package/src/generators/sql.js

@@ -0,0 +1,118 @@
+import path from 'path';
+import fs from 'fs-extra';
+import chalk from 'chalk';
+import { toUpper, toLower, toPascal } from '../utils/naming.js';
+import { writeFile, assertProjectRoot, loadEntityRegistry } from '../utils/fs.js';
+import { log } from '../utils/log.js';
+import { radioLine, textInput } from '../tui/engine.js';
+
+// ─── SQL generators ───────────────────────────────────────────────────────────
+
+function sqlTypeMap(appType) {
+  const map = {
+    varchar:  'NVARCHAR(255)',
+    int:      'INT',
+    decimal:  'DECIMAL(18,2)',
+    date:     'DATE',
+    datetime: 'DATETIME2',
+    bit:      'BIT',
+    text:     'NVARCHAR(MAX)',
+    float:    'FLOAT',
+    enum:     'NVARCHAR(50)',
+  };
+  return map[appType] || 'NVARCHAR(255)';
+}
+
+function buildCreateTable({ entity, table, schema, fields, auditFields, pkField }) {
+  const TABLE    = toUpper(table || entity);
+  const SCHEMA   = schema || 'dbo';
+  const allCols  = [...(fields || []), ...(auditFields || [])];
+
+  const colLines = allCols.map(f => {
+    const nullable = f.pk ? 'NOT NULL' : 'NULL';
+    const identity = f.pk ? ' IDENTITY(1,1)' : '';
+    return `    [${f.field}]  ${sqlTypeMap(f.type)}${identity}  ${nullable}`;
+  });
+
+  const pkLine = `    CONSTRAINT [PK_${TABLE}] PRIMARY KEY ([${pkField || `${entity}_id`}])`;
+
+  return `-- Generated by eapp — ${new Date().toISOString().slice(0, 10)}
+-- Entity : ${toLower(entity)}
+-- Table  : [${SCHEMA}].[${TABLE}]
+
+CREATE TABLE [${SCHEMA}].[${TABLE}] (
+${[...colLines, pkLine].join(',\n')}
+);
+GO
+`;
+}
+
+function buildAlterTable({ entity, table, schema, fields }) {
+  const TABLE  = toUpper(table || entity);
+  const SCHEMA = schema || 'dbo';
+
+  const lines = (fields || []).map(f =>
+    `ALTER TABLE [${SCHEMA}].[${TABLE}]  ADD  [${f.field}]  ${sqlTypeMap(f.type)}  NULL;`
+  );
+
+  return `-- Alter: add missing columns to [${SCHEMA}].[${TABLE}]
+${lines.join('\n')}
+GO
+`;
+}
+
+// ─── Main generator ───────────────────────────────────────────────────────────
+
+export async function generateSql(args, rawArgs) {
+  assertProjectRoot();
+
+  const cwd      = process.cwd();
+  const registry = await loadEntityRegistry(cwd);
+
+  if (!registry.size) {
+    log.warn('No entities found. Run  eapp entity  first.');
+    return;
+  }
+
+  // Pick entity from registry
+  const entries = [...registry.entries()];
+  console.log('');
+  console.log(chalk.bold.white('  Generate SQL for entity'));
+  const key = await textInput('module/entity (or "all"):');
+
+  const targets = key.trim() === 'all'
+    ? entries
+    : entries.filter(([k]) => k.endsWith(key.trim().toLowerCase()) || k === key.trim().toLowerCase());
+
+  if (!targets.length) {
+    log.error(`Entity "${key}" not found in registry.`);
+    return;
+  }
+
+  // Pick statement type
+  console.log('');
+  console.log(chalk.bold.white('  Statement type'));
+  const stmtType = await radioLine('', [
+    { label: 'CREATE TABLE', value: 'create' },
+    { label: 'ALTER (add cols)', value: 'alter' },
+  ]);
+
+  const sqlDir = path.join(cwd, 'src', 'backend', 'sql');
+  await fs.ensureDir(sqlDir);
+
+  for (const [, meta] of targets) {
+    const { module, entity, table, schema, fields, auditFields, pkField } = meta;
+    const fileName  = stmtType === 'create'
+      ? `${schema}_${toUpper(table || entity)}_create.sql`
+      : `${schema}_${toUpper(table || entity)}_alter.sql`;
+    const filePath  = path.join(sqlDir, fileName);
+    const content   = stmtType === 'create'
+      ? buildCreateTable({ entity, table, schema, fields, auditFields, pkField })
+      : buildAlterTable({ entity, table, schema, fields });
+
+    await writeFile(filePath, content);
+    log.success(`${fileName}`);
+  }
+
+  log.info(`SQL files written to  src/backend/sql/`);
+}

package/src/generators/view.js

@@ -349,11 +349,19 @@ export async function generateView(args, rawArgs) {
     defaultComps,
     COMP_COLS,
     COMP_WIDTHS,
-    'Components  (+ add  - remove  ← → cols  space menu toggle  enter done)'
+    'Components  (+ add  - remove  \u2190 \u2192 cols  space menu toggle  enter done)'
   );
 
-  const hasRow  = compRows.some(r => r.render === 'row'  || r.render === 'table');
-  const hasCard = compRows.some(r => r.render === 'card');
+  // List render mode — explicit radio (table / card / both) so user can't mistype
+  console.log('');
+  console.log(chalk.bold.white('  List render'));
+  const listRender = await radioLine('', [
+    { label: 'Table (row)', value: 'table' },
+    { label: 'Card',        value: 'card'  },
+    { label: 'Both',        value: 'both'  },
+  ]);
+  const hasRow  = listRender === 'table' || listRender === 'both';
+  const hasCard = listRender === 'card'  || listRender === 'both';
 
   // ── Step 4: slaves ────────────────────────────────────────────────────────
   let slaveConfigs = [];

package/src/index.js

@@ -41,11 +41,12 @@ Options:
 
 const MAIN_MENU = [
   { label: 'Entity',  value: 'entity'  },
+  { label: 'Pivot',   value: 'pivot'   },
   { label: 'View',    value: 'view'    },
   { label: 'Module',  value: 'module'  },
   { label: 'Menu',    value: 'menu'    },
+  { label: 'Sql',     value: 'sql'     },
   { label: 'Config',  value: 'config'  },
-  { label: 'Pivot',   value: 'pivot'   },
   { label: 'Layout',  value: 'layout'  },
   { label: 'List',    value: 'list'    },
   { label: 'Quit',    value: 'quit'    },
@@ -72,7 +73,10 @@ async function launchInteractive() {
       break;
     }
 
-    if (chosen === 'list') {
+    if (chosen === 'sql') {
+      const { generateSql } = await import('./generators/sql.js');
+      await generateSql([], []);
+    } else if (chosen === 'list') {
       await listModules();
       console.log('');
       await listEntities([]);

package/src/tui/engine.js

@@ -161,8 +161,9 @@ const BOOL_COLS = new Set(['pk', 'fk']);
 // Columns where space cycles between string values
 const CYCLE_COLS = {
   vmenu: ['own', 'share'],
+  hmenu: ['own', 'share', 'none'],
   home:  ['on', 'off'],
-  grid:  ['on', 'off'],
+  // 'grid' is free-text (NxM), not cycled
 };
 
 // Strip ANSI escape codes to get the true printable length of a string.

package/src/utils/naming.js

@@ -27,15 +27,25 @@ export function parseEntityPath(input) {
 
   let raw = input.trim();
 
-  // Handle old dot notation for backwards compat: rh.employee → rh/employee
+  // 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']);
   if (!raw.includes('/') && raw.includes('.') && raw.split('.').length === 2) {
-    const [mod, ent] = raw.split('.');
-    raw = `${mod}/${ent}`;
+    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) {
+      raw = `${left}/${right}`;
+    }
   }
 
   // No slash at all → shared
   if (!raw.includes('/')) {
-    return { module: 'shared', entity: toLower(raw), schema: 'dbo' };
+    const _e = toLower(raw);
+  return { module: 'shared', entity: _e, table: _e, schema: 'dbo' };
   }
 
   // Split on /
@@ -49,20 +59,34 @@ export function parseEntityPath(input) {
   const dotIdx = rest.indexOf('.');
   let entity, schema;
 
-  if (dotIdx === -1) {
-    // No dot → schema = module (or dbo for shared)
-    entity = toLower(rest);
+  // Also parse optional table alias: entity:tableName
+  // e.g.  rh/agent:agentx.dbo  →  entity=agent, table=agentx, schema=dbo
+  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
+  }
+  const cleanRest = rest.replace(/:([^.]+)/, '');  // strip :alias for entity/schema parsing
+
+  const dotIdx2 = cleanRest.indexOf('.');
+  let entity, schema;
+  if (dotIdx2 === -1) {
+    entity = toLower(cleanRest);
     schema = module === 'shared' ? 'dbo' : module;
   } else {
-    entity = toLower(rest.slice(0, dotIdx));
-    const schemaPart = rest.slice(dotIdx + 1);
-    if (schemaPart === '') {
-      // Trailing dot → schema = module
-      schema = module === 'shared' ? 'dbo' : module;
-    } else {
-      schema = toLower(schemaPart);
-    }
+    entity = toLower(cleanRest.slice(0, dotIdx2));
+    const schemaPart = cleanRest.slice(dotIdx2 + 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.`);
@@ -71,7 +95,7 @@ export function parseEntityPath(input) {
     throw new Error(`Invalid module name "${module}".`);
   }
 
-  return { module, entity, schema };
+  return { module, entity, table: table || entity, schema };
 }
 
 /**