thatcher 1.0.84 → 1.0.86

package/package.json

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

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

@@ -209,6 +209,7 @@ const PRODUCT_ENTITY_DEFAULT = {
     description: { type: 'textarea', label: 'Description' },
     unit_price: { type: 'currency', label: 'Unit Price' },
     reorder_threshold: { type: 'number', min: 0, label: 'Reorder Threshold' },
+    lead_time_days: { type: 'number', min: 0, default: 14, label: 'Lead Time (days)' },
   },
 };
 

package/src/lib/demand-forecast.js

@@ -0,0 +1,58 @@
+// Single source of truth for CRM demand-planning math, shared with any
+// future forecast summary view -- the same small pure-computation module
+// shape as contract-expiry.js and inventory-forecast.js. Forward-looking
+// (open pipeline -> future revenue), the mirror image of
+// inventory-forecast.js's backward-looking (movement history -> stockout).
+const OPEN_STAGE_EXCLUSIONS = new Set(['won', 'lost']);
+
+function monthBucketKey(dateSeconds) {
+  const d = new Date(dateSeconds * 1000);
+  return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, '0')}`;
+}
+
+// The stage field alone decides "still open" -- not the presence of a
+// weighted_value or any date math, so a caller can't accidentally count a
+// won/lost opportunity by omission.
+function isOpenStage(opportunity) {
+  return !OPEN_STAGE_EXCLUSIONS.has(opportunity.stage);
+}
+
+// A record already carries weighted_value if it passed through
+// busybase/store.js's list()/get() (which now computes formula fields on
+// every read) -- reused directly rather than recomputed, so this module
+// never drifts from the same formula the opportunity entity itself defines.
+// Falls back to computing value*probability/100 independently only if the
+// field is genuinely absent (e.g. a deployment whose opportunity entity
+// doesn't define weighted_value), never silently treating a present-but-null
+// value as "compute it myself" -- null still means the formula ran and
+// legitimately produced nothing.
+function weightedValueOf(opportunity) {
+  if (opportunity.weighted_value !== undefined) return opportunity.weighted_value ?? 0;
+  const value = Number(opportunity.value) || 0;
+  const probability = Number(opportunity.probability) || 0;
+  return (value * probability) / 100;
+}
+
+export function projectDemandByMonth(opportunities, nowSeconds = Math.floor(Date.now() / 1000)) {
+  const currentBucketKey = monthBucketKey(nowSeconds);
+  const buckets = new Map();
+
+  for (const opp of opportunities) {
+    if (!isOpenStage(opp)) continue;
+    if (opp.expected_close_date == null) continue;
+
+    const bucketKey = monthBucketKey(Number(opp.expected_close_date));
+    // A future bucket sorts >= the current month's key lexicographically
+    // (YYYY-MM strings compare correctly as dates); a past-due open
+    // opportunity's bucket key is strictly less than the current one and is
+    // excluded entirely rather than folded into the nearest future bucket --
+    // silently reassigning it would misrepresent when the demand was
+    // actually expected.
+    if (bucketKey < currentBucketKey) continue;
+
+    const weighted = weightedValueOf(opp);
+    buckets.set(bucketKey, (buckets.get(bucketKey) || 0) + weighted);
+  }
+
+  return [...buckets.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+}

package/src/lib/inventory-forecast.js

@@ -0,0 +1,53 @@
+// Single source of truth for inventory demand-forecast math, shared between
+// page-handler.js's product detail-view computation and any future forecast
+// summary view -- kept in one place so they never drift, the same pattern
+// contract-expiry.js already established for expiry math.
+const DEFAULT_WINDOW_DAYS = 90;
+const DEFAULT_LEAD_TIME_DAYS = 14;
+const DAY_SECONDS = 86400;
+
+// Average daily consumption over a trailing window: sum of every OUTBOUND
+// (negative quantity) movement within the window, divided by the window's
+// day-count -- not the number of movements, so sparse activity (e.g. one
+// large monthly shipment) still averages correctly over the full period
+// rather than only the days something happened.
+export function averageDailyConsumption(movements, windowDays = DEFAULT_WINDOW_DAYS, nowSeconds = Math.floor(Date.now() / 1000)) {
+  const windowStart = nowSeconds - windowDays * DAY_SECONDS;
+  const outboundTotal = movements
+    .filter(m => Number(m.created_at) >= windowStart && Number(m.quantity) < 0)
+    .reduce((sum, m) => sum + Math.abs(Number(m.quantity) || 0), 0);
+  return outboundTotal / windowDays;
+}
+
+// null (not Infinity, not a crash) when there is no consumption to project
+// against -- a caller rendering this must be able to tell "we don't know"
+// apart from "never" without special-casing an infinite number.
+export function daysUntilStockout(currentStock, avgDailyConsumption) {
+  if (!Number.isFinite(avgDailyConsumption) || avgDailyConsumption <= 0) return null;
+  if (currentStock <= 0) return 0;
+  return currentStock / avgDailyConsumption;
+}
+
+export function suggestedReorderDate(daysUntilStockoutValue, leadTimeDays = DEFAULT_LEAD_TIME_DAYS, nowSeconds = Math.floor(Date.now() / 1000)) {
+  if (daysUntilStockoutValue == null) return null;
+  const daysUntilReorder = daysUntilStockoutValue - leadTimeDays;
+  return nowSeconds + daysUntilReorder * DAY_SECONDS;
+}
+
+export function isReorderDue(reorderDateSeconds, nowSeconds = Math.floor(Date.now() / 1000)) {
+  if (reorderDateSeconds == null) return false;
+  return reorderDateSeconds <= nowSeconds;
+}
+
+export function computeInventoryForecast(product, movements, currentStock, options = {}) {
+  const nowSeconds = options.nowSeconds ?? Math.floor(Date.now() / 1000);
+  const windowDays = options.windowDays ?? DEFAULT_WINDOW_DAYS;
+  const leadTimeDays = product.lead_time_days ?? DEFAULT_LEAD_TIME_DAYS;
+
+  const avgDailyConsumption = averageDailyConsumption(movements, windowDays, nowSeconds);
+  const daysUntilOut = daysUntilStockout(currentStock, avgDailyConsumption);
+  const reorderDate = suggestedReorderDate(daysUntilOut, leadTimeDays, nowSeconds);
+  const reorderDue = isReorderDue(reorderDate, nowSeconds);
+
+  return { avg_daily_consumption: avgDailyConsumption, days_until_stockout: daysUntilOut, reorder_date: reorderDate, reorder_due: reorderDue };
+}

package/src/ui/entity-renderer.js

@@ -139,6 +139,24 @@ export function renderEntityDetail(entityName, item, spec, user, history = []) {
       })()
     : ''
 
+  // Forecast fields are computed alongside current_stock (page-handler.js's
+  // inventory-forecast.js), same not-a-spec-field treatment.
+  const forecastRow = entityName === 'product' && item.days_until_stockout !== undefined
+    ? (() => {
+        const daysLabel = item.days_until_stockout == null ? 'Unknown (no recent consumption)' : `${Math.round(item.days_until_stockout)} days`
+        const reorderLabel = item.reorder_date == null ? '-' : new Date(item.reorder_date * 1000).toISOString().slice(0, 10)
+        const pillCls = item.reorder_due ? 'pill-danger' : 'pill-success'
+        return `<div class="detail-row">
+          <span class="detail-row-label">Days Until Stockout</span>
+          <span class="detail-row-value">${esc(daysLabel)}</span>
+        </div>
+        <div class="detail-row">
+          <span class="detail-row-label">Suggested Reorder Date</span>
+          <span class="detail-row-value"><span class="pill ${pillCls}">${esc(reorderLabel)}${item.reorder_due ? ' (Reorder Now)' : ''}</span></span>
+        </div>`
+      })()
+    : ''
+
   // total_hours/billable_amount are computed (page-handler.js sums time_entry
   // rows, directly for a task or joined through task for a project), same
   // not-a-spec-field treatment as current_stock above.
@@ -177,7 +195,7 @@ export function renderEntityDetail(entityName, item, spec, user, history = []) {
 
   const visibleFields = Object.entries(fields).filter(([k]) => k !== 'id' && !HIDDEN_FIELDS.has(k) && item[k] !== undefined)
 
-  const fieldRows = stockRow + timeTrackingRows + expiryRow + utilizationRow + visibleFields.map(([k, f]) =>
+  const fieldRows = stockRow + forecastRow + timeTrackingRows + expiryRow + utilizationRow + 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

@@ -9,7 +9,7 @@ import { renderEngagementGrid } from '@/ui/engagement-grid-renderer.js';
 import { renderBoardView } from '@/ui/board-view-renderer.js';
 import { renderGridView } from '@/ui/grid-view-renderer.js';
 import { renderCalendarView, renderTimelineView } from '@/ui/calendar-view-renderer.js';
-import { renderCountByFieldReport, renderCountOverTimeReport, renderSumByFieldReport, renderRollupReport } from '@/ui/report-renderer.js';
+import { renderCountByFieldReport, renderCountOverTimeReport, renderSumByFieldReport, renderRollupReport, renderInventoryForecastReport, renderDemandForecastReport } from '@/ui/report-renderer.js';
 import { renderClientProgress } from '@/ui/client-progress-renderer.js';
 import { renderLetterWorkflow } from '@/ui/letter-workflow-renderer.js';
 import { renderAdvancedSearch } from '@/ui/advanced-search-renderer.js';
@@ -118,12 +118,18 @@ async function handleGenericEntityView(user, entityName, id, req) {
   if (entityName === 'product') {
     // current_stock is derived, never a stored/editable field -- summed fresh
     // from stock_movement history so it can never drift from the ledger the
-    // way a separately-writable counter could.
+    // way a separately-writable counter could. stock_movement carries no
+    // organization_id (product is a system_entity, exempt from multi-tenancy
+    // auto-scoping the same way every other system entity this session is),
+    // so this unscoped list() matches the entity's actual access model
+    // rather than bypassing a row-access check that was never in effect.
     try {
       const movements = await list('stock_movement', { product_id: id });
       const currentStock = movements.reduce((sum, m) => sum + (Number(m.quantity) || 0), 0);
-      resolvedItem = { ...resolvedItem, current_stock: currentStock };
-    } catch { resolvedItem = { ...resolvedItem, current_stock: 0 }; }
+      const { computeInventoryForecast } = await import('@/lib/inventory-forecast.js');
+      const forecast = computeInventoryForecast(resolvedItem, movements, currentStock);
+      resolvedItem = { ...resolvedItem, current_stock: currentStock, ...forecast };
+    } catch { resolvedItem = { ...resolvedItem, current_stock: 0, avg_daily_consumption: 0, days_until_stockout: null, reorder_date: null, reorder_due: false }; }
   }
   if (entityName === 'task') {
     // total_hours/billable_amount are derived from time_entry history, same
@@ -370,6 +376,32 @@ export async function handlePage(pathname, req, res) {
       const relatedRecords = await list(relatedEntity, {}, { user });
       return renderRollupReport(user, entityName, spec, items, refField, relatedEntity, relatedSpec, relatedRecords, rollupField);
     }
+    if (report === 'inventory-forecast' && entityName === 'product') {
+      // items is already the {user}-scoped product list from above -- no new
+      // unscoped bulk query. stock_movement itself carries no organization_id
+      // (product is a system_entity, exempt from multi-tenancy auto-scoping
+      // like every other system entity this session), so it is read
+      // per-product the same unscoped way the detail view already does.
+      const { computeInventoryForecast } = await import('@/lib/inventory-forecast.js');
+      const forecastRows = [];
+      for (const p of items) {
+        const movements = await list('stock_movement', { product_id: p.id });
+        const currentStock = movements.reduce((sum, m) => sum + (Number(m.quantity) || 0), 0);
+        const forecast = computeInventoryForecast(p, movements, currentStock);
+        forecastRows.push({ ...p, current_stock: currentStock, ...forecast });
+      }
+      return renderInventoryForecastReport(user, spec, forecastRows);
+    }
+    if (report === 'demand-forecast' && entityName === 'opportunity') {
+      // items is already the {user}-scoped opportunity list fetched at the
+      // top of this route (same list(entityName,{},{user}) every other
+      // entity route uses) -- no new unscoped query, and each item already
+      // carries a computed weighted_value from list()'s own formula-field
+      // pass, reused directly rather than recomputed.
+      const { projectDemandByMonth } = await import('@/lib/demand-forecast.js');
+      const buckets = projectDemandByMonth(items);
+      return renderDemandForecastReport(user, spec, buckets, items.length);
+    }
     const view = params.get('view');
     if (view === 'board') return renderBoardView(user, entityName, spec, items);
     if (view === 'grid') return renderGridView(user, entityName, spec, items);

package/src/ui/report-renderer.js

@@ -206,3 +206,54 @@ export function renderCountOverTimeReport(user, entityName, spec, records, dateF
     ${barChart(buckets)}`;
   return page(user, `${label} Report | Thatcher`, null, content);
 }
+
+// One table per-product rather than a bar chart: unlike count-by-field/
+// sum-by-field's single grouped metric, a forecast is inherently multiple
+// values per row (stock, consumption rate, days-out, reorder date) -- a bar
+// chart of any single one of those would discard the others, so a table is
+// the correct shape here, reusing the same page()/esc() rendering discipline
+// as every other report rather than inventing a new chart type.
+export function renderInventoryForecastReport(user, spec, forecastRows) {
+  const label = getEntityLabel(spec, true) || 'Products';
+  const rows = forecastRows.map(p => {
+    const daysLabel = p.days_until_stockout == null ? 'Unknown' : String(Math.round(p.days_until_stockout))
+    const reorderLabel = p.reorder_date == null ? '-' : new Date(p.reorder_date * 1000).toISOString().slice(0, 10)
+    const rowCls = p.reorder_due ? 'style="background:var(--color-danger-bg,#fee2e2)"' : ''
+    return `<tr ${rowCls}>
+      <td>${esc(p.name || p.id)}</td>
+      <td>${esc(String(p.current_stock))}</td>
+      <td>${esc((p.avg_daily_consumption || 0).toFixed(2))}</td>
+      <td>${esc(daysLabel)}</td>
+      <td>${esc(reorderLabel)}${p.reorder_due ? ' <span class="pill pill-danger">Reorder Now</span>' : ''}</td>
+    </tr>`;
+  }).join('') || emptyState('No products to forecast', 'bar-chart');
+
+  const content = `<div class="page-header">
+      <div><h1 class="page-title">${esc(label)}: Inventory Forecast</h1><p class="page-subtitle">${forecastRows.length} products</p></div>
+    </div>
+    <div class="table-wrap"><table class="data-table">
+      <thead><tr><th>Product</th><th>Current Stock</th><th>Avg Daily Use</th><th>Days Until Stockout</th><th>Suggested Reorder</th></tr></thead>
+      <tbody>${rows}</tbody>
+    </table></div>`;
+  return page(user, `Inventory Forecast | Thatcher`, null, content);
+}
+
+// Reuses sumBarChart (already built for sum-by-field's currency-aware bar
+// rendering) rather than inventing a third chart type -- a demand-by-month
+// bucket is the exact same [label, numericValue] shape sum-by-field already
+// renders, just currency-formatted since weighted_value derives from a
+// currency field.
+export function renderDemandForecastReport(user, spec, buckets, totalOpportunities) {
+  const label = getEntityLabel(spec, true) || 'Opportunities';
+  const valueFieldDef = spec.fields?.value || { type: 'currency' };
+  const totalProjected = buckets.reduce((sum, [, v]) => sum + v, 0);
+  const notice = !buckets.length
+    ? `<div class="report-notice">No open opportunities with a future expected close date</div>`
+    : '';
+  const content = `<div class="page-header">
+      <div><h1 class="page-title">${esc(label)}: Demand Forecast</h1><p class="page-subtitle">${totalOpportunities} total opportunities, ${esc(formatSumValue(totalProjected, valueFieldDef))} projected across ${buckets.length} future month${buckets.length === 1 ? '' : 's'}</p></div>
+    </div>
+    ${notice}
+    ${sumBarChart(buckets, valueFieldDef)}`;
+  return page(user, `Demand Forecast | Thatcher`, null, content);
+}