@cosider.construction/eapp 1.0.0

package/src/generators/misc.js

@@ -0,0 +1,231 @@
+import path from 'path';
+import chalk from 'chalk';
+import { toUpper, toLower, toPascal, isValidName, parseEntityPath } from '../utils/naming.js';
+import { writeFile, writeJson, exists, assertProjectRoot, readDir, loadEntityRegistry } from '../utils/fs.js';
+import { log } from '../utils/log.js';
+import { textInput } from '../tui/engine.js';
+
+// ─── Module ───────────────────────────────────────────────────────────────────
+
+export async function generateModule(args, rawArgs) {
+  assertProjectRoot();
+  const dryRun = rawArgs.includes('--dry-run');
+  const schema = rawArgs[rawArgs.indexOf('--schema') + 1] || null;
+
+  let name = args[0] || await textInput('Module name:');
+  name = toLower(name.trim());
+
+  if (!isValidName(name)) { log.error('Invalid module name.'); process.exit(1); }
+
+  const cwd = process.cwd();
+  const backendDir  = path.join(cwd, 'src', 'backend', 'modules', toUpper(name));
+  const frontendDir = path.join(cwd, 'src', 'frontend', 'views', 'modules', name);
+
+  if (!dryRun && await exists(backendDir)) {
+    log.warn(`Module ${toUpper(name)} already exists. Skipping.`); return;
+  }
+
+  await writeFile(path.join(backendDir,  '.gitkeep'), '', { dryRun });
+  await writeFile(path.join(frontendDir, '.gitkeep'), '', { dryRun });
+
+  if (schema) {
+    await writeFile(path.join(backendDir, 'schema.sql'),
+      `-- Create schema for ${toUpper(name)} module\nIF NOT EXISTS (SELECT * FROM sys.schemas WHERE name = '${name}')\n  EXEC('CREATE SCHEMA ${name}');\n`,
+      { dryRun });
+  }
+
+  // Menu file
+  const menuFile = path.join(cwd, 'src', 'frontend', 'menus', `${name}.menu.json`);
+  if (!(await exists(menuFile))) {
+    await writeJson(menuFile, { module: name, label: toPascal(name), hMenu: [], vMenu: [] }, { dryRun });
+  }
+
+  log.success(`Module ${chalk.cyan(toUpper(name))} created.`);
+}
+
+// ─── Menu (interactive table) ─────────────────────────────────────────────────
+
+export async function generateMenu(args, rawArgs) {
+  assertProjectRoot();
+  const dryRun = rawArgs.includes('--dry-run');
+  const cwd = process.cwd();
+
+  // Load all existing menu entries from all menu files
+  const { fieldsTable } = await import('../tui/engine.js');
+  const fs = await import('fs-extra').then(m => m.default);
+
+  const menusDir = path.join(cwd, 'src', 'frontend', 'menus');
+  const menuFiles = (await fs.readdir(menusDir)).filter(f => f.endsWith('.menu.json'));
+
+  // Build flat list of all entries
+  const allEntries = [];
+  for (const file of menuFiles) {
+    const menu = await import('fs-extra').then(m => m.default.readJson(path.join(menusDir, file)));
+    const mod = menu.module || file.replace('.menu.json', '');
+    for (const item of (menu.hMenu || [])) {
+      const existing = allEntries.find(e => e.module === mod && e.entry === (item.label || item.route));
+      if (existing) { existing.hMenu = 'on'; }
+      else allEntries.push({ module: mod, entry: item.label || item.route, route: item.route, hMenu: 'on', vMenu: 'off', permission: item.permission || '' });
+    }
+    for (const item of (menu.vMenu || [])) {
+      const existing = allEntries.find(e => e.module === mod && e.entry === (item.label || item.route));
+      if (existing) { existing.vMenu = 'on'; }
+      else allEntries.push({ module: mod, entry: item.label || item.route, route: item.route, hMenu: 'off', vMenu: 'on', permission: item.permission || '' });
+    }
+  }
+
+  if (!allEntries.length) {
+    log.info('No menu entries yet. Generate some views with menu enabled first.');
+    return;
+  }
+
+  console.log('');
+  const updated = await fieldsTable(
+    allEntries,
+    ['module', 'entry', 'hMenu', 'vMenu'],
+    { module: 16, entry: 20, hMenu: 7, vMenu: 7 },
+    'Menu entries  (space to toggle hMenu/vMenu  enter to save)'
+  );
+
+  // Write back to each menu file
+  if (!dryRun) {
+    const byModule = {};
+    for (const row of updated) {
+      if (!byModule[row.module]) byModule[row.module] = { hMenu: [], vMenu: [] };
+      const item = { label: row.entry, route: row.route, icon: '', permission: row.permission };
+      if (row.hMenu === 'on') byModule[row.module].hMenu.push(item);
+      if (row.vMenu === 'on') byModule[row.module].vMenu.push(item);
+    }
+    for (const [mod, data] of Object.entries(byModule)) {
+      const menuFile = path.join(menusDir, `${mod}.menu.json`);
+      const existing = await fs.pathExists(menuFile) ? await fs.readJson(menuFile) : { module: mod, label: toPascal(mod) };
+      await fs.writeJson(menuFile, { ...existing, ...data }, { spaces: 2 });
+      log.success(`Updated ${mod}.menu.json`);
+    }
+  } else {
+    log.info('[dry-run] would update menu files');
+  }
+}
+
+// ─── Pivot ────────────────────────────────────────────────────────────────────
+
+export async function generatePivot(args, rawArgs) {
+  assertProjectRoot();
+  const dryRun = rawArgs.includes('--dry-run');
+
+  if (!args[0] || !args[1]) {
+    log.error('Usage: eapp pivot <module/entity-a> <module/entity-b>');
+    process.exit(1);
+  }
+
+  const a = parseEntityPath(args[0]);
+  const b = parseEntityPath(args[1]);
+
+  const sameModule  = a.module === b.module && a.module !== 'shared';
+  const pivotModule = sameModule ? a.module : 'shared';
+  const pivotEntity = `${toUpper(a.entity)}_${toUpper(b.entity)}`;
+  const pivotLower  = pivotEntity.toLowerCase();
+  const schema      = sameModule ? a.schema : 'dbo';
+
+  const cwd = process.cwd();
+  const backendBase = sameModule
+    ? path.join(cwd, 'src', 'backend', 'modules', toUpper(pivotModule), pivotEntity)
+    : path.join(cwd, 'src', 'backend', 'shared', pivotEntity);
+
+  const fields = [
+    { field: `${a.entity}_id`, type: 'int', pk: false, fk: true,  group: '', values: '' },
+    { field: `${b.entity}_id`, type: 'int', pk: false, fk: true,  group: '', values: '' },
+  ];
+
+  // Simple model for pivot
+  const modelJs = `import { ${schema} as db } from '../../engine/db.js';
+
+export async function getAll()          { return db.query('SELECT * FROM ${pivotEntity}'); }
+export async function getByA(${a.entity}_id) { return db.query('SELECT * FROM ${pivotEntity} WHERE ${a.entity}_id = @${a.entity}_id', { ${a.entity}_id }); }
+export async function add(data)         { return db.execute('INSERT INTO ${pivotEntity} (${a.entity}_id, ${b.entity}_id) VALUES (@${a.entity}_id, @${b.entity}_id)', data); }
+export async function remove(${a.entity}_id, ${b.entity}_id) { return db.execute('DELETE FROM ${pivotEntity} WHERE ${a.entity}_id = @${a.entity}_id AND ${b.entity}_id = @${b.entity}_id', { ${a.entity}_id, ${b.entity}_id }); }
+`;
+
+  await writeFile(path.join(backendBase, 'model.js'),      modelJs, { dryRun });
+  await writeFile(path.join(backendBase, 'controller.js'), `import * as model from './model.js';\nexport const getAll = model.getAll;\nexport const getByA = model.getByA;\nexport const add    = model.add;\nexport const remove = model.remove;\n`, { dryRun });
+  await writeJson(path.join(backendBase, 'ipc.json'), {
+    route: `${sameModule ? 'modules.' + toUpper(pivotModule) + '.' : 'shared.'}${pivotEntity}`,
+    schema,
+    methods: {
+      getAll:  { handler: 'getAll' },
+      getByA:  { handler: 'getByA' },
+      add:     { handler: 'add'   },
+      delete:  { handler: 'remove' },
+    },
+  }, { dryRun });
+
+  log.success(`Pivot ${chalk.cyan(pivotEntity)} created in ${sameModule ? toUpper(pivotModule) : 'shared'}.`);
+}
+
+// ─── Layout ───────────────────────────────────────────────────────────────────
+
+export async function generateLayout(args, rawArgs) {
+  assertProjectRoot();
+  const dryRun = rawArgs.includes('--dry-run');
+
+  let name = args[0] || await textInput('Layout name (e.g. rh, admin, default):');
+  name = name.trim();
+  if (!isValidName(name)) { log.error('Invalid layout name.'); process.exit(1); }
+
+  const cwd      = process.cwd();
+  const Pascal   = toPascal(name);
+  const filePath = path.join(cwd, 'src', 'frontend', 'layouts', `${Pascal}Layout.vue`);
+
+  if (!dryRun && await exists(filePath)) {
+    log.warn(`${Pascal}Layout.vue already exists — overwriting.`);
+  }
+
+  const stub = `<script setup>
+// ${Pascal}Layout — page shell
+</script>
+<template>
+  <div class="${toLower(name)}-layout">
+    <header class="${toLower(name)}-layout__header"><!-- header --></header>
+    <main class="${toLower(name)}-layout__main"><slot /></main>
+  </div>
+</template>
+<style scoped>
+.${toLower(name)}-layout { display:flex;flex-direction:column;min-height:100vh; }
+.${toLower(name)}-layout__main { flex:1;padding:1rem; }
+</style>
+`;
+
+  await writeFile(filePath, stub, { dryRun });
+  log.success(`Layout ${chalk.cyan(Pascal + 'Layout.vue')} generated.`);
+}
+
+// ─── List commands ────────────────────────────────────────────────────────────
+
+export async function listModules() {
+  assertProjectRoot();
+  const cwd = process.cwd();
+  const modules = await readDir(path.join(cwd, 'src', 'backend', 'modules'));
+  if (!modules.length) { log.info('No modules found.'); return; }
+  console.log(chalk.bold('\nModules:'));
+  modules.forEach(m => console.log('  ' + chalk.cyan(m)));
+}
+
+export async function listEntities(args) {
+  assertProjectRoot();
+  const registry = await loadEntityRegistry(process.cwd());
+  const filter   = args[0] ? toLower(args[0]) : null;
+
+  const entries = [...registry.entries()]
+    .filter(([key]) => !filter || key.startsWith(filter + '.'))
+    .sort(([a], [b]) => a.localeCompare(b));
+
+  if (!entries.length) { log.info('No entities found.'); return; }
+  console.log(chalk.bold('\nEntities:'));
+  entries.forEach(([, meta]) => {
+    console.log(
+      '  ' + chalk.cyan(meta.module) + chalk.dim('/') +
+      chalk.white(meta.entity) + chalk.dim('.' + meta.schema) +
+      chalk.dim('  pk:' + meta.pkField)
+    );
+  });
+}

package/src/generators/module.js

@@ -0,0 +1,202 @@
+import path from 'path';
+import fs from 'fs-extra';
+import chalk from 'chalk';
+import { toUpper, toLower, toPascal, isValidName } from '../utils/naming.js';
+import { writeFile, writeJson, exists, readDir, assertProjectRoot } from '../utils/fs.js';
+import { log } from '../utils/log.js';
+import { textInput, fieldsTable } from '../tui/engine.js';
+
+// ─── Stubs ────────────────────────────────────────────────────────────────────
+
+function moduleLayoutStub(name) {
+  const Pascal = toPascal(name);
+  return `<script setup>
+import { inject } from 'vue';
+import AppMenuH from '@/components/AppMenuH.vue';
+import AppMenuV from '@/components/AppMenuV.vue';
+import moduleMenu from '@/menus/${toLower(name)}.menu.json';
+
+const subHMenu    = inject('hMenuConfig', null);
+const hMenuConfig = moduleMenu.hMenu || { style: 'classic', items: [] };
+const vMenuConfig = moduleMenu.vMenu || { items: [] };
+</script>
+
+<template>
+  <div class="${toLower(name)}-layout">
+    <AppMenuH :config="hMenuConfig" />
+    <AppMenuH v-if="subHMenu" :config="subHMenu" sub />
+    <div class="${toLower(name)}-layout__body">
+      <AppMenuV :config="vMenuConfig" />
+      <main class="${toLower(name)}-layout__main"><slot /></main>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.${toLower(name)}-layout       { display:flex;flex-direction:column;height:100vh;overflow:hidden; }
+.${toLower(name)}-layout__body { display:flex;flex:1;overflow:hidden; }
+.${toLower(name)}-layout__main { flex:1;overflow:auto;padding:1.5rem;background:#1e1e2e; }
+</style>
+`;
+}
+
+function moduleHomeStub(name) {
+  const label = toPascal(name);
+  return `<script setup>
+import { ref } from 'vue';
+
+const gridConfig = ref([
+  { id: 'w1', col: 1, row: 1, colSpan: 2, rowSpan: 1, type: 'placeholder', title: '${label} Overview' },
+  { id: 'w2', col: 3, row: 1, colSpan: 1, rowSpan: 1, type: 'placeholder', title: 'Quick Stats' },
+  { id: 'w3', col: 1, row: 2, colSpan: 3, rowSpan: 1, type: 'placeholder', title: 'Recent Activity' },
+]);
+
+const COLS = 3;
+function gridStyle(w) {
+  return { gridColumn: \`\${w.col} / span \${w.colSpan}\`, gridRow: \`\${w.row} / span \${w.rowSpan}\` };
+}
+</script>
+
+<template>
+  <div class="${toLower(name)}-home">
+    <div class="home-header">
+      <h1>${label}</h1>
+      <p class="sub">Module overview</p>
+    </div>
+    <div class="widget-grid" :style="{ '--grid-cols': COLS }">
+      <div v-for="w in gridConfig" :key="w.id" class="widget" :style="gridStyle(w)">
+        <div class="widget__header"><span>{{ w.title }}</span></div>
+        <div class="widget__body">
+          <div class="widget__placeholder">
+            <span>{{ w.type }}</span><small>Configure in gridConfig</small>
+          </div>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.${toLower(name)}-home { padding:1.5rem;color:#cdd6f4; }
+.home-header { margin-bottom:1.5rem; }
+h1 { font-size:1.4rem;font-weight:700;margin:0; }
+.sub { color:#6c7086;margin:.25rem 0 0;font-size:.875rem; }
+.widget-grid { display:grid;grid-template-columns:repeat(var(--grid-cols,3),1fr);gap:1rem; }
+.widget { background:#313244;border:1px solid #45475a;border-radius:10px;overflow:hidden;display:flex;flex-direction:column;min-height:160px; }
+.widget__header { padding:.75rem 1rem;border-bottom:1px solid #45475a; }
+.widget__body { flex:1;padding:1rem; }
+.widget__placeholder { height:100%;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:.35rem;color:#585b70;font-size:.8rem; }
+</style>
+`;
+}
+
+function moduleMenuJson(name) {
+  return {
+    module: toLower(name),
+    label:  toPascal(name),
+    hMenu:  { style: 'classic', items: [
+      { label: `${toPascal(name)} Home`, route: `/${toLower(name)}`, icon: '' },
+    ]},
+    vMenu:  { items: [
+      { label: toPascal(name), icon: '', children: [] },
+    ]},
+  };
+}
+
+// ─── Generator ────────────────────────────────────────────────────────────────
+
+export async function generateModule(args, rawArgs) {
+  assertProjectRoot();
+
+  const dryRun = rawArgs.includes('--dry-run');
+  const cwd    = process.cwd();
+
+  // ── Load existing modules for table ───────────────────────────────────────
+  const modulesDir = path.join(cwd, 'src', 'backend', 'modules');
+  const existing   = await readDir(modulesDir);
+
+  // Build table rows from existing modules
+  const rows = existing.map(mod => {
+    const lower = toLower(mod);
+    return {
+      module:  lower,
+      layout:  `${toPascal(lower)}Layout`,
+      vmenu:   'own',
+      home:    'on',
+      grid:    'on',
+    };
+  });
+
+  // Add a new empty row if a name was provided or will be typed
+  let newName = args[0] || '';
+
+  if (!newName && !existing.length) {
+    newName = await textInput('Module name (e.g. rh, sales, stk):');
+  }
+
+  if (newName) {
+    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' });
+    }
+  }
+
+  // ── Show module table ─────────────────────────────────────────────────────
+  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)'
+  );
+
+  // ── 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 layoutName = row.layout || `${toPascal(name)}Layout`;
+
+    const backendDir  = path.join(cwd, 'src', 'backend',  'modules', toUpper(name));
+    const frontendDir = path.join(cwd, 'src', 'frontend', 'views',   'modules', name);
+    const layoutFile  = path.join(cwd, 'src', 'frontend', 'layouts', `${layoutName}.vue`);
+    const menuFile    = path.join(cwd, 'src', 'frontend', 'menus',   `${name}.menu.json`);
+    const homeFile    = path.join(cwd, 'src', 'frontend', 'views',   'modules', name, `${toPascal(name)}Home.vue`);
+    const routerFile  = path.join(cwd, 'src', 'frontend', 'router',  'index.js');
+
+    // Backend dir
+    if (!(await exists(backendDir)))  await writeFile(path.join(backendDir,  '.gitkeep'), '', { dryRun });
+    if (!(await exists(frontendDir))) await writeFile(path.join(frontendDir, '.gitkeep'), '', { dryRun });
+
+    // Menu JSON
+    if (!(await exists(menuFile))) {
+      await writeJson(menuFile, moduleMenuJson(name), { dryRun });
+    }
+
+    // Layout
+    if (!(await exists(layoutFile))) {
+      await writeFile(layoutFile, moduleLayoutStub(name), { dryRun });
+    }
+
+    // Module home
+    if (hasHome && !(await exists(homeFile))) {
+      await writeFile(homeFile, moduleHomeStub(name), { dryRun });
+    }
+
+    // Router entry for module home
+    if (hasHome && !dryRun && await exists(routerFile)) {
+      const content = await fs.readFile(routerFile, 'utf8');
+      const route   = `/${name}`;
+      if (!content.includes(`path: '${route}'`)) {
+        const entry = `  {\n    path: '${route}',\n    component: () => import('@/views/modules/${name}/${toPascal(name)}Home.vue'),\n  },`;
+        const updated = content.replace(/\/\/ routes/i, `// routes\n${entry}`);
+        await fs.writeFile(routerFile, updated, 'utf8');
+        log.success(`Added route ${route} to router`);
+      }
+    }
+
+    log.success(`Module ${chalk.cyan(toUpper(name))} ${existing.find(e => toLower(e) === name) ? 'updated' : 'created'}.`);
+  }
+}