thatcher 1.0.74 → 1.0.76

package/package.json

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

package/src/lib/bulk-operations.js

@@ -56,6 +56,33 @@ async function bulkTransitionOne(entityName, id, workflowName, toState, user) {
   return transition(entityName, id, workflowName, toState, user, 'bulk operation');
 }
 
+async function bulkNotifyOne(entityName, spec, id, user, message) {
+  // Same permission/row-access gate every other bulk action already applies
+  // -- 'notify' reads the record to build the notification, so it must not
+  // bypass the checks a plain view of that record would require.
+  await requirePermission(user, spec, 'view');
+  const existing = await get(entityName, id, { user });
+  if (!existing) throw new Error('Not found');
+  if (!permissionService.checkRowAccess(user, spec, existing)) throw new Error('Access denied');
+
+  const recipientId = existing.owner_id;
+  if (!recipientId) throw new Error('Record has no owner_id to notify');
+
+  const { createNotification } = await import('../services/notification-engine.js');
+  // createNotification stores user_id as the sole addressee -- the existing
+  // /notifications route already filters list('notification',{user_id:...})
+  // scoped by {user}, so a notification is only ever visible to the user it
+  // names, the same row-access guarantee every other entity gets.
+  return createNotification({
+    user_id: recipientId,
+    title: message || `${spec.label || entityName} update`,
+    message: message || `${spec.label || entityName} "${existing.name || id}" requires attention`,
+    entity_type: entityName,
+    entity_id: id,
+    created_by: user?.id || 'system',
+  });
+}
+
 export async function runBulkOperation(entityName, spec, ids, action, user) {
   if (!Array.isArray(ids) || !ids.length) return { ok: false, error: 'ids array required and must be non-empty' };
   if (ids.length > MAX_BULK_IDS) return { ok: false, error: `Cannot process more than ${MAX_BULK_IDS} ids in one bulk operation` };
@@ -77,6 +104,9 @@ export async function runBulkOperation(entityName, spec, ids, action, user) {
         if (!action.workflow || !action.toState) throw new Error('action.workflow and action.toState required');
         await bulkTransitionOne(entityName, id, action.workflow, action.toState, user);
         results.push({ id, success: true });
+      } else if (action.type === 'notify') {
+        await bulkNotifyOne(entityName, spec, id, user, action.message);
+        results.push({ id, success: true });
       } else {
         results.push({ id, success: false, error: `Unknown action type "${action.type}"` });
       }

package/src/lib/config-generator-engine.js

@@ -253,10 +253,49 @@ function withTimeTrackingDefaults(masterConfig) {
   return changed ? { ...masterConfig, entities } : masterConfig;
 }
 
+const CONTRACT_LIFECYCLE_WORKFLOW = {
+  state_field: 'status',
+  stages: [
+    { name: 'draft', label: 'Draft', forward: ['active'], backward: [] },
+    { name: 'active', label: 'Active', forward: ['expired', 'renewed', 'terminated'], backward: [] },
+    { name: 'expired', label: 'Expired', forward: ['renewed'], backward: [] },
+    { name: 'terminated', label: 'Terminated', forward: [], backward: [] },
+    { name: 'renewed', label: 'Renewed', forward: [], backward: [] },
+  ],
+};
+
+const CONTRACT_ENTITY_DEFAULT = {
+  label: 'Contract',
+  label_plural: 'Contracts',
+  system_entity: true,
+  workflow: 'contract_lifecycle',
+  fields: {
+    name: { type: 'text', required: true, label: 'Name' },
+    organization_id: { type: 'ref', ref: 'organization', label: 'Organization' },
+    opportunity_id: { type: 'ref', ref: 'opportunity', label: 'Opportunity' },
+    value: { type: 'currency', label: 'Value' },
+    start_date: { type: 'date', required: true, label: 'Start Date' },
+    end_date: { type: 'date', required: true, label: 'End Date' },
+    status: { type: 'enum', options: ['draft', 'active', 'expired', 'terminated', 'renewed'], default: 'draft', label: 'Status' },
+    auto_renew: { type: 'bool', default: false, label: 'Auto Renew' },
+    notice_period_days: { type: 'number', min: 0, default: 30, label: 'Notice Period (days)' },
+    owner_id: { type: 'ref', ref: 'user', label: 'Owner' },
+  },
+};
+
+function withContractDefaults(masterConfig) {
+  const entities = { ...(masterConfig.entities || {}) };
+  const workflows = { ...(masterConfig.workflows || {}) };
+  let changed = false;
+  if (!entities.contract) { entities.contract = CONTRACT_ENTITY_DEFAULT; changed = true; }
+  if (!workflows.contract_lifecycle) { workflows.contract_lifecycle = CONTRACT_LIFECYCLE_WORKFLOW; changed = true; }
+  return changed ? { ...masterConfig, entities, workflows } : masterConfig;
+}
+
 export class ConfigGeneratorEngine {
   constructor(masterConfig) {
     if (!masterConfig) throw new Error('[ConfigGeneratorEngine] masterConfig is required');
-    this.masterConfig = deepFreeze(withTimeTrackingDefaults(withInventoryDefaults(withProjectDefaults(withCrmDefaults(withWebhookDefaults(withMultiTenancyDefaults(masterConfig)))))));
+    this.masterConfig = deepFreeze(withContractDefaults(withTimeTrackingDefaults(withInventoryDefaults(withProjectDefaults(withCrmDefaults(withWebhookDefaults(withMultiTenancyDefaults(masterConfig))))))));
     this.specCache = new LRUCache(100);
     this.debugMode = false;
     this._plugins = new Map();

package/src/lib/contract-expiry.js

@@ -0,0 +1,13 @@
+// Single source of truth for contract expiry math, shared between
+// page-handler.js's detail-view computation and scheduler-engine.js's
+// expiry-notification pre-filter -- kept in one place so the two never drift
+// against each other the way a duplicated formula could.
+export function daysUntilExpiry(endDate, nowSeconds = Math.floor(Date.now() / 1000)) {
+  return Math.floor((Number(endDate) - nowSeconds) / 86400);
+}
+
+export function isWithinNoticeWindow(contract, nowSeconds = Math.floor(Date.now() / 1000)) {
+  if (contract.status !== 'active' || contract.end_date == null) return false;
+  const days = daysUntilExpiry(contract.end_date, nowSeconds);
+  return days <= (contract.notice_period_days ?? 30);
+}

package/src/lib/scheduler-engine.js

@@ -35,7 +35,18 @@ async function runOneJob(job, nowTs) {
     // scoping crud-handlers.js's read path enforces for an interactive
     // request, so a job cannot reach records outside its owner's org just
     // because it runs unattended.
-    const targets = await list(job.entity, filter, { user: owner });
+    let targets = await list(job.entity, filter, { user: owner });
+
+    // job.filter can only express stored-field equality (e.g. status:active);
+    // "expiring within notice_period_days" is a per-record computed
+    // comparison, not a filterable field, so it's checked here in JS against
+    // the SAME shared math the contract detail view uses -- never a second,
+    // divergent formula.
+    if (job.entity === 'contract' && action?.type === 'notify') {
+      const { isWithinNoticeWindow } = await import('./contract-expiry.js');
+      targets = targets.filter(c => isWithinNoticeWindow(c, nowTs));
+    }
+
     const ids = targets.map(r => r.id);
 
     let result = { ok: true, total: 0, succeeded: 0, failed: 0, results: [] };

package/src/lib/validation/entity-validators.js

@@ -190,6 +190,21 @@ async function checkStockBalance(entityName, data) {
   return null;
 }
 
+// A contract whose end_date is not strictly after its start_date is invalid
+// regardless of what the form happened to allow -- checked wherever either
+// date is present in the payload so it also catches a create that only sets
+// one of the two dates against an existing record's other date on update.
+function checkContractDateOrder(entityName, data, existingRecord) {
+  if (entityName !== 'contract') return null;
+  const startDate = data.start_date !== undefined ? data.start_date : existingRecord?.start_date;
+  const endDate = data.end_date !== undefined ? data.end_date : existingRecord?.end_date;
+  if (startDate == null || endDate == null) return null;
+  if (Number(endDate) <= Number(startDate)) {
+    return `end_date must be after start_date`;
+  }
+  return null;
+}
+
 export async function validateEntity(entityName, data, existingRecord = null, options = {}) {
   const spec = getSpec(entityName);
   const errors = {};
@@ -220,6 +235,9 @@ export async function validateEntity(entityName, data, existingRecord = null, op
   const ownershipErr = checkTimeEntryOwnership(entityName, data, options);
   if (ownershipErr) errors.user_id = ownershipErr;
 
+  const dateOrderErr = checkContractDateOrder(entityName, data, existingRecord);
+  if (dateOrderErr) errors.end_date = dateOrderErr;
+
   return errors;
 }
 
@@ -295,6 +313,9 @@ export async function validateUpdate(entityName, changes, existingRecord) {
   const depErr = await checkTaskDependencies(entityName, changes, existingRecord);
   if (depErr) errors.status = depErr;
 
+  const dateOrderErr = checkContractDateOrder(entityName, changes, existingRecord);
+  if (dateOrderErr) errors.end_date = dateOrderErr;
+
   return errors;
 }
 

package/src/ui/entity-renderer.js

@@ -146,9 +146,23 @@ export function renderEntityDetail(entityName, item, spec, user, history = []) {
        <div class="detail-row"><span class="detail-row-label">Billable Amount</span><span class="detail-row-value">${esc('$' + (item.billable_amount / 100).toFixed(2))}</span></div>`
     : ''
 
+  // days_until_expiry is computed (page-handler.js diffs end_date against
+  // now), never a spec.fields entry, same treatment as current_stock above.
+  const expiryRow = entityName === 'contract' && typeof item.days_until_expiry === 'number'
+    ? (() => {
+        const warn = item.status === 'active' && item.days_until_expiry <= (item.notice_period_days ?? 30)
+        const pillCls = item.days_until_expiry < 0 ? 'pill-danger' : (warn ? 'pill-warning' : 'pill-success')
+        const label = item.days_until_expiry < 0 ? `Expired ${Math.abs(item.days_until_expiry)} days ago` : `${item.days_until_expiry} days`
+        return `<div class="detail-row">
+          <span class="detail-row-label">Days Until Expiry</span>
+          <span class="detail-row-value"><span class="pill ${pillCls}">${esc(label)}${warn ? ' (Renewal Notice)' : ''}</span></span>
+        </div>`
+      })()
+    : ''
+
   const visibleFields = Object.entries(fields).filter(([k]) => k !== 'id' && !HIDDEN_FIELDS.has(k) && item[k] !== undefined)
 
-  const fieldRows = stockRow + timeTrackingRows + visibleFields.map(([k, f]) =>
+  const fieldRows = stockRow + timeTrackingRows + expiryRow + visibleFields.map(([k, f]) =>
     `<div class="detail-row">
       <span class="detail-row-label">${esc(f.label || k)}</span>
       <span class="detail-row-value">${formatFieldValue(k, item[k], entityName, f)}</span>

package/src/ui/page-handler.js

@@ -149,6 +149,15 @@ async function handleGenericEntityView(user, entityName, id, req) {
       resolvedItem = { ...resolvedItem, total_hours: totalHours, billable_amount: billableAmount };
     } catch { resolvedItem = { ...resolvedItem, total_hours: 0, billable_amount: 0 }; }
   }
+  if (entityName === 'contract' && resolvedItem.end_date != null) {
+    // days_until_expiry is computed from the already-access-checked record
+    // (get(...,{user}) above already returned null for a denied/absent
+    // contract before this line is ever reached), never a separate query
+    // that could leak the value to a caller who never proved they can view
+    // this specific contract.
+    const { daysUntilExpiry } = await import('@/lib/contract-expiry.js');
+    resolvedItem = { ...resolvedItem, days_until_expiry: daysUntilExpiry(resolvedItem.end_date) };
+  }
   // get(...,{user}) above already enforced row/org access for this exact
   // record (a denied/absent record returns null before this point), so
   // fetching its audit trail here is scoped by construction -- there is no