@cosider.construction/eapp 1.0.0

package/src/generators/view.js

@@ -0,0 +1,466 @@
+import path from 'path';
+import chalk from 'chalk';
+import { parseEntityPath, toUpper, toLower, toPascal } from '../utils/naming.js';
+import { writeFile, exists, assertProjectRoot, loadEntityRegistry, upsertMenuItem } from '../utils/fs.js';
+import { log } from '../utils/log.js';
+import { radioLine, optionsLine, fieldsTable } from '../tui/engine.js';
+
+// ─── Behaviour stubs ──────────────────────────────────────────────────────────
+
+function indexStub({ module, entity, behaviour }) {
+  const Pascal = toPascal(entity);
+  const lower  = toLower(entity);
+
+  const stubs = {
+    page: `<script setup>
+import ${Pascal}List from './${Pascal}List.vue';
+import ${Pascal}Form from './${Pascal}Form.vue';
+import { ref } from 'vue';
+const selected = ref(null);
+</script>
+<template>
+  <div class="${lower}-page">
+    <${Pascal}List @select="selected = $event" />
+    <router-view />
+  </div>
+</template>`,
+
+    popup: `<script setup>
+import ${Pascal}List from './${Pascal}List.vue';
+import ${Pascal}Form from './${Pascal}Form.vue';
+import { ref } from 'vue';
+const selected = ref(null);
+const showForm = ref(false);
+function open(id) { selected.value = id; showForm.value = true; }
+function close()  { showForm.value = false; selected.value = null; }
+</script>
+<template>
+  <div class="${lower}-container">
+    <${Pascal}List @select="open" />
+    <teleport to="body">
+      <div v-if="showForm" class="overlay" @click.self="close">
+        <div class="popup">
+          <${Pascal}Form :id="selected" @saved="close" @close="close" />
+        </div>
+      </div>
+    </teleport>
+  </div>
+</template>
+<style scoped>
+.overlay { position:fixed;inset:0;background:rgba(0,0,0,.45);display:flex;align-items:center;justify-content:center;z-index:100; }
+.popup   { background:#fff;border-radius:10px;padding:2rem;min-width:480px;max-height:90vh;overflow:auto; }
+</style>`,
+
+    right: splitStub(Pascal, lower, 'right'),
+    left:  splitStub(Pascal, lower, 'left'),
+    top:   splitStub(Pascal, lower, 'top'),
+    bottom: splitStub(Pascal, lower, 'bottom'),
+  };
+
+  return stubs[behaviour] || stubs.page;
+}
+
+function splitStub(Pascal, lower, side) {
+  const isVertical   = side === 'top'   || side === 'bottom';
+  const isFormFirst  = side === 'left'  || side === 'top';
+  const flexDir      = isVertical ? 'column' : 'row';
+  const [first, sec] = isFormFirst
+    ? [`<${Pascal}Form :id="selected" @saved="selected=null" />`, `<${Pascal}List @select="selected=$event" />`]
+    : [`<${Pascal}List @select="selected=$event" />`,             `<${Pascal}Form :id="selected" @saved="selected=null" />`];
+
+  return `<script setup>
+import ${Pascal}List from './${Pascal}List.vue';
+import ${Pascal}Form from './${Pascal}Form.vue';
+import { ref } from 'vue';
+const selected = ref(null);
+</script>
+<template>
+  <div class="${lower}-split">
+    ${first}
+    ${sec}
+  </div>
+</template>
+<style scoped>
+.${lower}-split { display:flex;flex-direction:${flexDir};gap:1rem;height:100%; }
+.${lower}-split > * { flex:1;overflow:auto; }
+</style>`;
+}
+
+// ─── List component ───────────────────────────────────────────────────────────
+
+function listStub({ module, entity, hasRow, hasCard }) {
+  const Pascal = toPascal(entity);
+  const lower  = toLower(entity);
+  const apiPath = `@/api/modules/${lower}.${lower}.api.js`;
+
+  const rowImport  = hasRow  ? `import ${Pascal}ListRow  from './${Pascal}ListRow.vue';`  : '';
+  const cardImport = hasCard ? `import ${Pascal}ListCard from './${Pascal}ListCard.vue';` : '';
+  const toggleBtn  = (hasRow && hasCard)
+    ? `<div class="render-toggle">
+      <button :class="{ active: render==='table' }" @click="render='table'">Table</button>
+      <button :class="{ active: render==='card'  }" @click="render='card'">Cards</button>
+    </div>` : '';
+  const renderBlock = hasRow && hasCard
+    ? `<${Pascal}ListRow  v-if="render==='table'" v-for="item in items" :key="item.id" :item="item" @select="$emit('select', item.id)" />
+    <${Pascal}ListCard v-if="render==='card'"  v-for="item in items" :key="item.id" :item="item" @select="$emit('select', item.id)" />`
+    : hasRow
+      ? `<${Pascal}ListRow v-for="item in items" :key="item.id" :item="item" @select="$emit('select', item.id)" />`
+      : hasCard
+        ? `<${Pascal}ListCard v-for="item in items" :key="item.id" :item="item" @select="$emit('select', item.id)" />`
+        : `<div v-for="item in items" :key="item.id" @click="$emit('select', item.id)">{{ item }}</div>`;
+
+  return `<script setup>
+import { ref, onMounted } from 'vue';
+import api from '${apiPath}';
+${rowImport}
+${cardImport}
+
+// Props: parentId filters list to a specific parent (slave/scoped mode)
+const props = defineProps({ parentId: { type: Number, default: null } });
+const emit  = defineEmits(['select']);
+
+const items   = ref([]);
+const loading = ref(false);
+${hasRow && hasCard ? "const render = ref('table');" : ''}
+
+// <!-- FILTER_SLOT: plug your filter package here -->
+
+async function load() {
+  loading.value = true;
+  try {
+    items.value = props.parentId != null
+      ? await api.getAll({ parentId: props.parentId })
+      : await api.getAll();
+  } finally {
+    loading.value = false;
+  }
+}
+
+onMounted(load);
+defineExpose({ reload: load });
+</script>
+
+<template>
+  <div class="${lower}-list">
+    ${toggleBtn}
+    <div v-if="loading">Loading…</div>
+    <div v-else>
+      ${renderBlock}
+    </div>
+  </div>
+</template>
+`;
+}
+
+// ─── Form component ───────────────────────────────────────────────────────────
+
+function formStub({ module, entity }) {
+  const Pascal  = toPascal(entity);
+  const lower   = toLower(entity);
+  const apiPath = `@/api/modules/${lower}.${lower}.api.js`;
+
+  return `<script setup>
+import { ref, watch } from 'vue';
+import api from '${apiPath}';
+
+const props = defineProps({ id: { type: Number, default: null } });
+const emit  = defineEmits(['saved', 'close']);
+
+const form = ref({});
+
+watch(() => props.id, async (id) => {
+  if (id) form.value = await api.getById(id);
+  else form.value = {};
+}, { immediate: true });
+
+async function save() {
+  if (form.value.id) await api.update(form.value.id, form.value);
+  else await api.add(form.value);
+  emit('saved');
+}
+</script>
+
+<template>
+  <div class="${lower}-form">
+    <h3>{{ form.id ? 'Edit' : 'New' }} ${Pascal}</h3>
+    <!-- Add form fields here -->
+    <div class="form-actions">
+      <button @click="save">Save</button>
+      <button @click="$emit('close')">Cancel</button>
+    </div>
+  </div>
+</template>
+`;
+}
+
+// ─── ListRow / ListCard stubs ─────────────────────────────────────────────────
+
+function listRowStub({ entity }) {
+  const Pascal = toPascal(entity);
+  return `<script setup>
+defineProps({ item: { type: Object, required: true } });
+defineEmits(['select']);
+</script>
+<template>
+  <tr class="${toLower(entity)}-row" @click="$emit('select', item.id)" style="cursor:pointer">
+    <!-- render row cells here -->
+    <td>{{ item.id }}</td>
+  </tr>
+</template>
+`;
+}
+
+function listCardStub({ entity }) {
+  const Pascal = toPascal(entity);
+  return `<script setup>
+defineProps({ item: { type: Object, required: true } });
+defineEmits(['select']);
+</script>
+<template>
+  <div class="${toLower(entity)}-card" @click="$emit('select', item.id)" style="cursor:pointer;border:1px solid #ccc;border-radius:8px;padding:1rem;">
+    <!-- render card content here -->
+    <strong>{{ item.id }}</strong>
+  </div>
+</template>
+`;
+}
+
+// ─── Slave part stub ──────────────────────────────────────────────────────────
+
+function slavePartStub({ masterEntity, slaveModule, slaveEntity, behaviour }) {
+  const MasterPascal = toPascal(masterEntity);
+  const SlavePascal  = toPascal(slaveEntity);
+  const SlaveList    = `${SlavePascal}List`;
+  const SlaveForm    = `${SlavePascal}Form`;
+  const fkField      = `${toLower(masterEntity)}_id`;
+
+  const formSection = behaviour === 'popup'
+    ? `<teleport to="body">
+      <div v-if="showForm" class="overlay" @click.self="showForm=false">
+        <div class="popup"><${SlaveForm} :id="selectedId" @saved="showForm=false;listRef.reload()" @close="showForm=false" /></div>
+      </div>
+    </teleport>`
+    : behaviour === 'tab'
+      ? `<!-- rendered as tab, see parent tabs -->`
+      : `<${SlaveForm} v-if="selectedId" :id="selectedId" @saved="selectedId=null;listRef.reload()" />`;
+
+  return `<script setup>
+import { ref } from 'vue';
+import ${SlaveList} from '@/views/modules/${toLower(slaveModule)}/${toLower(slaveEntity)}/${SlavePascal}List.vue';
+${behaviour !== 'tab' ? `import ${SlaveForm} from '@/views/modules/${toLower(slaveModule)}/${toLower(slaveEntity)}/${SlavePascal}Form.vue';` : ''}
+
+// Slave part: ${SlavePascal} scoped to ${MasterPascal}
+const props = defineProps({ parentId: { type: Number, required: true } });
+
+const listRef    = ref(null);
+const selectedId = ref(null);
+${behaviour === 'popup' ? "const showForm = ref(false);" : ''}
+</script>
+
+<template>
+  <div class="${toLower(masterEntity)}-${toLower(slaveEntity)}">
+    <${SlaveList} ref="listRef" :parentId="props.parentId" @select="selectedId = $event${behaviour === 'popup' ? '; showForm = true' : ''}" />
+    ${formSection}
+  </div>
+</template>
+${behaviour === 'popup' ? `<style scoped>
+.overlay { position:fixed;inset:0;background:rgba(0,0,0,.45);display:flex;align-items:center;justify-content:center;z-index:100; }
+.popup   { background:#fff;border-radius:10px;padding:2rem;min-width:480px; }
+</style>` : ''}
+`;
+}
+
+// ─── Components table ─────────────────────────────────────────────────────────
+
+const COMP_COLS   = ['comp', 'route', 'menu', 'render'];
+const COMP_WIDTHS = { comp: 16, route: 22, menu: 6, render: 16 };
+
+// ─── Main generator ───────────────────────────────────────────────────────────
+
+export async function generateView(args, rawArgs) {
+  assertProjectRoot();
+
+  const dryRun     = rawArgs.includes('--dry-run');
+  const useDefault = rawArgs.includes('--default');
+
+  let parsed;
+  if (args[0]) {
+    try { parsed = parseEntityPath(args[0]); }
+    catch (e) { log.error(e.message); process.exit(1); }
+  } else {
+    console.log('');
+    console.log(chalk.bold.cyan('  eapp view') + chalk.dim(' <module/entity>'));
+    console.log('');
+    const { textInput } = await import('../tui/engine.js');
+    const input = await textInput('module/entity:');
+    if (!input) { log.warn('Cancelled.'); return; }
+    try { parsed = parseEntityPath(input); }
+    catch (e) { log.error(e.message); process.exit(1); }
+  }
+
+  const { module, entity } = parsed;
+  const Pascal = toPascal(entity);
+  const cwd    = process.cwd();
+
+  // ── Load entity registry to detect slaves ─────────────────────────────────
+  const registry = await loadEntityRegistry(cwd);
+  const entityMeta = registry.get(`${module}.${entity}`);
+
+  // Detect slaves — entities that have an FK pointing to this entity
+  const slaves = [];
+  for (const [key, meta] of registry.entries()) {
+    if (key === `${module}.${entity}`) continue;
+    const hasFk = meta.fields?.some(f => f.fk && f.field === `${entity}_id`);
+    if (hasFk) slaves.push(meta);
+  }
+
+  if (useDefault) {
+    await _writeView({ module, entity, behaviour: 'page', hasRow: true, hasCard: false,
+      comps: [
+        { comp: 'List', route: `/${module}/${entity}`, menu: true,  render: 'row' },
+        { comp: 'Form', route: '',                     menu: false, render: ''    },
+      ],
+      slaves: slaves.map(s => ({ ...s, behaviour: 'popup', menu: false })),
+      dryRun, cwd,
+    });
+    return;
+  }
+
+  // ── Step 2: behaviour ─────────────────────────────────────────────────────
+  console.log('');
+  console.log(chalk.bold.white('  Behaviour'));
+  const behaviour = await radioLine('', [
+    { label: 'Page',   value: 'page'   },
+    { label: 'Popup',  value: 'popup'  },
+    { label: 'Right',  value: 'right'  },
+    { label: 'Left',   value: 'left'   },
+    { label: 'Top',    value: 'top'    },
+    { label: 'Bottom', value: 'bottom' },
+  ]);
+
+  // ── Step 3: components table ──────────────────────────────────────────────
+  const defaultRoute = `/${toLower(module)}/${toLower(entity)}`;
+  const defaultComps = [
+    { comp: 'List', route: defaultRoute, menu: 'on',  render: 'row' },
+    { comp: 'Form', route: '',           menu: 'off', render: ''    },
+  ];
+
+  const compRows = await fieldsTable(
+    defaultComps,
+    COMP_COLS,
+    COMP_WIDTHS,
+    'Components  (+ add  - remove  ← → 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');
+
+  // ── Step 4: slaves ────────────────────────────────────────────────────────
+  let slaveConfigs = [];
+  if (slaves.length > 0) {
+    console.log('');
+    console.log(chalk.bold.white(`  Slaves detected (${slaves.length})`));
+
+    const SLAVE_COLS   = ['slave', 'behaviour', 'menu'];
+    const SLAVE_WIDTHS = { slave: 18, behaviour: 30, menu: 6 };
+    const slaveDefaults = slaves.map(s => ({
+      slave:     `${s.module}/${s.entity}`,
+      behaviour: 'popup',
+      menu:      'off',
+    }));
+
+    const slaveRows = await fieldsTable(slaveDefaults, SLAVE_COLS, SLAVE_WIDTHS,
+      'Slave components  (behaviour: popup/tab/page/part)');
+
+    slaveConfigs = slaveRows.map((r, i) => ({
+      ...slaves[i],
+      behaviour: r.behaviour || 'popup',
+      menu:      r.menu === 'on',
+    }));
+  }
+
+  await _writeView({ module, entity, behaviour, hasRow, hasCard, comps: compRows, slaves: slaveConfigs, dryRun, cwd });
+}
+
+async function _writeView({ module, entity, behaviour, hasRow, hasCard, comps, slaves, dryRun, cwd }) {
+  const Pascal   = toPascal(entity);
+  const viewDir  = module === 'shared'
+    ? path.join(cwd, 'src', 'frontend', 'views', 'shared', toLower(entity))
+    : path.join(cwd, 'src', 'frontend', 'views', 'modules', toLower(module), toLower(entity));
+
+  // List
+  const listFile = path.join(viewDir, `${Pascal}List.vue`);
+  if (await exists(listFile)) {
+    log.info(`${Pascal}List.vue exists — skipping (behaviour change only affects Index.vue)`);
+  } else {
+    await writeFile(listFile, listStub({ module, entity, hasRow, hasCard }), { dryRun });
+  }
+
+  // Form
+  const formFile = path.join(viewDir, `${Pascal}Form.vue`);
+  if (await exists(formFile)) {
+    log.info(`${Pascal}Form.vue exists — skipping`);
+  } else {
+    await writeFile(formFile, formStub({ module, entity }), { dryRun });
+  }
+
+  // ListRow / ListCard
+  if (hasRow)  await writeFile(path.join(viewDir, `${Pascal}ListRow.vue`),  listRowStub({ entity }),  { dryRun });
+  if (hasCard) await writeFile(path.join(viewDir, `${Pascal}ListCard.vue`), listCardStub({ entity }), { dryRun });
+
+  // Index (always regenerate — safe, only behaviour wrapper)
+  await writeFile(
+    path.join(viewDir, `${Pascal}Index.vue`),
+    indexStub({ module, entity, behaviour }),
+    { dryRun }
+  );
+
+  // Slave parts
+  for (const slave of slaves) {
+    const slaveFile = path.join(viewDir, `${Pascal}${toPascal(slave.entity)}.vue`);
+    await writeFile(slaveFile,
+      slavePartStub({ masterEntity: entity, slaveModule: slave.module, slaveEntity: slave.entity, behaviour: slave.behaviour }),
+      { dryRun }
+    );
+  }
+
+  // View-level menu skeleton (rh.employee.menu.json)
+  // loader.menu.js picks this up automatically — no router update needed
+  const viewMenuFile = path.join(cwd, 'src', 'frontend', 'menus',
+    module === 'shared' ? `shared.${toLower(entity)}.menu.json` : `${toLower(module)}.${toLower(entity)}.menu.json`
+  );
+  if (!(await exists(viewMenuFile))) {
+    const route = `/${toLower(module)}/${toLower(entity)}`;
+    const skeleton = {
+      route,
+      hMenu: {
+        style: 'classic',
+        items: [
+          { label: 'New',    action: 'emit:new',    icon: '+' },
+          { label: 'Export', action: 'emit:export', icon: '↓' },
+        ],
+      },
+    };
+    await writeFile(viewMenuFile, JSON.stringify(skeleton, null, 2), { dryRun });
+  }
+
+  // vMenu entry in module menu
+  const menuComp = comps.find(c => c.menu === 'on' || c.menu === true);
+  if (menuComp) {
+    const moduleMenuFile = module === 'shared'
+      ? path.join(cwd, 'src', 'frontend', 'menus', 'main.menu.json')
+      : path.join(cwd, 'src', 'frontend', 'menus', `${toLower(module)}.menu.json`);
+    if (!dryRun) {
+      await upsertMenuItem(moduleMenuFile, {
+        module, entity,
+        route: menuComp.route || `/${toLower(module)}/${toLower(entity)}`,
+        hMenu: false,
+        vMenu: true,
+      });
+    } else {
+      log.info(`[dry-run] would add vMenu entry to ${path.basename(moduleMenuFile)}`);
+    }
+  }
+
+  log.success(`View ${chalk.cyan(module + '/' + entity)} generated with behaviour: ${chalk.yellow(behaviour)}`);
+}

package/src/index.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+import minimist from 'minimist';
+import chalk from 'chalk';
+import { generateEntity }                                          from './generators/entity.js';
+import { generateView }                                            from './generators/view.js';
+import { generateModule }                                          from './generators/module.js';
+import { generateMenu }                                            from './generators/menu.js';
+import { generateConfig }                                          from './generators/config.js';
+import { generatePivot, generateLayout, listModules, listEntities } from './generators/misc.js';
+import { radioLine, showCursor }                                   from './tui/engine.js';
+
+const HELP = `
+${chalk.bold.cyan('eapp')} — Electron + Vue ERP project CLI
+
+Usage:
+  eapp                              interactive launcher
+  eapp <command> [path] [options]
+
+Commands:
+  entity   [module/entity.schema]    Generate backend entity + api
+  view     [module/entity]           Generate Vue views
+  module   [name]                    Add / manage domain modules
+  menu     [module[/entity]]         Manage navigation menus
+  config                             Edit db.config.json
+  pivot    <a> <b>                   Generate pivot/join entity
+  layout   [name]                    Generate layout component
+  modules                            List all modules
+  entities [module]                  List all entities
+
+Path format:
+  /employee           shared module, dbo schema
+  rh/employee         rh module, rh schema
+  rh/employee.dbo     rh module, dbo schema
+  employee            shorthand for shared/employee
+
+Options:
+  --default    Skip all prompts, use sensible defaults
+  --dry-run    Print files without writing
+  --help, -h   Show this help
+`;
+
+async function launchInteractive() {
+  console.log('');
+  console.log(chalk.bold.cyan('  eapp') + chalk.dim(' — what do you want to do?'));
+  console.log('');
+  const chosen = await radioLine('', [
+    { label: 'Entity',  value: 'entity'  },
+    { label: 'View',    value: 'view'    },
+    { label: 'Module',  value: 'module'  },
+    { label: 'Menu',    value: 'menu'    },
+    { label: 'Config',  value: 'config'  },
+    { label: 'Pivot',   value: 'pivot'   },
+    { label: 'Layout',  value: 'layout'  },
+    { label: 'List',    value: 'list'    },
+  ]);
+  console.log('');
+  if (chosen === 'list') {
+    await listModules();
+    console.log('');
+    await listEntities([]);
+    return;
+  }
+  await run(chosen, [], process.argv.slice(2));
+}
+
+async function run(command, args, rawArgs) {
+  switch (command) {
+    case 'entity':        await generateEntity(args, rawArgs);  break;
+    case 'view':          await generateView(args, rawArgs);    break;
+    case 'module':        await generateModule(args, rawArgs);  break;
+    case 'menu':          await generateMenu(args, rawArgs);    break;
+    case 'config':        await generateConfig(args, rawArgs);  break;
+    case 'pivot':         await generatePivot(args, rawArgs);   break;
+    case 'layout':        await generateLayout(args, rawArgs);  break;
+    case 'modules':       await listModules();                  break;
+    case 'entities':      await listEntities(args);             break;
+    case 'add:entity':    await generateEntity(args, rawArgs);  break;
+    case 'add:view':      await generateView(args, rawArgs);    break;
+    case 'add:module':    await generateModule(args, rawArgs);  break;
+    case 'add:menu':      await generateMenu(args, rawArgs);    break;
+    case 'add:pivot':     await generatePivot(args, rawArgs);   break;
+    case 'add:layout':    await generateLayout(args, rawArgs);  break;
+    case 'list:modules':  await listModules();                  break;
+    case 'list:entities': await listEntities(args);             break;
+    default:
+      console.error(chalk.red(`Unknown command: "${command}"`));
+      console.log(`Run eapp --help for available commands.`);
+      process.exit(1);
+  }
+}
+
+async function main() {
+  const argv    = minimist(process.argv.slice(2), { boolean: ['help','h','dry-run','default'], string: ['schema'] });
+  const [cmd, ...args] = argv._;
+  const rawArgs = process.argv.slice(2);
+
+  if (argv.help || argv.h) { console.log(HELP); process.exit(0); }
+
+  try {
+    if (!cmd) { await launchInteractive(); return; }
+    await run(cmd, args, rawArgs);
+  } catch (err) {
+    if (err.name === 'ExitPromptError') { showCursor(); console.log(chalk.yellow('\nCancelled.')); process.exit(0); }
+    console.error(chalk.red('✖'), err.message);
+    if (process.env.DEBUG) console.error(err.stack);
+    process.exit(1);
+  }
+}
+
+main();