@cosider.construction/eapp 1.0.0

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@cosider.construction/eapp",
+  "version": "1.0.0",
+  "description": "Project-local CLI for Electron + Vue ERP projects",
+  "type": "module",
+  "bin": {
+    "eapp": "./src/index.js"
+  },
+  "files": ["src"],
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "fs-extra": "^11.2.0",
+    "minimist": "^1.2.8"
+  }
+}

package/src/generators/config.js

@@ -0,0 +1,71 @@
+import path from 'path';
+import fs from 'fs-extra';
+import chalk from 'chalk';
+import { assertProjectRoot, exists } from '../utils/fs.js';
+import { log } from '../utils/log.js';
+import { fieldsTable, radioLine } from '../tui/engine.js';
+
+export async function generateConfig(args, rawArgs) {
+  assertProjectRoot();
+
+  const cwd        = process.cwd();
+  const configFile = path.join(cwd, 'db.config.json');
+
+  let config = { mode: 'single', connections: [] };
+  if (await exists(configFile)) {
+    config = await fs.readJson(configFile);
+  }
+
+  // ── Mode toggle ───────────────────────────────────────────────────────────
+  console.log('');
+  console.log(chalk.bold.white('  Database mode'));
+  const mode = await radioLine('', [
+    { label: 'Single database', value: 'single' },
+    { label: 'Multi database',  value: 'multi'  },
+  ], config.mode === 'multi' ? 1 : 0);
+
+  // ── Connections table ─────────────────────────────────────────────────────
+  const rows = (config.connections || []).map(c => ({
+    name:     c.name     || '',
+    host:     c.host     || '',
+    port:     String(c.port || 1433),
+    user:     c.user     || '',
+    password: c.password ? '••••••' : '',
+    database: c.database || '',
+    // store real password separately so we don't lose it on ••••••
+    _realPass: c.password || '',
+  }));
+
+  if (!rows.length) {
+    rows.push({ name: 'default', host: '127.0.0.1', port: '1433', user: '', password: '', database: '', _realPass: '' });
+  }
+
+  console.log('');
+  const updated = await fieldsTable(
+    rows,
+    ['name', 'host', 'port', 'user', 'password', 'database'],
+    { name: 12, host: 16, port: 6, user: 10, password: 10, database: 14 },
+    'Connections  (+ add  - remove  ← → cols  ↑ ↓ rows  enter save)'
+  );
+
+  // Restore real passwords where user left ••••••
+  const connections = updated.map((r, i) => ({
+    name:     r.name,
+    host:     r.host,
+    port:     parseInt(r.port, 10) || 1433,
+    user:     r.user,
+    password: r.password === '••••••' ? (rows[i]?._realPass || '') : r.password,
+    database: r.database,
+  }));
+
+  const newConfig = { mode, connections };
+  await fs.writeJson(configFile, newConfig, { spaces: 2 });
+  log.success('db.config.json updated.');
+
+  // Also update app.config.json if it exists
+  const appConfigFile = path.join(cwd, 'app.config.json');
+  if (await exists(appConfigFile)) {
+    await fs.writeJson(appConfigFile, newConfig, { spaces: 2 });
+    log.success('app.config.json updated.');
+  }
+}

package/src/generators/entity.js

@@ -0,0 +1,256 @@
+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 { log } from '../utils/log.js';
+import { textInput, optionsLine, fieldsTable, radioLine } 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: '' },
+  ];
+}
+
+const DEFAULT_AUDIT_ROWS = [
+  { field: 'dt_creation',   type: 'datetime' },
+  { field: 'user_creation', type: 'varchar'  },
+  { field: 'dt_modif',      type: 'datetime' },
+  { field: 'user_modif',    type: 'varchar'  },
+];
+
+const FILLABLE_COLS   = ['field', 'type', 'values', 'pk', 'fk', 'group'];
+const FILLABLE_WIDTHS = { field: 18, type: 10, values: 14, pk: 4, fk: 4, group: 14 };
+const AUDIT_COLS      = ['field', 'type'];
+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';
+
+  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(', ');
+  const updateSet  = fillable.map(f => `${f.field} = @${f.field}`).join(', ');
+
+  return `import { ${dbAlias} as db } from '${importPath}';
+
+// Table  : ${TABLE}
+// Schema : ${schema}
+// PK     : ${pkField}
+
+export async function getAll() {
+  return db.query('SELECT * FROM ${TABLE}');
+}
+
+export async function getById(${pkField}) {
+  return db.queryOne('SELECT * FROM ${TABLE} WHERE ${pkField} = @${pkField}', { ${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 */'})',
+    data
+  );
+}
+
+export async function update(${pkField}, data) {
+  return db.execute(
+    'UPDATE ${TABLE} SET ${updateSet || '/* set */'} WHERE ${pkField} = @${pkField}',
+    { ...data, ${pkField} }
+  );
+}
+
+export async function remove(${pkField}) {
+  return db.execute('DELETE FROM ${TABLE} WHERE ${pkField} = @${pkField}', { ${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}); }
+`;
+}
+
+function buildIpcJson({ module, entity, schema }) {
+  const route = ipcRoute(module, entity);
+  const mod   = module === 'shared' ? 'shared' : module;
+  const ent   = toLower(entity);
+  return JSON.stringify({
+    route,
+    schema,
+    methods: {
+      getAll:  { handler: 'getAll',  permission: `${mod}.${ent}.view`   },
+      getById: { handler: 'getById', permission: `${mod}.${ent}.view`   },
+      add:     { handler: 'add',     permission: `${mod}.${ent}.add`    },
+      update:  { handler: 'update',  permission: `${mod}.${ent}.update` },
+      delete:  { handler: 'remove',  permission: `${mod}.${ent}.delete` },
+    },
+  }, null, 2);
+}
+
+function buildApiJs({ module, entity }) {
+  const route     = ipcRoute(module, entity);
+  const ClassName = toPascal(entity) + 'Api';
+  return `import { Api } from '../../api.js';
+
+class ${ClassName} extends Api {
+  constructor() { super('${route}'); }
+}
+
+export default new ${ClassName}();
+`;
+}
+
+function buildMetaJson({ module, entity, schema, fields, auditFields, pkField }) {
+  return JSON.stringify({ module, entity, schema, fields, auditFields, pkField }, null, 2);
+}
+
+// ─── Write entity files ───────────────────────────────────────────────────────
+
+async function writeEntity({ module, entity, schema, fields, auditFields, pkField, opts, dryRun }) {
+  const cwd = process.cwd();
+  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, schema, fields, auditFields, pkField }), { dryRun });
+  }
+  if (o.controller) {
+    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 });
+  }
+  // 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 });
+
+  if (o.api && o.ipc) {
+    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.`);
+}
+
+// ─── Main generator ───────────────────────────────────────────────────────────
+
+export async function generateEntity(args, rawArgs) {
+  assertProjectRoot();
+
+  const dryRun     = rawArgs.includes('--dry-run');
+  const useDefault = rawArgs.includes('--default');
+
+  // ── Show hint if no args ──────────────────────────────────────────────────
+  if (!args[0] && !useDefault) {
+    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('  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('');
+  }
+
+  // ── Parse or prompt for path ──────────────────────────────────────────────
+  let parsed;
+  if (args[0]) {
+    try { parsed = parseEntityPath(args[0]); }
+    catch (e) { log.error(e.message); process.exit(1); }
+  } else {
+    const input = await textInput('module/entity.schema:');
+    if (!input) { log.warn('Cancelled.'); return; }
+    try { parsed = parseEntityPath(input); }
+    catch (e) { log.error(e.message); process.exit(1); }
+  }
+
+  const { module, entity, schema } = parsed;
+  const pkField = `${entity}_id`;
+
+  // ── Check if exists ───────────────────────────────────────────────────────
+  const cwd = process.cwd();
+  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.');
+  }
+
+  // ── --default: skip all prompts ───────────────────────────────────────────
+  if (useDefault) {
+    await writeEntity({
+      module, entity, schema,
+      fields: defaultFillableRows(entity),
+      auditFields: DEFAULT_AUDIT_ROWS,
+      pkField,
+      opts: { model: true, controller: true, crud: true, api: true, ipc: true },
+      dryRun,
+    });
+    return;
+  }
+
+  // ── Options ───────────────────────────────────────────────────────────────
+  console.log('');
+  console.log(chalk.bold.white('  Options'));
+  const opts = await optionsLine([
+    { key: 'model',      label: 'Model',      default: true },
+    { key: 'controller', label: 'Controller', default: true },
+    { key: 'crud',       label: 'CRUD',       default: true },
+    { key: 'api',        label: 'API',        default: true },
+    { key: 'ipc',        label: 'IPC',        default: true },
+  ]);
+
+  // ── Fillable fields ───────────────────────────────────────────────────────
+  const fillableRows = await fieldsTable(
+    defaultFillableRows(entity),
+    FILLABLE_COLS,
+    FILLABLE_WIDTHS,
+    'Fillable Fields  (+ add  - remove  ← → cols  ↑ ↓ rows  space pk/fk  enter done)'
+  );
+
+  // ── Audit fields ──────────────────────────────────────────────────────────
+  const auditRows = await fieldsTable(
+    [...DEFAULT_AUDIT_ROWS],
+    AUDIT_COLS,
+    AUDIT_WIDTHS,
+    'Audit Fields (non-fillable)  (- to remove unwanted)'
+  );
+
+  // Find PK
+  const pkRow   = fillableRows.find(r => r.pk);
+  const resolvedPk = pkRow ? pkRow.field : pkField;
+
+  await writeEntity({
+    module, entity, schema,
+    fields: fillableRows,
+    auditFields: auditRows,
+    pkField: resolvedPk,
+    opts,
+    dryRun,
+  });
+}

package/src/generators/menu.js

@@ -0,0 +1,230 @@
+import path from 'path';
+import fs from 'fs-extra';
+import chalk from 'chalk';
+import { parseEntityPath, toLower, toPascal } from '../utils/naming.js';
+import { writeJson, exists, assertProjectRoot } from '../utils/fs.js';
+import { log } from '../utils/log.js';
+import { fieldsTable, radioLine, textInput } from '../tui/engine.js';
+
+// ─── Flatten nested menu items into table rows ────────────────────────────────
+
+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 || '',
+    });
+    if (item.children?.length) {
+      rows.push(...flattenItems(item.children, item.label));
+    }
+  }
+  return rows;
+}
+
+// ─── Rebuild nested menu items from flat rows ─────────────────────────────────
+
+function nestItems(rows) {
+  const top      = rows.filter(r => !r.parent);
+  const children = rows.filter(r => r.parent);
+
+  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);
+    if (kids.length) {
+      item.children = kids.map(c => ({
+        label: c.label, route: c.route, icon: c.icon,
+        ...(c.permission ? { permission: c.permission } : {}),
+      }));
+    }
+    return item;
+  });
+}
+
+// ─── View-level ribbon/classic menu editor ────────────────────────────────────
+
+async function editViewMenu(menuFile, existing) {
+  console.log('');
+  console.log(chalk.bold.white('  View menu style'));
+  const style = await radioLine('', [
+    { label: 'Classic (dropdown)', value: 'classic' },
+    { label: 'Ribbon (Office)',    value: 'ribbon'  },
+  ], existing?.hMenu?.style === 'ribbon' ? 1 : 0);
+
+  if (style === 'classic') {
+    // 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: '' });
+    }
+    console.log('');
+    const rows = await fieldsTable(
+      existing_items,
+      ['label', 'route', 'icon', 'parent', 'permission'],
+      { label: 16, route: 20, icon: 6, parent: 14, permission: 20 },
+      'hMenu items  (parent = dropdown group label, empty = top level)'
+    );
+    const menu = { route: existing?.route || '', hMenu: { style: 'classic', items: nestItems(rows) } };
+    await writeJson(menuFile, menu);
+    log.success('View menu updated.');
+    return;
+  }
+
+  // Ribbon — tabs → groups → items
+  const tabs = existing?.hMenu?.tabs || [{ label: 'General', groups: [] }];
+  console.log('');
+  const tabRows = await fieldsTable(
+    tabs.map(t => ({ label: t.label })),
+    ['label'],
+    { label: 20 },
+    'Ribbon tabs  (+ add  - remove  enter done)'
+  );
+
+  const builtTabs = [];
+  for (const tabRow of tabRows) {
+    const existingTab = tabs.find(t => t.label === tabRow.label) || { groups: [] };
+    console.log('');
+    console.log(chalk.bold.white(`  Tab: ${tabRow.label} — Groups`));
+    const groupRows = await fieldsTable(
+      (existingTab.groups || [{ label: 'Actions' }]).map(g => ({ label: g.label })),
+      ['label'],
+      { label: 20 },
+      'Groups  (+ add  - remove  enter done)'
+    );
+
+    const builtGroups = [];
+    for (const groupRow of groupRows) {
+      const existingGroup = (existingTab.groups || []).find(g => g.label === groupRow.label) || { items: [] };
+      console.log('');
+      console.log(chalk.bold.white(`  Group: ${groupRow.label} — Items`));
+      const itemRows = await fieldsTable(
+        (existingGroup.items || [
+          { label: 'New',    action: 'emit:new',    icon: '+' },
+          { label: 'Save',   action: 'emit:save',   icon: '💾' },
+          { label: 'Delete', action: 'emit:delete', icon: '🗑' },
+        ]),
+        ['label', 'action', 'icon'],
+        { label: 14, action: 20, icon: 6 },
+        'Items  (action: emit:name | route:/path)'
+      );
+      builtGroups.push({ label: groupRow.label, items: itemRows });
+    }
+    builtTabs.push({ label: tabRow.label, groups: builtGroups });
+  }
+
+  const menu = { route: existing?.route || '', hMenu: { style: 'ribbon', tabs: builtTabs } };
+  await writeJson(menuFile, menu);
+  log.success('View ribbon menu updated.');
+}
+
+// ─── Main generator ───────────────────────────────────────────────────────────
+
+export async function generateMenu(args, rawArgs) {
+  assertProjectRoot();
+  const cwd = process.cwd();
+
+  const target = args[0]; // e.g. "rh" or "rh/employee"
+
+  // ── Determine if this is a view-level or module-level menu ────────────────
+  let isViewMenu = false;
+  let module     = '';
+  let entity     = '';
+
+  if (target) {
+    if (target.includes('/')) {
+      // view-level: rh/employee
+      try {
+        const parsed = parseEntityPath(target);
+        module       = parsed.module;
+        entity       = parsed.entity;
+        isViewMenu   = true;
+      } catch (e) {
+        // treat as module name
+        module = toLower(target);
+      }
+    } else {
+      module = toLower(target);
+    }
+  } else {
+    // Interactive: pick module, then optionally entity
+    console.log('');
+    const menusDir  = path.join(cwd, 'src', 'frontend', 'menus');
+    const menuFiles = (await fs.readdir(menusDir)).filter(f => f.endsWith('.menu.json'));
+    const modules   = menuFiles
+      .filter(f => !f.includes('.') || f.split('.').length === 2)
+      .map(f => f.replace('.menu.json', ''));
+
+    module = await textInput('Module name (e.g. rh):');
+    const ent = await textInput('Entity name (leave blank for module-level menu):');
+    if (ent) { entity = ent; isViewMenu = true; }
+  }
+
+  const menusDir = path.join(cwd, 'src', 'frontend', 'menus');
+
+  // ── View-level menu ───────────────────────────────────────────────────────
+  if (isViewMenu) {
+    const menuFile = path.join(menusDir, `${module}.${entity}.menu.json`);
+    const existing = (await exists(menuFile)) ? await fs.readJson(menuFile) : null;
+    await editViewMenu(menuFile, existing);
+    return;
+  }
+
+  // ── Module-level menu ─────────────────────────────────────────────────────
+  const menuFile = path.join(menusDir, `${module}.menu.json`);
+  let existing   = { module, label: toPascal(module), hMenu: { style: 'classic', items: [] }, vMenu: { items: [] } };
+  if (await exists(menuFile)) {
+    existing = await fs.readJson(menuFile);
+  }
+
+  // Pass 1 — hMenu
+  console.log('');
+  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: '' });
+  }
+
+  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)'
+  );
+
+  // Pass 2 — vMenu
+  console.log('');
+  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: '' });
+  }
+
+  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)'
+  );
+
+  // Also check hMenu style
+  console.log('');
+  console.log(chalk.bold.white('  hMenu style'));
+  const style = await radioLine('', [
+    { label: 'Classic (dropdown)', value: 'classic' },
+    { label: 'Ribbon (Office)',    value: 'ribbon'  },
+  ], existing.hMenu?.style === 'ribbon' ? 1 : 0);
+
+  const updated = {
+    module,
+    label: toPascal(module),
+    hMenu: { style, items: nestItems(updatedH) },
+    vMenu: { items: nestItems(updatedV) },
+  };
+
+  await writeJson(menuFile, updated);
+  log.success(`${module}.menu.json updated.`);
+}