pgkiln 0.80.0 → 0.82.0

package/src/runtime/maps.ts

@@ -60,10 +60,35 @@ interface Point {
   href: string | null;
   weight: number;
 }
+/** (159, CD-6) a shape layer's look: fixed in the layer's settings, or per row from columns of the same names */
+export interface ShapeStyle {
+  fill_color?: string;
+  stroke_color?: string;
+  stroke_width?: number;
+  opacity?: number;
+}
+const COLOR = /^#[0-9a-fA-F]{6}$/;
+/** The checked parts of a style (anything else is left out). */
+export function shapeStyle(x: unknown): ShapeStyle {
+  const s = (x && typeof x === 'object' ? x : {}) as Record<string, unknown>;
+  const out: ShapeStyle = {};
+  if (typeof s.fill_color === 'string' && COLOR.test(s.fill_color)) out.fill_color = s.fill_color;
+  if (typeof s.stroke_color === 'string' && COLOR.test(s.stroke_color)) out.stroke_color = s.stroke_color;
+  const w = Number(s.stroke_width);
+  if (s.stroke_width !== undefined && s.stroke_width !== null && Number.isFinite(w) && w >= 0 && w <= 20) out.stroke_width = w;
+  const o = Number(s.opacity);
+  if (s.opacity !== undefined && s.opacity !== null && Number.isFinite(o) && o >= 0 && o <= 1) out.opacity = o;
+  return out;
+}
+const SHAPE_KINDS = new Set(['lines', 'polygons', 'extruded']);
+const kindOf = (v: unknown): LayerDef['kind'] => (v === 'heat' || SHAPE_KINDS.has(v as string) ? (v as LayerDef['kind']) : 'markers');
+
 export interface LayerDef {
   name: string;
   source: string;
-  kind: 'markers' | 'heat';
+  /** (159) lines, polygons: GeoJSON / PostGIS shapes with a style; extruded: polygons shaded by a height column */
+  kind: 'markers' | 'heat' | 'lines' | 'polygons' | 'extruded';
+  style: ShapeStyle;
   cluster: boolean;
   link: Link | undefined;
   hidden: boolean;
@@ -78,7 +103,8 @@ export function layerDefs(r: Region): LayerDef[] {
   const first: LayerDef = {
     name: typeof r.config.name === 'string' && r.config.name.trim() ? r.config.name.trim() : (r.title ?? 'Map'),
     source: r.source ?? '',
-    kind: r.config.layer === 'heat' ? 'heat' : 'markers',
+    kind: kindOf(r.config.layer),
+    style: shapeStyle(r.config.style),
     cluster: r.config.cluster === true,
     link: r.config.link,
     hidden: false,
@@ -91,7 +117,8 @@ export function layerDefs(r: Region): LayerDef[] {
     .map((l: any, i: number): LayerDef => ({
       name: typeof l.name === 'string' && l.name.trim() ? l.name.trim() : `Layer ${i + 2}`,
       source: l.source,
-      kind: l.layer === 'heat' ? 'heat' : 'markers',
+      kind: kindOf(l.layer),
+      style: shapeStyle(l.style),
       cluster: l.cluster === true,
       link: l.link && typeof l.link === 'object' && Number.isInteger(l.link.page) ? l.link : undefined,
       hidden: l.hidden === true,
@@ -151,12 +178,31 @@ async function loadLayer(ctx: PageContext, def: LayerDef, g: PostGis | null, opt
       if (geometry?.type === 'Point' && Array.isArray(geometry.coordinates) && (Number.isNaN(lat) || Number.isNaN(lng)))
         // a point is a place (a marker, a heat spot, part of a cluster)
         [lng, lat] = geometry.coordinates.map(Number);
-      else if (geometry && typeof geometry === 'object') shapes.push({ type: 'Feature', geometry, properties: { title, body, href } });
+      else if (geometry && typeof geometry === 'object') {
+        // (159) a shape layer's style: the layer's, then the row's own columns
+        const style = SHAPE_KINDS.has(def.kind)
+          ? { ...def.style, ...shapeStyle({ fill_color: col(row, 'fill_color'), stroke_color: col(row, 'stroke_color'), stroke_width: col(row, 'stroke_width'), opacity: col(row, 'opacity') }) }
+          : undefined;
+        const h = num(col(row, 'height'));
+        shapes.push({ type: 'Feature', geometry, properties: { title, body, href, ...(style ? { style } : {}), ...(def.kind === 'extruded' && Number.isFinite(h) ? { height: h } : {}) } });
+      }
     }
+    // a shape layer draws only shapes
+    if (SHAPE_KINDS.has(def.kind)) continue;
     const w = num(col(row, 'weight'));
     const weight = Number.isFinite(w) && w > 0 ? w : Number.isNaN(w) ? 1 : 0;
     if (Math.abs(lat) <= 90 && Math.abs(lng) <= 180) points.push({ lat, lng, title, body, href, weight });
   }
+  // (159) extruded: each polygon shaded by its height (from light to strong; no 3D view)
+  if (def.kind === 'extruded') {
+    const hs = shapes.map((f: any) => f.properties.height).filter((h): h is number => typeof h === 'number');
+    const [lo, hi] = hs.length ? [Math.min(...hs), Math.max(...hs)] : [0, 0];
+    for (const f of shapes as any[]) {
+      const h = f.properties.height;
+      const share = typeof h === 'number' && hi > lo ? (h - lo) / (hi - lo) : 0.5;
+      f.properties.style = { ...f.properties.style, opacity: Math.round((0.2 + 0.7 * share) * 100) / 100 };
+    }
+  }
   return { points, shapes, truncated };
 }
 

package/src/runtime/process-types.ts

@@ -0,0 +1,139 @@
+// (sprint 157, CD-4) Declarative process types APEX applications rely on (migration 150). Each one calls what pgkiln
+// already has: session state, user preferences, the geocoder, document templates, human tasks.
+import type { Process } from '../metadata.ts';
+import { geocode, geocoderUrl } from '../geocode.ts';
+import { substitute, toState, type PageContext } from './context.ts';
+import { renderDocument } from './documents.ts';
+
+const ITEM = /^[A-Z][A-Z0-9_]{0,99}$/;
+const NAME = /^[A-Z][A-Z0-9_]{0,59}$/;
+const isItem = (x: unknown) => typeof x === 'string' && ITEM.test(x);
+const items = (x: unknown) => Array.isArray(x) && x.every(isItem);
+const text = (x: unknown) => x === undefined || typeof x === 'string';
+
+export const DECLARATIVE_PROCESS_TYPES = new Set(['close_dialog', 'clear_session_state', 'reset_pagination', 'user_preferences', 'server_geocoding',
+  'print_report', 'human_task_create', 'human_task_manage', 'form_init']);
+const TASK_ACTIONS = ['approve', 'reject', 'complete', 'claim', 'release', 'delegate', 'cancel'];
+
+/** Problems with a declarative process's config (the builder shows them; running refuses them). */
+export function declarativeProblems(type: string, conf: unknown): string[] {
+  const c = (conf ?? {}) as Record<string, any>;
+  const out: string[] = [];
+  switch (type) {
+    case 'close_dialog':
+      if (c.items !== undefined && !items(c.items)) out.push('"items" is a list of item names, e.g. ["P5_ID"].');
+      break;
+    case 'clear_session_state':
+      if (c.items !== undefined && !items(c.items)) out.push('"items" is a list of item names.');
+      if (c.pages !== undefined && !(Array.isArray(c.pages) && c.pages.every((n: unknown) => Number.isInteger(n) && (n as number) > 0))) out.push('"pages" is a list of page numbers.');
+      if (c.all !== undefined && typeof c.all !== 'boolean') out.push('"all" is true or false.');
+      if (!c.items && !c.pages && !c.all) out.push('Name "items", "pages" or "all": true.');
+      break;
+    case 'user_preferences':
+      if (!['set', 'reset'].includes(c.action ?? 'set')) out.push('"action" is set or reset.');
+      if (typeof c.preference !== 'string' || !NAME.test(c.preference.toUpperCase())) out.push('"preference" is a name, e.g. DEFAULT_DEPT.');
+      if ((c.action ?? 'set') === 'set' && !isItem(c.item)) out.push('"item" names the item whose value is stored.');
+      break;
+    case 'server_geocoding':
+      if (!isItem(c.address_item)) out.push('"address_item" is the item with the address.');
+      if (!isItem(c.coordinates_item)) out.push('"coordinates_item" is the item that gets "lat,lng".');
+      if (c.country !== undefined && !(typeof c.country === 'string' && /^[a-z]{2}(,[a-z]{2})*$/i.test(c.country))) out.push('"country" is a country code, e.g. nl.');
+      break;
+    case 'print_report':
+      if (typeof c.document !== 'string' || !NAME.test(c.document.toUpperCase())) out.push('"document" names a document template or report query.');
+      break;
+    case 'human_task_create':
+      if (typeof c.definition !== 'string' || !NAME.test(c.definition.toUpperCase())) out.push('"definition" names a task definition, e.g. LEAVE_APPROVAL.');
+      if (!text(c.detail_pk)) out.push('"detail_pk" is text, e.g. "&P7_ID.".');
+      if (c.parameters !== undefined && (typeof c.parameters !== 'object' || c.parameters === null || Array.isArray(c.parameters) || Object.values(c.parameters).some((v) => typeof v !== 'string')))
+        out.push('"parameters" maps parameter names to values, e.g. {"DAYS": "&P7_DAYS."}.');
+      if (c.id_item !== undefined && !isItem(c.id_item)) out.push('"id_item" is an item name.');
+      break;
+    case 'human_task_manage':
+      if (!TASK_ACTIONS.includes(c.action)) out.push(`"action" is one of ${TASK_ACTIONS.join(', ')}.`);
+      if (typeof c.task !== 'string' || !c.task) out.push('"task" is the task id, e.g. "&P8_TASK_ID.".');
+      if (c.action === 'complete' && (typeof c.outcome !== 'string' || !NAME.test(c.outcome.toUpperCase()))) out.push('"outcome" names the outcome, e.g. APPROVED.');
+      if (c.action === 'delegate' && (typeof c.to !== 'string' || !c.to)) out.push('"to" is the user it goes to, e.g. "&P8_TO.".');
+      if (!text(c.comment)) out.push('"comment" is text.');
+      break;
+  }
+  return out;
+}
+
+/** Run a declarative process; its success message (or a default) is the answer. */
+export async function runDeclarative(ctx: PageContext, p: Process, assignable: Set<string>): Promise<string | null> {
+  const conf = (p.config ?? {}) as Record<string, any>;
+  const problems = declarativeProblems(p.type, conf);
+  if (problems.length) throw new Error(`Process "${p.name}": ${problems.join(' ')}`);
+  const c = ctx.client!;
+  const value = (s: unknown) => (typeof s === 'string' ? substitute(s, ctx, (x) => x) : null);
+  const state = ctx.session.state;
+  const assign = (name: string, v: string | null) => {
+    if (!assignable.has(name)) throw new Error(`Process "${p.name}": ${name} is not an item of this page or an application item.`);
+    state[name] = v;
+  };
+  switch (p.type) {
+    case 'form_init':
+      return null;
+    case 'close_dialog':
+      ctx.closeDialog = Object.fromEntries(((conf.items ?? []) as string[]).map((n) => [n, state[n] ?? '']));
+      return p.success_message;
+    case 'reset_pagination':
+      ctx.resetPagination = true;
+      return p.success_message;
+    case 'clear_session_state': {
+      const names = new Set<string>(conf.items ?? []);
+      const prefixes = ((conf.pages ?? []) as number[]).map((n) => `P${n}_`);
+      for (const k of Object.keys(state)) {
+        if (k.startsWith('__')) continue;
+        if (names.has(k) || prefixes.some((x) => k.startsWith(x)) || (conf.all === true && (/^P\d+_/.test(k) || ctx.app.app_items.includes(k)))) state[k] = null;
+      }
+      return p.success_message;
+    }
+    case 'user_preferences': {
+      // the public user has no preferences (as meta.get_preference): nothing to store
+      if (ctx.user === 'nobody') return null;
+      const name = String(conf.preference).toUpperCase();
+      if ((conf.action ?? 'set') === 'reset') await c.query('select meta.remove_preference($1)', [name]);
+      else await c.query('select meta.set_preference($1, $2)', [name, state[conf.item] ?? null]);
+      return p.success_message;
+    }
+    case 'server_geocoding': {
+      const address = (state[conf.address_item] ?? '').trim();
+      if (!address) return null;
+      if (!geocoderUrl()) throw new Error(ctx.locale.t('process.no_geocoder'));
+      const [first] = await geocode(address, { language: ctx.locale.lang, country: conf.country ?? null });
+      if (!first) throw new Error(ctx.locale.t('process.address_not_found', { address }));
+      assign(conf.coordinates_item, `${first.lat.toFixed(6)},${first.lon.toFixed(6)}`);
+      return p.success_message;
+    }
+    case 'print_report': {
+      const doc = await renderDocument(ctx, String(conf.document), true);
+      // the first file of a request wins (as for download processes)
+      ctx.download ??= 'download' in doc ? doc.download : { content: doc.file, name: doc.name, type: doc.type, inline: false };
+      return null;
+    }
+    case 'human_task_create': {
+      const params = Object.fromEntries(Object.entries((conf.parameters ?? {}) as Record<string, string>).map(([k, v]) => [k.toUpperCase(), value(v)]));
+      const id = (await c.query('select meta.create_task($1, $2, $3::jsonb)::text as id', [String(conf.definition).toUpperCase(), value(conf.detail_pk) || null, JSON.stringify(params)])).rows[0].id as string;
+      if (conf.id_item) assign(conf.id_item, toState(id));
+      return p.success_message ?? ctx.locale.t('process.task_created', { id });
+    }
+    case 'human_task_manage': {
+      const id = (value(conf.task) ?? '').trim();
+      if (!/^\d{1,18}$/.test(id)) throw new Error(ctx.locale.t('process.no_task'));
+      const comment = value(conf.comment) || null;
+      switch (conf.action) {
+        case 'approve': await c.query('select meta.complete_task($1::bigint, $2, $3)', [id, 'APPROVED', comment]); break;
+        case 'reject': await c.query('select meta.complete_task($1::bigint, $2, $3)', [id, 'REJECTED', comment]); break;
+        case 'complete': await c.query('select meta.complete_task($1::bigint, $2, $3)', [id, String(conf.outcome).toUpperCase(), comment]); break;
+        case 'claim': await c.query('select meta.claim_task($1::bigint)', [id]); break;
+        case 'release': await c.query('select meta.release_task($1::bigint)', [id]); break;
+        case 'delegate': await c.query('select meta.delegate_task($1::bigint, $2)', [id, value(conf.to)]); break;
+        case 'cancel': await c.query('select meta.cancel_task($1::bigint, $2)', [id, comment]); break;
+      }
+      return p.success_message;
+    }
+  }
+  return null;
+}

package/src/runtime/processes.ts

@@ -1,3 +1,4 @@
+import { declarativeProblems, DECLARATIVE_PROCESS_TYPES } from './process-types.ts';
 import { zipSync, type Zippable } from 'fflate';
 import { applyBinds } from '../binds.ts';
 import { esc } from '../html.ts';
@@ -248,6 +249,7 @@ export function processProblems(type: string, conf: unknown): string[] {
   if (type === 'workflow') return workflowProblems(conf);
   if (type === 'send_push') return sendPushProblems(conf);
   if (type === 'send_email') return sendEmailProblems(conf);
+  if (DECLARATIVE_PROCESS_TYPES.has(type)) return declarativeProblems(type, conf);
   return [];
 }
 

package/src/runtime/regions.ts

@@ -1,3 +1,4 @@
+import { renderWorkflowDiagram } from './workflow-diagram.ts';
 import type { QueryResult } from 'pg';
 import { ganttEditable } from './gantt-move.ts';
 import { applyBinds } from '../binds.ts';
@@ -379,6 +380,9 @@ async function renderBody(ctx: PageContext, r: Region, hidden: Set<string>): Pro
     case 'workflows':
       body = await renderWorkflows(ctx, r);
       break;
+    case 'workflow_diagram':
+      body = await renderWorkflowDiagram(ctx, r);
+      break;
     case 'map':
       body = await renderMap(ctx, r);
       break;

package/src/runtime/render.ts

@@ -1,3 +1,4 @@
+import { compareValues, safeStyles } from './da-styles.ts';
 import { randomUUID } from 'node:crypto';
 import { urlChecksum } from '../security.ts';
 import { pwaBody, pwaHead } from './pwa.ts';
@@ -50,6 +51,9 @@ function dynamicActionsJson(ctx: PageContext) {
       fn: d.action === 'execute_javascript' && /^[A-Za-z_$][\w$.-]{0,99}$/.test(d.code?.trim() ?? '') ? d.code!.trim() : null,
       // plugin: the plug-in's name and attribute values (only a plug-in of the application)
       ...(d.action === 'plugin' ? pluginAction(ctx, d.code, d.config) : {}),
+      // (156) set_style: checked properties and values; open_report_dialog: the dialog's key (checked by the database)
+      ...(d.action === 'set_style' ? { styles: safeStyles(d.config) } : {}),
+      ...(d.action === 'open_report_dialog' ? { dialog: /^[a-z]{3,10}$/.test(d.code?.trim() ?? '') ? d.code!.trim() : null } : {}),
     }));
 
 function pluginAction(ctx: PageContext, name: string | null, config: Record<string, any> | null | undefined) {
@@ -65,6 +69,12 @@ function conditionHolds(type: string | null, expected: string | null, value: str
     case 'in_list': return (expected ?? '').split(',').map((x) => x.trim()).includes(value);
     case 'is_null': return value === '';
     case 'is_not_null': return value !== '';
+    // (156) greater / less: numbers as numbers, else text (ISO dates sort as text); not_in_list
+    case 'greater': return value !== '' && compareValues(value, expected ?? '') > 0;
+    case 'greater_equal': return value !== '' && compareValues(value, expected ?? '') >= 0;
+    case 'less': return value !== '' && compareValues(value, expected ?? '') < 0;
+    case 'less_equal': return value !== '' && compareValues(value, expected ?? '') <= 0;
+    case 'not_in_list': return !(expected ?? '').split(',').map((x) => x.trim()).includes(value);
     default: return true;
   }
 }
@@ -418,12 +428,13 @@ export async function renderPage(ctx: PageContext) {
 }
 
 /** Response to a successful submit inside a dialog: tells the opener to close it. */
-export function dialogClosePage(ctx: PageContext) {
+/** (157) `items`: the values a close_dialog process hands to the page below (items of the same name there are set). */
+export function dialogClosePage(ctx: PageContext, items?: Record<string, string>) {
   return documentShell(
     ctx.app.name,
     html`<main class="t-dialog-main"><p>${ctx.locale.t('dialog.done')} <a href="${ctx.base}/${ctx.app.home_page}">${ctx.locale.t('dialog.continue')}</a></p></main>`,
     't-dialog-page',
-    { 'data-dialog-close': '1', 'data-dialog-page': String(ctx.page.page_no) },
+    { 'data-dialog-close': '1', 'data-dialog-page': String(ctx.page.page_no), ...(items && Object.keys(items).length ? { 'data-dialog-items': JSON.stringify(items) } : {}) },
     '',
     { lang: ctx.locale.lang, dir: ctx.locale.dir, theme: ctx.locale.theme, style: ctx.locale.style },
   );

package/src/runtime/routes.ts

@@ -630,9 +630,9 @@ export async function runtimeRoutes(app: FastifyInstance) {
     }
     if (messages.length) ctx.session.state.__FLASH = messages.join(' ');
     await saveState(ctx.session);
-    if (ctx.dialog) return reply.type('text/html').send(dialogClosePage(ctx));
+    if (ctx.dialog) return reply.type('text/html').send(dialogClosePage(ctx, ctx.closeDialog));
     // (sprint 54) a grid's Save comes back to the grid's search, page, sort and view
-    const back = branchTo || button.target_page ? '' : gridReturn(ctx, button.name);
+    const back = branchTo || button.target_page || ctx.resetPagination ? '' : gridReturn(ctx, button.name);
     return reply.redirect(branchTo ?? (button.target_page ? `${ctx.base}/${button.target_page}` : back ? `${self}${self.includes('?') ? '&' : '?'}${back}` : self), 303);
   });
 

package/src/runtime/workflow-diagram.ts

@@ -0,0 +1,45 @@
+// (sprint 160, CD-7) Workflow Diagram region (APEX 24.2+): one workflow instance drawn as its steps, the ones it went
+// through (green), where it is now (blue) and a failed step (red); each step's tooltip says when it was reached and
+// what happened. config {"instance_item": "P9_WORKFLOW_ID"}. The instance comes through meta.workflows, as the
+// application's role: only workflows the user started or administers (the Workflow Console's rule). Server-rendered SVG.
+import { owner, savepoint } from '../db.ts';
+import { html, type Raw } from '../html.ts';
+import type { Region } from '../metadata.ts';
+import { workflowDiagram, type Step } from '../workflow.ts';
+import { publicError, type PageContext } from './context.ts';
+import { cell } from './report.ts';
+
+export async function renderWorkflowDiagram(ctx: PageContext, r: Region): Promise<Raw> {
+  const t = ctx.locale.t;
+  const itemName = typeof r.config.instance_item === 'string' ? r.config.instance_item.toUpperCase() : '';
+  const id = (itemName ? (ctx.session.state[itemName] ?? '') : '').trim();
+  if (!/^\d{1,18}$/.test(id)) return html`<p class="empty">${r.config.empty ?? t('workflows.none')}</p>`;
+  const c = ctx.client!;
+  let w: { id: string; title: string; state: string; current_step: string | null; error: string | null; active_steps: string[] } | undefined;
+  let events: { at: string; step: string | null; event: string; detail: string | null }[] = [];
+  try {
+    w = (await savepoint(c, () => c.query('select id::text, title, state, current_step, error, active_steps from meta.workflows where id = $1::bigint', [id]))).rows[0];
+    if (w) events = (await savepoint(c, () => c.query('select at::text, step, event, detail from meta.workflow_events where workflow_id = $1::bigint order by at, id', [id]))).rows;
+  } catch (e) {
+    return html`<div class="alert alert-error" role="alert">${await publicError(ctx, e, `workflow diagram "${r.title ?? r.id}"`)}</div>`;
+  }
+  // not one the user may see (or none): the same as no instance
+  if (!w) return html`<p class="empty">${r.config.empty ?? t('workflows.none')}</p>`;
+  // the steps of its version: only after the view let this user see the instance (the steps hold SQL)
+  const steps = (await owner.query<{ steps: Step[] }>('select steps from meta.workflow where id = $1::bigint and app_id = $2', [id, ctx.app.id])).rows[0]?.steps ?? [];
+  const reached = new Set(events.filter((e) => e.step).map((e) => e.step!));
+  const active = w.state === 'completed' || w.state === 'terminated' ? [] : w.active_steps.length ? w.active_steps : w.current_step ? [w.current_step] : [];
+  const failed = w.state === 'faulted' ? active : [];
+  const done = [...reached].filter((s) => !active.includes(s));
+  const notes = new Map<string, string>();
+  // events without a step (started, terminated) belong to the first step's history
+  for (const e of events) {
+    const step = e.step ?? steps[0]?.name;
+    if (step) notes.set(step, [notes.get(step), `${cell(e.at, 1184, ctx.locale.format)}: ${e.event}${e.detail ? ` (${e.detail})` : ''}`].filter(Boolean).join('\n'));
+  }
+  return html`<div class="wf-wrap wf-instance" data-state="${w.state}">
+    <p class="muted u-mt0">${w.title} · ${t(`workflows.state.${w.state}`)}</p>
+    ${w.error ? html`<div class="alert alert-error" role="alert">${w.error}</div>` : ''}
+    ${workflowDiagram(steps, { active: failed.length ? [] : active, failed, done, notes, id: `r${r.id}` })}
+  </div>`;
+}

package/src/vector.ts

@@ -1,5 +1,5 @@
 import pg from 'pg';
-import { embedTexts, loadVectorProviders, vectorLiteral, vectorProviderProblems, DEFAULT_BATCH, DEFAULT_PER_MINUTE, type VectorProvider } from './ai/embeddings.ts';
+import { embedsInDatabase, embedTexts, loadVectorProviders, vectorLiteral, vectorProviderProblems, DEFAULT_BATCH, DEFAULT_PER_MINUTE, type VectorProvider } from './ai/embeddings.ts';
 import { isAiError } from './ai/types.ts';
 import { owner } from './db.ts';
 import { devDbForApp } from './workspace-db.ts';
@@ -127,8 +127,8 @@ async function runBatch(g: Group, p: VectorProvider): Promise<number> {
     const text = `meta.embedding_text(to_jsonb(t), $2::text[])`;
     try {
       let written = 0;
-      if (p.type === 'function') {
-        // a function provider: embedded in the database, as the developer connection (the trigger's own function)
+      if (embedsInDatabase(p)) {
+        // a function or database model provider: embedded in the database, as the developer connection (the trigger's own function)
         await db.query(
           `update ${table} t set ${id(g.vector_column)} = translate(meta.embed(${text}, $3, $4)::text, '{}', '[]')::text::${await vectorTypeOf(db)}
             where t.${id(g.key_column)}::text = any($1::text[])`, [rows.map((r) => r.key_value), g.source_columns, p.name, g.app_id]);

package/src/workflow.ts

@@ -917,12 +917,16 @@ export async function startWorkflowRunner() {
  * marks the steps an instance is at (several with parallel branches); `id`
  * keeps the arrow marker unique when a page shows several diagrams.
  */
-export function workflowDiagram(steps: Step[], opts: { active?: string[]; id?: string; standalone?: { title: string } } = {}): Raw {
+export function workflowDiagram(steps: Step[], opts: { active?: string[]; id?: string; standalone?: { title: string };
+  /** (160) the steps the instance went through, a step that failed, a tooltip per step (who and when) */
+  done?: string[]; failed?: string[]; notes?: Map<string, string> } = {}): Raw {
   if (!Array.isArray(steps) || !steps.length || steps.some((s) => !s || typeof s !== 'object' || typeof s.name !== 'string')) return html``;
   // (123) the export is an XML file: no control characters (the template escapes the rest)
   const txt = (v: unknown) => String(v ?? '').replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\ufffe\uffff]/g, '');
   const marker = `wf-arrow${opts.id ? `-${opts.id}` : ''}`;
   const active = new Set(opts.active ?? []);
+  const done = new Set(opts.done ?? []);
+  const failed = new Set(opts.failed ?? []);
   // levels: the longest path from the first step (cycles are cut)
   const level = new Map<string, number>([[steps[0].name, 0]]);
   const edges: { from: string; to: string; label: string; branch?: boolean }[] = [];
@@ -977,7 +981,9 @@ export function workflowDiagram(steps: Step[], opts: { active?: string[]; id?: s
     })}
     ${steps.map((s) => {
       const p = pos.get(s.name)!;
-      return html`<g class="wf-node wf-${TYPES.includes(s.type) ? s.type : 'unknown'}${active.has(s.name) ? ' wf-active' : ''}"><rect x="${p.x}" y="${p.y}" width="${W}" height="${H}" rx="${s.type === 'parallel' || s.type === 'join' ? 20 : 8}"/>
+      const note = opts.notes?.get(s.name);
+      const mark = failed.has(s.name) ? ' wf-failed' : active.has(s.name) ? ' wf-active' : done.has(s.name) ? ' wf-done' : '';
+      return html`<g class="wf-node wf-${TYPES.includes(s.type) ? s.type : 'unknown'}${mark}">${note ? html`<title>${txt(note)}</title>` : ''}<rect x="${p.x}" y="${p.y}" width="${W}" height="${H}" rx="${s.type === 'parallel' || s.type === 'join' ? 20 : 8}"/>
         <text x="${p.x + W / 2}" y="${p.y + 18}" class="wf-name">${txt(s.name)}</text>
         <text x="${p.x + W / 2}" y="${p.y + 34}" class="wf-type">${txt(typeText(s))}</text></g>`;
     })}
@@ -996,6 +1002,8 @@ const SVG_STYLE = `
 .wf-send_mail rect { stroke: #17794a; stroke-width: 2; }
 .wf-draft rect { fill: #fafafa; stroke: #8a8f98; stroke-width: 1.5; stroke-dasharray: 6 4; }
 .wf-active rect { fill: #e6efff; stroke: #2f6fde; stroke-width: 3; }
+.wf-done rect { fill: #e7f5ed; stroke: #17794a; }
+.wf-failed rect { fill: #fde7e4; stroke: #b42318; stroke-width: 3; }
 text { font-family: system-ui, -apple-system, "Segoe UI", Roboto, sans-serif; }
 .wf-name { fill: #1d2129; font-size: 12px; font-weight: 600; text-anchor: middle; }
 .wf-type { fill: #5d6470; font-size: 10px; text-anchor: middle; }