@cosider.construction/eapp 1.0.3 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosider.construction/eapp",
-  "version": "1.0.3",
+  "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: '' },
   ];
 }
 
@@ -28,12 +28,15 @@ const AUDIT_WIDTHS    = { field: 20, type: 10 };
 
 // ─── Code generators ──────────────────────────────────────────────────────────
 
-function buildModelJs({ module, entity, schema, fields, auditFields, pkField }) {
-  const TABLE   = toUpper(entity);
-  const dbAlias = schema === 'dbo' ? 'dbo' : schema;
-  const importPath = module === 'shared' ? '../../../engine/db.js' : '../../engine/db.js';
+function buildModelJs({ module, entity, table, schema, fields, auditFields, pkField }) {
+  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, schema, fields, auditFields, pkField })
 // 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,11 +81,11 @@ 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}); }
 `;
 }
 
@@ -115,14 +119,25 @@ 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, schema, fields, auditFields, pkField, opts, dryRun }) {
+async function writeEntity({ module, entity, table, schema, fields, auditFields, pkField, opts, dryRun }) {
   const cwd = process.cwd();
+
+  // Display path
+  const displayPath = `${module}/${entity}` +
+    (table !== entity ? `:${table}` : '') +
+    `.${schema}`;
+  console.log('');
+  console.log(chalk.bold.white('  Entity  ') + chalk.cyan(displayPath));
+  if (table !== entity) {
+    console.log(chalk.dim(`  DB table name: ${toUpper(table)}`));
+  }
+
   const backendBase = module === 'shared'
     ? path.join(cwd, 'src', 'backend', 'shared', toUpper(entity))
     : path.join(cwd, 'src', 'backend', 'modules', toUpper(module), toUpper(entity));
@@ -130,28 +145,43 @@ async function writeEntity({ module, entity, schema, fields, auditFields, pkFiel
   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, 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, 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 ───────────────────────────────────────────────────────────
@@ -167,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('');
   }
 
@@ -186,8 +218,8 @@ export async function generateEntity(args, rawArgs) {
     catch (e) { log.error(e.message); process.exit(1); }
   }
 
-  const { module, entity, schema } = parsed;
-  const pkField = `${entity}_id`;
+  const { module, entity, table, schema } = parsed;
+  const defaultPk = `${entity}_id`;
 
   // ── Check if exists ───────────────────────────────────────────────────────
   const cwd = process.cwd();
@@ -195,20 +227,18 @@ export async function generateEntity(args, rawArgs) {
     ? 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, 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;
@@ -225,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,
@@ -233,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, schema,
-    fields: fillableRows,
+    module, entity, table, schema,
+    fields:      fillableRows,
     auditFields: auditRows,
-    pkField: resolvedPk,
+    pkField:     resolvedPk,
     opts,
     dryRun,
   });

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,13 +62,13 @@ 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(
       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) } };
@@ -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

@@ -15,69 +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 old dot notation for backwards compat: rh.employee → rh/employee
+  // ── Old "module.entity" compat (only if left is strictly lowercase) ────────
   if (!raw.includes('/') && raw.includes('.') && raw.split('.').length === 2) {
-    const [mod, ent] = raw.split('.');
-    raw = `${mod}/${ent}`;
+    const [left, right] = raw.split('.');
+    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('/')) {
-    return { module: 'shared', entity: toLower(raw), 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
+  // ── Has slash ─────────────────────────────────────────────────────────────
+  const slashIdx  = raw.indexOf('/');
+  const modPart   = raw.slice(0, slashIdx);
+  const rest      = raw.slice(slashIdx + 1);
+  const module    = modPart === '' ? 'shared' : toLower(modPart);
 
-  const module = modulePart === '' ? 'shared' : toLower(modulePart);
+  // ── Optional table alias: entity:TABLE.schema ──────────────────────────────
+  let tableAlias = null;
+  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;
+  }
 
-  // Split entity and schema on .
-  const dotIdx = rest.indexOf('.');
+  // ── Entity and schema ──────────────────────────────────────────────────────
+  const dotPos = cleanRest.indexOf('.');
   let entity, schema;
 
-  if (dotIdx === -1) {
-    // No dot → schema = module (or dbo for shared)
-    entity = toLower(rest);
+  if (dotPos === -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, dotPos));
+    const schemaPart = cleanRest.slice(dotPos + 1);
+    schema          = schemaPart === '' ? (module === 'shared' ? 'dbo' : module) : toLower(schemaPart);
   }
 
-  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, 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)}`;
@@ -85,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)}`;
 }