thatcher 1.0.48 → 1.0.49

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thatcher",
-  "version": "1.0.48",
+  "version": "1.0.49",
   "description": "A config-driven application framework for building data-intensive web apps without code.",
   "main": "src/index.js",
   "type": "module",

package/src/index.js

@@ -63,6 +63,9 @@ export class Thatcher {
     // Load plugins
     await this.loadPlugins();
 
+    const { registerAutomationEngine } = await import(resolveModule('./lib/automation-engine.js'));
+    registerAutomationEngine();
+
     // Hot reload
     if (this.options.server.hotReload) {
       this.setupHotReload();

package/src/lib/automation-engine.js

@@ -0,0 +1,113 @@
+import { hookEngine } from './hook-engine.js';
+import { update as updateRecord, create as createRecord } from './busybase/store.js';
+import { getConfigEngineSync } from './config-generator-engine.js';
+import { createLogger } from './logger.js';
+
+const log = createLogger('[AutomationEngine]');
+
+const OPERATORS = {
+  eq: (a, b) => a === b,
+  neq: (a, b) => a !== b,
+  gt: (a, b) => Number(a) > Number(b),
+  gte: (a, b) => Number(a) >= Number(b),
+  lt: (a, b) => Number(a) < Number(b),
+  lte: (a, b) => Number(a) <= Number(b),
+  in: (a, b) => Array.isArray(b) && b.includes(a),
+  changed: (a, b, prev, field) => prev && prev[field] !== a,
+  present: (a) => a !== null && a !== undefined && a !== '',
+};
+
+function evalCondition(cond, data, prev) {
+  const { field, op = 'eq', value } = cond;
+  const actual = data[field];
+  const fn = OPERATORS[op];
+  if (!fn) { log.error(`unknown automation operator: ${op}`); return false; }
+  return fn(actual, value, prev, field);
+}
+
+function evalConditions(conditions, data, prev) {
+  if (!conditions || !conditions.length) return true;
+  return conditions.every(c => evalCondition(c, data, prev));
+}
+
+async function runAction(action, context) {
+  const { entity, id, data, user } = context;
+  switch (action.type) {
+    case 'set_field': {
+      const patch = { [action.field]: action.value };
+      await updateRecord(entity, id, patch, user);
+      return;
+    }
+    case 'create_entity': {
+      const payload = { ...(action.data || {}) };
+      for (const [k, v] of Object.entries(payload)) {
+        if (typeof v === 'string' && v.startsWith('$')) payload[k] = data[v.slice(1)];
+      }
+      await createRecord(action.entity, payload, user);
+      return;
+    }
+    case 'notify': {
+      await hookEngine.execute('automation:notify', { entity, id, data, user, message: action.message, target: action.target });
+      return;
+    }
+    default:
+      log.error(`unknown automation action type: ${action.type}`);
+  }
+}
+
+function normalizeContext(context) {
+  const data = context.data || context.record || {};
+  const prev = context.before || context.prev || null;
+  return { ...context, data, prev, entity: context.entity, id: context.id ?? data.id };
+}
+
+async function runRule(rule, rawContext) {
+  const context = normalizeContext(rawContext);
+  if (!evalConditions(rule.when, context.data, context.prev)) return;
+  for (const action of rule.then || []) {
+    try {
+      await runAction(action, context);
+    } catch (error) {
+      log.error(`automation rule "${rule.id || rule.name}" action failed:`, { message: error.message });
+    }
+  }
+}
+
+function getRules(entityName, trigger) {
+  let config;
+  try {
+    config = getConfigEngineSync().getConfig();
+  } catch {
+    return [];
+  }
+  const rules = config?.automation?.rules || [];
+  return rules.filter(r => (!r.entity || r.entity === entityName) && (!r.trigger || r.trigger === trigger));
+}
+
+let registered = false;
+
+export function registerAutomationEngine() {
+  if (registered) return;
+  registered = true;
+
+  const config = getConfigEngineSync().getConfig();
+  const entityNames = Object.keys(config?.entities || {});
+
+  for (const entityName of entityNames) {
+    for (const trigger of ['create', 'update', 'delete']) {
+      hookEngine.register(`${trigger}:${entityName}:after`, async (context) => {
+        for (const rule of getRules(entityName, trigger)) await runRule(rule, context);
+        return context;
+      });
+    }
+    hookEngine.register(`transition:${entityName}`, async (context) => {
+      for (const rule of getRules(entityName, 'transition')) await runRule(rule, context);
+      return context;
+    });
+  }
+}
+
+export function dispatchAutomation(trigger, entity, context) {
+  const rules = getRules(entity, trigger);
+  return Promise.all(rules.map(rule => runRule(rule, context)));
+}

package/src/lib/field-types.js

@@ -124,6 +124,51 @@ export const fieldRegistry = {
   }),
   image: createSimpleType('TEXT'),
   id: createSimpleType('TEXT PRIMARY KEY'),
+  people: createSimpleType('TEXT', {
+    coerce: (val) => (val === undefined || val === '' || val === null ? null : (typeof val === 'string' ? val : JSON.stringify(val))),
+    format: (val, field, spec, row) => {
+      const ids = Array.isArray(val) ? val : (val ? [val] : []);
+      if (!ids.length) return null;
+      return ids.map(id => row?.[`${id}_display`] || row?.assignee_names?.[id] || String(id));
+    },
+  }),
+  link: createSimpleType('TEXT', {
+    format: (val) => String(val ?? ''),
+    isValid: (val) => { if (!val) return true; try { new URL(String(val)); return true; } catch { return false; } },
+  }),
+  file: createSimpleType('TEXT', {
+    coerce: (val) => (val === undefined || val === '' || val === null ? null : (typeof val === 'string' ? val : JSON.stringify(val))),
+    format: (val) => {
+      if (!val) return null;
+      const obj = typeof val === 'string' ? (() => { try { return JSON.parse(val); } catch { return { name: val }; } })() : val;
+      return { name: obj.name || obj.filename || 'file', url: obj.url || null };
+    },
+  }),
+  rating: createNumberType('INTEGER', (val) => {
+    if (val === undefined || val === '' || val === null) return null;
+    const num = parseInt(val, 10);
+    if (isNaN(num)) throw new Error(`Invalid rating: ${val}`);
+    return num;
+  }, (val, field) => ({ value: Number(val) || 0, max: field?.max || 5 })),
+  progress: createNumberType('REAL', (val) => {
+    if (val === undefined || val === '' || val === null) return null;
+    const num = parseFloat(val);
+    if (isNaN(num)) throw new Error(`Invalid progress: ${val}`);
+    return num;
+  }, (val) => Math.max(0, Math.min(100, Number(val) || 0))),
+  checkbox: createSimpleType('INTEGER', {
+    coerce: (val) => (val === true || val === 'true' || val === 'on' || val === 1 ? 1 : 0),
+    format: (val) => !!val,
+  }),
+  formula: {
+    sqlType: 'TEXT',
+    coerce: () => undefined,
+    format: (val, field, spec, row) => {
+      if (typeof field?.compute !== 'function') return null;
+      try { return field.compute(row); } catch { return null; }
+    },
+    isValid: () => true,
+  },
 };
 
 export function getFieldHandler(type) {

package/src/ui/board-view-renderer.js

@@ -0,0 +1,76 @@
+import { page } from '@/ui/layout.js';
+import { esc, statusPill, TABLE_SCRIPT } from '@/ui/render-helpers.js';
+import { getStateField, getStageLabels } from '@/lib/workflow-engine.js';
+
+function cardTitleField(spec) {
+  if (spec.list?.titleField) return spec.list.titleField;
+  const candidates = ['name', 'title', 'label'];
+  for (const c of candidates) if (spec.fields?.[c]) return c;
+  const first = Object.keys(spec.fields || {}).find(k => spec.fields[k]?.type === 'text');
+  return first || 'id';
+}
+
+function boardCard(entityName, record, titleField) {
+  const title = esc(record[titleField] ?? record.id);
+  const status = record.status !== undefined ? statusPill(record.status) : '';
+  return `<div class="board-card" draggable="true" data-id="${esc(record.id)}" data-navigate="/${esc(entityName)}/${esc(record.id)}">
+    <div class="board-card-title">${title}</div>
+    ${status ? `<div class="board-card-meta">${status}</div>` : ''}
+  </div>`;
+}
+
+function boardColumn(entityName, stageKey, stageLabel, records, titleField) {
+  const cards = records.map(r => boardCard(entityName, r, titleField)).join('') ||
+    `<div class="board-column-empty">No items</div>`;
+  return `<div class="board-column" data-stage="${esc(stageKey)}">
+    <div class="board-column-header"><span>${esc(stageLabel)}</span><span class="board-column-count">${records.length}</span></div>
+    <div class="board-column-body" data-drop-zone="${esc(stageKey)}">${cards}</div>
+  </div>`;
+}
+
+const BOARD_SCRIPT = `(function(){
+  document.addEventListener('dragstart',e=>{const c=e.target.closest('.board-card');if(!c)return;e.dataTransfer.setData('text/plain',c.dataset.id);c.classList.add('dragging')});
+  document.addEventListener('dragend',e=>{const c=e.target.closest('.board-card');if(c)c.classList.remove('dragging')});
+  document.addEventListener('dragover',e=>{const z=e.target.closest('[data-drop-zone]');if(z)e.preventDefault()});
+  document.addEventListener('drop',async e=>{
+    const zone=e.target.closest('[data-drop-zone]');if(!zone)return;e.preventDefault();
+    const id=e.dataTransfer.getData('text/plain');if(!id)return;
+    const toStage=zone.dataset.dropZone;
+    const board=document.getElementById('board-root');
+    const entity=board.dataset.entity, workflow=board.dataset.workflow;
+    try{
+      const r=await fetch('/api/'+entity+'/'+id+'/transition',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({workflow,toState:toStage})});
+      if(r.ok)location.reload();else{const d=await r.json().catch(()=>({}));showToast(d.error||'Transition failed','error')}
+    }catch(err){showToast(err.message,'error')}
+  });
+})();`;
+
+export function renderBoardView(user, entityName, spec, records, options = {}) {
+  const workflowName = options.workflow || spec.workflow;
+  if (!workflowName) {
+    return page(user, `${spec.labelPlural || spec.label} | Board`, null,
+      `<div class="board-empty-state">This entity has no workflow configured; board view requires a <code>workflow</code> key on the entity spec.</div>`);
+  }
+  const stateField = getStateField(workflowName);
+  const stageLabels = getStageLabels(workflowName);
+  const titleField = cardTitleField(spec);
+
+  const grouped = {};
+  for (const key of Object.keys(stageLabels)) grouped[key] = [];
+  for (const r of records) {
+    const stage = r[stateField];
+    if (!grouped[stage]) grouped[stage] = [];
+    grouped[stage].push(r);
+  }
+
+  const columns = Object.entries(stageLabels)
+    .map(([key, label]) => boardColumn(entityName, key, label, grouped[key] || [], titleField))
+    .join('');
+
+  const content = `<div class="page-header">
+      <div><h1 class="page-title">${esc(spec.labelPlural || spec.label)}</h1><p class="page-subtitle">${records.length} items</p></div>
+    </div>
+    <div id="board-root" class="board-view" data-entity="${esc(entityName)}" data-workflow="${esc(workflowName)}">${columns}</div>`;
+
+  return page(user, `${spec.labelPlural || spec.label} | Board`, null, content, [TABLE_SCRIPT, BOARD_SCRIPT]);
+}

package/src/ui/calendar-view-renderer.js

@@ -0,0 +1,196 @@
+import { page } from '@/ui/layout.js';
+import { esc } from '@/ui/render-helpers.js';
+import { getEntityLabel } from '@/config/spec-helpers.js';
+
+const MONTH_NAMES = ['January','February','March','April','May','June','July','August','September','October','November','December'];
+const DAY_NAMES = ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'];
+
+function calendarDateField(spec) {
+  if (spec.list?.dateField) return spec.list.dateField;
+  const entries = Object.entries(spec.fields || {});
+  const found = entries.find(([, f]) => f.type === 'date' || f.type === 'timestamp');
+  return found ? found[0] : null;
+}
+
+function toDateOrNull(value) {
+  if (value === null || value === undefined || value === '') return null;
+  const num = Number(value);
+  if (!isNaN(num) && num > 0) return new Date(num * 1000);
+  const d = new Date(value);
+  return isNaN(d) ? null : d;
+}
+
+function dayKey(d) {
+  return `${d.getFullYear()}-${d.getMonth()}-${d.getDate()}`;
+}
+
+function calendarChip(entityName, record, titleField) {
+  const title = esc(record[titleField] ?? record.id);
+  return `<div class="calendar-chip" data-navigate="/${esc(entityName)}/${esc(record.id)}">${title}</div>`;
+}
+
+function calendarTitleField(spec) {
+  if (spec.list?.titleField) return spec.list.titleField;
+  const candidates = ['name', 'title', 'label'];
+  for (const c of candidates) if (spec.fields?.[c]) return c;
+  const first = Object.keys(spec.fields || {}).find(k => spec.fields[k]?.type === 'text');
+  return first || 'id';
+}
+
+export function renderCalendarView(user, entityName, spec, records, options = {}) {
+  const label = getEntityLabel(spec, true) || entityName;
+  const dateField = calendarDateField(spec);
+  const titleField = calendarTitleField(spec);
+
+  const now = new Date();
+  const year = Number(options.year) || now.getFullYear();
+  const month = options.month !== undefined ? Number(options.month) : now.getMonth();
+
+  const byDay = {};
+  const undated = [];
+
+  for (const r of records) {
+    const d = dateField ? toDateOrNull(r[dateField]) : null;
+    if (!d) { undated.push(r); continue; }
+    const key = dayKey(d);
+    if (!byDay[key]) byDay[key] = [];
+    byDay[key].push(r);
+  }
+
+  const firstOfMonth = new Date(year, month, 1);
+  const startWeekday = firstOfMonth.getDay();
+  const daysInMonth = new Date(year, month + 1, 0).getDate();
+
+  const cells = [];
+  for (let i = 0; i < startWeekday; i++) cells.push('<div class="calendar-cell calendar-cell-empty"></div>');
+  for (let day = 1; day <= daysInMonth; day++) {
+    const key = `${year}-${month}-${day}`;
+    const dayRecords = byDay[key] || [];
+    const chips = dayRecords.map(r => calendarChip(entityName, r, titleField)).join('');
+    const isToday = year === now.getFullYear() && month === now.getMonth() && day === now.getDate();
+    cells.push(`<div class="calendar-cell${isToday ? ' calendar-cell-today' : ''}">
+      <div class="calendar-cell-date">${day}</div>
+      <div class="calendar-cell-chips">${chips}</div>
+    </div>`);
+  }
+
+  const totalCells = startWeekday + daysInMonth;
+  const trailing = (7 - (totalCells % 7)) % 7;
+  for (let i = 0; i < trailing; i++) cells.push('<div class="calendar-cell calendar-cell-empty"></div>');
+
+  const dayHeaders = DAY_NAMES.map(d => `<div class="calendar-day-header">${d}</div>`).join('');
+
+  let prevMonth = month - 1, prevYear = year;
+  if (prevMonth < 0) { prevMonth = 11; prevYear -= 1; }
+  let nextMonth = month + 1, nextYear = year;
+  if (nextMonth > 11) { nextMonth = 0; nextYear += 1; }
+
+  const undatedSection = undated.length
+    ? `<div class="calendar-undated">
+        <h3>Undated (${undated.length})</h3>
+        <div class="calendar-undated-list">${undated.map(r => calendarChip(entityName, r, titleField)).join('')}</div>
+      </div>`
+    : '';
+
+  const noDateFieldNotice = !dateField
+    ? `<div class="calendar-empty-state">This entity has no date field configured; all records are shown as undated.</div>`
+    : '';
+
+  const content = `<div class="page-header">
+      <div><h1 class="page-title">${esc(label)}</h1><p class="page-subtitle">${records.length} items</p></div>
+    </div>
+    ${noDateFieldNotice}
+    <div class="calendar-toolbar">
+      <a class="calendar-nav-link" href="?month=${prevMonth}&year=${prevYear}">&laquo; Prev</a>
+      <span class="calendar-month-label">${MONTH_NAMES[month]} ${year}</span>
+      <a class="calendar-nav-link" href="?month=${nextMonth}&year=${nextYear}">Next &raquo;</a>
+    </div>
+    <div class="calendar-grid">
+      ${dayHeaders}
+      ${cells.join('')}
+    </div>
+    ${undatedSection}`;
+
+  return page(user, `${label} | Calendar`, null, content);
+}
+
+function timelineFields(spec) {
+  if (spec.list?.timelineStart && spec.list?.timelineEnd) {
+    return [spec.list.timelineStart, spec.list.timelineEnd];
+  }
+  const fields = spec.fields || {};
+  const startCandidates = ['start_date', 'start'];
+  const endCandidates = ['end_date', 'due_date', 'end', 'deadline'];
+  const start = startCandidates.find(k => fields[k]) || null;
+  const end = endCandidates.find(k => fields[k]) || null;
+  return [start, end];
+}
+
+function timelineTitleField(spec) {
+  if (spec.list?.titleField) return spec.list.titleField;
+  const candidates = ['name', 'title', 'label'];
+  for (const c of candidates) if (spec.fields?.[c]) return c;
+  const first = Object.keys(spec.fields || {}).find(k => spec.fields[k]?.type === 'text');
+  return first || 'id';
+}
+
+export function renderTimelineView(user, entityName, spec, records, options = {}) {
+  const label = getEntityLabel(spec, true) || entityName;
+  const [startField, endField] = timelineFields(spec);
+  const titleField = timelineTitleField(spec);
+
+  const plotted = [];
+  let missing = 0;
+
+  for (const r of records) {
+    const start = startField ? toDateOrNull(r[startField]) : null;
+    const end = endField ? toDateOrNull(r[endField]) : null;
+    if (!start || !end) { missing++; continue; }
+    plotted.push({ record: r, start, end });
+  }
+
+  if (!startField || !endField) {
+    return page(user, `${label} | Timeline`, null,
+      `<div class="page-header">
+        <div><h1 class="page-title">${esc(label)}</h1><p class="page-subtitle">${records.length} items</p></div>
+      </div>
+      <div class="timeline-empty-state">This entity has no start/end date fields configured; timeline view requires <code>list.timelineStart</code>/<code>list.timelineEnd</code> or matching field names.</div>`);
+  }
+
+  const missingNotice = missing
+    ? `<div class="timeline-missing-notice">${missing} item${missing === 1 ? '' : 's'} without dates not shown</div>`
+    : '';
+
+  if (!plotted.length) {
+    const content = `<div class="page-header">
+        <div><h1 class="page-title">${esc(label)}</h1><p class="page-subtitle">${records.length} items</p></div>
+      </div>
+      ${missingNotice}
+      <div class="timeline-empty-state">No items have both a start and end date.</div>`;
+    return page(user, `${label} | Timeline`, null, content);
+  }
+
+  const minTime = Math.min(...plotted.map(p => p.start.getTime()));
+  const maxTime = Math.max(...plotted.map(p => p.end.getTime()));
+  const span = Math.max(1, maxTime - minTime);
+
+  const rows = plotted.map(({ record, start, end }) => {
+    const title = esc(record[titleField] ?? record.id);
+    const offsetPct = ((start.getTime() - minTime) / span) * 100;
+    const widthPct = Math.max(1, ((end.getTime() - start.getTime()) / span) * 100);
+    return `<div class="timeline-row">
+      <div class="timeline-row-label">${title}</div>
+      <div class="timeline-row-track">
+        <div class="timeline-bar" data-navigate="/${esc(entityName)}/${esc(record.id)}" style="margin-left:${offsetPct}%;width:${widthPct}%"></div>
+      </div>
+    </div>`;
+  }).join('');
+
+  const content = `<div class="page-header">
+      <div><h1 class="page-title">${esc(label)}</h1><p class="page-subtitle">${records.length} items</p></div>
+    </div>
+    ${missingNotice}
+    <div class="timeline-view">${rows}</div>`;
+
+  return page(user, `${label} | Timeline`, null, content);
+}

package/src/ui/grid-view-renderer.js

@@ -0,0 +1,78 @@
+import { page } from '@/ui/layout.js';
+import { esc, fmtVal, TABLE_SCRIPT, emptyRow } from '@/ui/render-helpers.js';
+import { getDefaultSort, getAvailableFilters, getPageSize, getEntityLabel } from '@/config/spec-helpers.js';
+
+const EMBEDDED_TYPES = new Set(['json', 'embedded']);
+
+function getColumns(spec) {
+  const fields = spec?.fields || {};
+  const override = spec?.list?.columns;
+  if (Array.isArray(override) && override.length) {
+    return override
+      .filter(key => fields[key])
+      .map(key => [key, fields[key]]);
+  }
+  return Object.entries(fields).filter(([, f]) =>
+    !f.hidden && !EMBEDDED_TYPES.has(f.type)
+  );
+}
+
+function isEditable(field) {
+  return field && field.readonly !== true;
+}
+
+function gridRow(entityName, item, columns) {
+  const cells = columns.map(([key, field]) => {
+    const value = item[key];
+    const rendered = fmtVal(value, key, item);
+    const editableAttr = isEditable(field) ? ` data-editable="${esc(key)}"` : '';
+    return `<td data-col="${esc(key)}"${editableAttr}>${rendered}</td>`;
+  }).join('');
+  return `<tr data-row data-navigate="/${esc(entityName)}/${esc(item.id)}" style="cursor:pointer">${cells}</tr>`;
+}
+
+export function renderGridView(user, entityName, spec, records, options = {}) {
+  const label = getEntityLabel(spec, true) || entityName;
+  const columns = getColumns(spec);
+  const defaultSort = getDefaultSort(spec);
+  const filters = getAvailableFilters(spec);
+  const pageSize = getPageSize(spec);
+
+  const headerCells = columns.map(([key, field]) => {
+    const colLabel = esc(field?.label || key);
+    const isDefaultSort = key === defaultSort.field;
+    return `<th data-sort="${esc(key)}" aria-label="Sort by ${colLabel}"${isDefaultSort ? ` class="sort-${esc(defaultSort.dir)}"` : ''}>${colLabel}</th>`;
+  }).join('');
+
+  const filterControls = filters.map(f => {
+    const fieldKey = typeof f === 'string' ? f : f.field;
+    const fieldSpec = spec.fields?.[fieldKey];
+    const filterLabel = esc(fieldSpec?.label || fieldKey);
+    const opts = (fieldSpec?.options || f.options || []).map(o => {
+      const value = typeof o === 'string' ? o : o.value;
+      const optLabel = typeof o === 'string' ? o : (o.label || o.value);
+      return `<option value="${esc(value)}">${esc(optLabel)}</option>`;
+    }).join('');
+    return `<div class="table-filter"><select data-filter="${esc(fieldKey)}" id="filter-${esc(fieldKey)}" aria-label="Filter by ${filterLabel}"><option value="">All ${filterLabel}</option>${opts}</select></div>`;
+  }).join('');
+
+  const rows = records.map(item => gridRow(entityName, item, columns)).join('') ||
+    emptyRow(columns.length || 1, `No ${esc(label.toLowerCase())} found`);
+
+  const content = `<div class="page-header">
+        <div><h1 class="page-title">${esc(label)}</h1><p class="page-subtitle">${records.length} total ${esc(label.toLowerCase())}</p></div>
+      </div>
+      <div class="table-wrap">
+        <div class="table-toolbar">
+          <div class="table-search"><input id="search-input" type="text" placeholder="Search ${esc(label.toLowerCase())}..."></div>
+          ${filterControls}
+          <span class="table-count" id="row-count">${records.length} items</span>
+        </div>
+        <table class="data-table" role="grid" data-page-size="${esc(pageSize)}">
+          <thead><tr>${headerCells}</tr></thead>
+          <tbody>${rows}</tbody>
+        </table>
+      </div>`;
+
+  return page(user, `${label} | Thatcher`, null, content, [TABLE_SCRIPT]);
+}