@friggframework/core 2.0.0--canary.703.12b980b.0 → 2.0.0--canary.707.df80bfd.0

package/integrations/definitions/renderers/preview.js

@@ -1,154 +0,0 @@
-/**
- * Previews: what an integration will show inside the apps it connects, rendered from the current settings and sample
- * or real records. Same code path as production for everything that decides the content (queries, view resolution,
- * the interpreter and its steps); the only thing swapped is where a capability call goes.
- *
- *   previewSurface   a UI surface (a HubSpot card, a Slack message menu...) -> view + html (+ slack blocks / hubspot tree)
- *   previewWorkflow  dry-run a workflow: every outbound call is RECORDED with the args it would send, none is made
- */
-const { makePorts, renderSurface, runWorkflow, recordOf } = require('../runtime');
-const { isBuiltin } = require('../steps');
-const { viewToSlack } = require('./slack');
-const { viewToHubSpot } = require('./hubspot');
-const { viewToHtml, slackMessageToHtml, callToHtml, slackBlocksToHtml, esc, HOSTS } = require('./html');
-
-class DryRunError extends Error { constructor(what) { super(`dry run: ${what} was not performed`); this.name = 'DryRunError'; } }
-
-const clone = (v) => (v === undefined ? v : JSON.parse(JSON.stringify(v)));
-
-/** A plausible empty record for a manifest object: ids are filled (a step that checks `$.steps.x.id exists` proceeds), the rest is empty of its type. */
-function sampleObject(manifest, name) {
-    const o = manifest?.objects?.[name];
-    const out = {};
-    for (const f of o?.fields || []) {
-        const keys = String(f.name).split('.');
-        let cur = out;
-        keys.slice(0, -1).forEach((k) => { cur = (cur[k] = cur[k] && typeof cur[k] === 'object' ? cur[k] : {}); });
-        const empty = f.type === 'id' ? `preview-${name}-${f.name}` : f.type === 'number' ? 0 : f.type === 'boolean' ? false : f.type === 'json' ? {} : f.type === 'array' ? [] : '';
-        cur[keys[keys.length - 1]] = empty;
-    }
-    return out;
-}
-function sampleOutput(manifest, cap) {
-    const o = String(cap?.output || '');
-    if (o.endsWith('[]')) return [];
-    if (/^page</.test(o)) return { results: [] };
-    return o && manifest?.objects?.[o] ? sampleObject(manifest, o) : {};
-}
-
-/**
- * Ports for previews. `ports.call` answers from `fixtures` (key "<module key>.<capability>", a value or a function of
- * the args), else from the manifest's own output shape, and records the call. The real `callApi` the base ports would
- * use throws, so a call that somehow bypassed the recorder fails loudly instead of reaching an API.
- *
- * @param {{ def, manifests, fixtures?: object, store?: Map }} p  fixtures.store pre-seeds the link store (keys as the real store's)
- * @returns {{ ports, calls: object[], refusing: object }}  `refusing`: the unwrapped ports, whose call() always throws (kept so a test can prove it)
- */
-function recordingPorts({ def, manifests, fixtures = {}, store }) {
-    const calls = [];
-    const rows = store || new Map(Object.entries(clone(fixtures.store) || {}));
-    const mem = {
-        get: async (k) => rows.get(k) ?? null,
-        put: async (k, v) => { rows.set(k, v); },
-        claim: async (k, v) => { if (rows.has(k)) return false; rows.set(k, v); return true; },
-        release: async (k) => { rows.delete(k); },
-    };
-    const base = makePorts({
-        def, manifests, store: mem,
-        callApi: async (moduleKey, method) => { throw new DryRunError(`${moduleKey}.${method}`); },
-        runCode: async (ref, args) => answer('code', ref, 'code', args, fixtures[`code:${ref}`], {}),
-    });
-    const ports = { ...base }; // the seam below replaces call() on this copy; `base` keeps the one that reaches callApi
-    const manifestFor = (key) => manifests[def.modules[key]?.module];
-    async function answer(module, capability, kind, args, fixture, fallback) {
-        const call = { module, capability, kind, args: clone(args) };
-        calls.push(call);
-        try {
-            call.output = typeof fixture === 'function' ? clone(await fixture(clone(args), { module, capability })) : fixture !== undefined ? clone(fixture) : fallback;
-            return clone(call.output);
-        } catch (e) { call.error = String(e.message || e); throw e; }
-    }
-    // `refusing` is the base ports as they were before the seam below: their call() reaches callApi, which throws.
-    // The seam: the interpreter only ever reaches a module through ports.call.
-    ports.call = async (moduleKey, capability, args) => {
-        const m = manifestFor(moduleKey);
-        const c = m?.capabilities?.[capability];
-        if (!c) {
-            calls.push({ module: moduleKey, capability, kind: 'unknown', args: clone(args), error: 'not declared by the module manifest' });
-            throw new Error(`${moduleKey}.${capability} is not declared by the module manifest`);
-        }
-        return answer(moduleKey, capability, c.kind, args, fixtures[`${moduleKey}.${capability}`], sampleOutput(m, c));
-    };
-    return { ports, calls, refusing: base };
-}
-
-/** read/search/subscribe calls fetch; the rest (and code) is what leaves the integration. */
-const isSend = (call) => call.kind === 'write' || call.kind === 'delete';
-
-/** How one outbound call would look where it lands. Slack messages get the real Block Kit/mrkdwn rendering. */
-function renderCall(call, manifest, appName) {
-    if (manifest?.module === 'slack' && /^message\./.test(call.capability)) {
-        const a = call.args || {};
-        const slack = { channel: a.channel, text: a.text, ...(Array.isArray(a.blocks) ? { blocks: a.blocks } : {}) };
-        return { html: slackMessageToHtml({ ...slack, appName }), slack };
-    }
-    return { html: callToHtml(call) };
-}
-
-/**
- * Dry-run one workflow. Nothing is performed: every capability call is recorded with the args it would carry and
- * answered from `fixtures` (or an empty record shaped by the manifest). A webhook workflow with no `event` runs on
- * the manifest's own sample payload for its trigger.
- *
- * @param {{ def, installation?, workflowId: string, event?, record?, manifests, fixtures?: object, now?: Function }} p
- * @returns {Promise<{ workflow: string, status: string, reason?: string, error?: string, waiting?: object, sends: object[], calls: object[], trace: object[] }>}
- *   `calls`: every call in order, `{ stepId, at, module, capability, kind, args, output, rendered }`; `sends`: the writes
- *   among them (`rendered` is `{ html, slack? }` for those, null for reads)
- */
-async function previewWorkflow({ def, installation = {}, workflowId, event, record, manifests, fixtures = {}, now }) {
-    const w = (def.workflows || []).find((x) => x.id === workflowId);
-    if (!w) throw new Error(`Unknown workflow "${workflowId}"`);
-    if (event === undefined) {
-        const t = w.trigger;
-        event = (t.type === 'webhook' && clone(manifests[def.modules[t.module]?.module]?.events?.[t.topic]?.payload)) || {};
-    }
-    const { ports, calls } = recordingPorts({ def, manifests, fixtures });
-    const run = await runWorkflow({ def, installation, workflowId, event, record, ports, manifests, ...(now ? { now } : {}) });
-
-    // The trace has one entry per step that ran; the calls, in the same order, belong to the entries that are capability steps (or code).
-    const callSteps = (run.trace || []).filter((t) => (!isBuiltin(t.use) || t.use === 'code') && (t.status === 'ok' || t.status === 'error'));
-    const aligned = callSteps.length === calls.length;
-    const out = calls.map((c, i) => {
-        const manifest = manifests[def.modules[c.module]?.module];
-        return { stepId: aligned ? callSteps[i].id : null, at: aligned ? callSteps[i].at : null, ...c, rendered: isSend(c) && manifest ? renderCall(c, manifest, def.label || def.id) : null };
-    });
-    const waiting = run.status === 'waiting' ? run.waitingFor : undefined;
-    return {
-        workflow: workflowId, status: run.status, ...(run.reason ? { reason: run.reason } : {}), ...(run.error ? { error: run.error } : {}),
-        ...(waiting ? { waiting: { ...waiting, ...(waiting.kind === 'approval' ? { html: `<div style="${HOSTS.generic.frame}"><div style="${HOSTS.generic.head}">Waits for approval</div><div style="${HOSTS.generic.body}">${esc(waiting.prompt)}</div></div>` } : {}) } } : {}),
-        sends: out.filter(isSend), calls: out, trace: run.trace || [],
-    };
-}
-
-/**
- * Render one UI surface. `ports` answer the surface's query (real ports for real records; `recordingPorts(...).ports`
- * with fixtures for samples). `host` defaults to the surface's own.
- *
- * @returns {Promise<{ surface, view, html: string, slack?: { blocks, text, truncated }, hubspot?: object }>}
- */
-async function previewSurface({ def, installation = {}, surfaceId, record, ports, host }) {
-    const { surface, view } = await renderSurface({ def, installation, surfaceId, record, ports });
-    const h = host || surface.host;
-    const opts = { integrationId: installation.integrationId, surface: surface.id };
-    const out = { surface, view };
-    if (h === 'slack') {
-        out.slack = viewToSlack(view, opts);
-        out.html = `<div data-preview-host="slack" style="${HOSTS.slack.frame}"><div style="${HOSTS.slack.head}">${esc(surface.label || def.label || def.id)} · ${esc(surface.placement)}</div><div style="${HOSTS.slack.body}">${view ? slackBlocksToHtml(out.slack.blocks) : '<em>Nothing to show for this record.</em>'}</div></div>`;
-    } else {
-        if (h === 'hubspot') out.hubspot = viewToHubSpot(view, opts);
-        out.html = viewToHtml(view, { host: h, title: `${def.ui.find((u) => u.id === surface.id)?.label || surface.id} · ${surface.placement}` });
-    }
-    return out;
-}
-
-module.exports = { previewSurface, previewWorkflow, recordingPorts, DryRunError, recordOf };

package/integrations/definitions/renderers/slack.js

@@ -1,146 +0,0 @@
-/**
- * Resolved view tree -> Slack Block Kit. Data comes from vendor records, so everything that is data is escaped for
- * mrkdwn, and everything is cut to Slack's limits with a visible marker instead of letting chat.postMessage reject the
- * whole message (a long deal name must not cost the approval request).
- */
-const { str, safeUrl, truncate, toneOf, encodeAction } = require('./common');
-
-const LIMITS = { blocks: 50, header: 150, sectionText: 3000, fieldText: 2000, fields: 10, contextText: 3000, contextElements: 10, button: 75, buttonUrl: 3000, actionId: 255, actions: 25, listItems: 25, itemText: 300 };
-const MARK = '…';
-const ZWSP = '\u200b';
-
-/**
- * Text that is DATA, for a mrkdwn field. `&`, `<` and `>` are the three characters Slack requires escaping (this also
- * defuses `<!channel>` and `<https://evil|click>` in a vendor field). Slack has no backslash escape for `* _ ~ \``, so
- * `* _ ~` are fenced with a zero-width space, which stops them pairing into bold/italic/strike without changing how they
- * look. A fenced backtick would still pair into a code span, so it becomes the look-alike U+02CB.
- */
-function escapeMrkdwn(v) {
-    return str(v).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/[*_~]/g, `${ZWSP}$&${ZWSP}`).replace(/`/g, '\u02cb');
-}
-const mrkdwn = (t) => ({ type: 'mrkdwn', text: t });
-const plain = (t) => ({ type: 'plain_text', text: t, emoji: false });
-const clip = (s, max) => truncate(s, max, MARK);
-
-/** Lines packed into as few sections as fit 3000 characters; one line is never split. */
-function linesToSections(lines) {
-    const out = [];
-    let cur = '';
-    for (const l of lines) {
-        const line = clip(l, LIMITS.itemText);
-        if (cur && cur.length + 1 + line.length > LIMITS.sectionText) { out.push(cur); cur = ''; }
-        cur = cur ? `${cur}\n${line}` : line;
-    }
-    if (cur) out.push(cur);
-    return out.map((text) => ({ type: 'section', text: mrkdwn(clip(text, LIMITS.sectionText)) }));
-}
-
-const TONE_EMOJI = { positive: ':large_green_circle:', warning: ':large_yellow_circle:', critical: ':red_circle:', neutral: ':white_circle:' };
-
-/**
- * @param {object|null} view  resolveView output ({ component, props, children })
- * @param {{ integrationId?: string, surface?: string }} [opts]  what a button's click carries back
- * @returns {{ blocks: object[], text: string, truncated: boolean }}  `text` is the notification/fallback text
- */
-function viewToSlack(view, { integrationId, surface } = {}) {
-    const blocks = [];
-    let text = '';
-    let truncated = false;
-    let pending = []; // consecutive buttons share one actions block
-    let n = 0;
-
-    const flush = () => {
-        if (!pending.length) return;
-        const els = pending.slice(0, LIMITS.actions);
-        if (pending.length > LIMITS.actions) truncated = true;
-        blocks.push({ type: 'actions', elements: els });
-        pending = [];
-    };
-    const push = (b) => { flush(); blocks.push(b); };
-
-    const walk = (node) => {
-        if (!node || typeof node !== 'object') return;
-        const p = node.props || {};
-        switch (node.component) {
-            case 'Heading': {
-                flush();
-                const t = clip(str(p.text), LIMITS.header);
-                if (!text) text = t;
-                if (t) blocks.push({ type: 'header', text: plain(t) });
-                break;
-            }
-            case 'Text': {
-                const t = str(p.text);
-                if (!text) text = t;
-                if (t) push({ type: 'section', text: mrkdwn(clip(escapeMrkdwn(t), LIMITS.sectionText)) });
-                break;
-            }
-            case 'KeyValue': {
-                const items = Array.isArray(p.items) ? p.items : [];
-                for (let i = 0; i < items.length; i += LIMITS.fields) {
-                    const fields = items.slice(i, i + LIMITS.fields).map((it) => mrkdwn(clip(`*${escapeMrkdwn(it?.label)}*\n${escapeMrkdwn(it?.value) || '—'}`, LIMITS.fieldText)));
-                    if (fields.length) push({ type: 'section', fields });
-                }
-                break;
-            }
-            case 'List': {
-                const items = Array.isArray(p.items) ? p.items : [];
-                const lines = items.slice(0, LIMITS.listItems).map((it) => `• ${escapeMrkdwn(it?.title)}${it?.meta ? ` — _${escapeMrkdwn(it.meta)}_` : ''}`);
-                if (items.length > LIMITS.listItems) { lines.push(`_${MARK} and ${items.length - LIMITS.listItems} more_`); truncated = true; }
-                flush();
-                blocks.push(...linesToSections(lines));
-                break;
-            }
-            case 'Table': {
-                const cols = Array.isArray(p.columns) ? p.columns : [];
-                const rows = Array.isArray(p.rows) ? p.rows : [];
-                const lines = [];
-                if (cols.length) lines.push(cols.map((c) => `*${escapeMrkdwn(c)}*`).join('  |  '));
-                for (const r of rows.slice(0, LIMITS.listItems)) lines.push((Array.isArray(r) ? r : []).map((c) => escapeMrkdwn(c) || '—').join('  |  '));
-                if (rows.length > LIMITS.listItems) { lines.push(`_${MARK} and ${rows.length - LIMITS.listItems} more_`); truncated = true; }
-                flush();
-                blocks.push(...linesToSections(lines));
-                break;
-            }
-            case 'Badge': {
-                const t = str(p.text);
-                if (t) push({ type: 'context', elements: [mrkdwn(clip(`${TONE_EMOJI[toneOf(p.tone)]} *${escapeMrkdwn(t)}*`, LIMITS.contextText))] });
-                break;
-            }
-            case 'Empty': {
-                const t = str(p.text);
-                if (t) push({ type: 'context', elements: [mrkdwn(clip(`_${escapeMrkdwn(t)}_`, LIMITS.contextText))] });
-                break;
-            }
-            case 'Divider': push({ type: 'divider' }); break;
-            case 'Button': {
-                const label = clip(str(p.label) || 'Open', LIMITS.button);
-                const style = p.style === 'primary' ? { style: 'primary' } : p.style === 'danger' ? { style: 'danger' } : {};
-                const a = p.action;
-                if (a?.type === 'userAction' && typeof a.workflow === 'string') {
-                    const value = encodeAction({ integrationId, workflow: a.workflow, surface, needsInput: !!a.input });
-                    if (value) pending.push({ type: 'button', text: plain(label), action_id: clip(`frigg:${a.workflow}`, LIMITS.actionId - 8) + `:${n++}`, value, ...style });
-                } else if (a?.type === 'open_url') {
-                    const url = safeUrl(a.url);
-                    if (url && url.length <= LIMITS.buttonUrl) pending.push({ type: 'button', text: plain(label), action_id: `frigg:open:${n++}`, url });
-                }
-                break;
-            }
-            default: break; // Stack, and anything a newer definition adds: just its children
-        }
-        for (const c of node.children || []) walk(c);
-    };
-    walk(view);
-    flush();
-
-    // 50 blocks is Slack's whole-message cap. Keep 49 and say so, rather than lose the message.
-    let out = blocks;
-    if (blocks.length > LIMITS.blocks) {
-        out = [...blocks.slice(0, LIMITS.blocks - 1), { type: 'context', elements: [mrkdwn(`_${MARK} ${blocks.length - (LIMITS.blocks - 1)} more blocks not shown_`)] }];
-        truncated = true;
-    }
-    // `text` is the notification fallback and Slack parses it as mrkdwn too, so a record's `<!channel>` must not ping from there either.
-    return { blocks: out, text: clip(escapeMrkdwn(text || 'Update'), LIMITS.sectionText), truncated };
-}
-
-module.exports = { viewToSlack, escapeMrkdwn, LIMITS };

package/integrations/definitions/repositories/definition-version-repository.js

@@ -1,67 +0,0 @@
-/**
- * IntegrationDefinitionVersion persistence (ADR-063). Pure data access: one Prisma call per method, no business rules.
- * Which version is "latest", whether a publish is allowed and what a status change means are decided by the use cases
- * (../use-cases/definition-use-cases.js); this layer only stores and reads rows.
- *
- * Rows come back as plain objects with string ids on every database. `document` is the definition verbatim.
- */
-const { prisma } = require('../../../database/prisma');
-
-const FIELDS = ['definitionId', 'version', 'schemaVersion', 'status', 'checksum', 'document', 'changeLevel', 'previousVersion', 'notes', 'createdBy', 'workspaceId', 'publishedAt'];
-const pick = (o) => Object.fromEntries(FIELDS.filter((k) => o[k] !== undefined).map((k) => [k, o[k]]));
-
-class DefinitionVersionRepositoryMongo {
-    constructor({ client } = {}) { this.prisma = client || prisma; }
-    toRow(r) { return r ? { ...r, id: String(r.id) } : null; }
-
-    async findVersion(definitionId, version) {
-        return this.toRow(await this.prisma.integrationDefinitionVersion.findUnique({ where: { definitionId_version: { definitionId, version } } }));
-    }
-
-    /** Every version of one definition, any status, unordered (semver order is the caller's business). */
-    async listVersions(definitionId) {
-        return (await this.prisma.integrationDefinitionVersion.findMany({ where: { definitionId } })).map((r) => this.toRow(r));
-    }
-
-    /** Rows in the given statuses across all definitions, without documents (a catalogue listing). */
-    async listByStatus(statuses) {
-        const rows = await this.prisma.integrationDefinitionVersion.findMany({
-            where: { status: { in: statuses } },
-            select: { id: true, definitionId: true, version: true, schemaVersion: true, status: true, checksum: true, changeLevel: true, workspaceId: true, publishedAt: true, createdAt: true },
-        });
-        return rows.map((r) => this.toRow(r));
-    }
-
-    async createVersion(data) {
-        return this.toRow(await this.prisma.integrationDefinitionVersion.create({ data: pick(data) }));
-    }
-
-    /**
-     * Change a row only if it is still in `fromStatus` (the use case's precondition, checked by the database, so two
-     * concurrent publishes cannot both win). Returns the updated row, or null if it was not in that status.
-     */
-    async updateIfStatus(definitionId, version, fromStatus, data) {
-        const { count } = await this.prisma.integrationDefinitionVersion.updateMany({ where: { definitionId, version, status: fromStatus }, data: pick(data) });
-        return count ? this.findVersion(definitionId, version) : null;
-    }
-
-    async deleteIfStatus(definitionId, version, status) {
-        const { count } = await this.prisma.integrationDefinitionVersion.deleteMany({ where: { definitionId, version, status } });
-        return count > 0;
-    }
-}
-
-class DefinitionVersionRepositoryPostgres extends DefinitionVersionRepositoryMongo {}
-class DefinitionVersionRepositoryDocumentDB extends DefinitionVersionRepositoryMongo {}
-
-function createDefinitionVersionRepository() {
-    const { DB_TYPE } = require('../../../database/config');
-    switch (DB_TYPE) {
-        case 'mongodb': return new DefinitionVersionRepositoryMongo();
-        case 'postgresql': return new DefinitionVersionRepositoryPostgres();
-        case 'documentdb': return new DefinitionVersionRepositoryDocumentDB();
-        default: throw new Error(`Unsupported database type: ${DB_TYPE}. Supported values: 'mongodb', 'documentdb', 'postgresql'`);
-    }
-}
-
-module.exports = { createDefinitionVersionRepository, DefinitionVersionRepositoryMongo, DefinitionVersionRepositoryPostgres, DefinitionVersionRepositoryDocumentDB };

package/integrations/definitions/repositories/workflow-run-repository.js

@@ -1,80 +0,0 @@
-/**
- * WorkflowRun persistence (ADR-063). Pure data access. A run row never holds request or response bodies: `trace` is
- * step ids, statuses, timings and error messages (see runtime.js).
- */
-const { prisma } = require('../../../database/prisma');
-
-class WorkflowRunRepositoryMongo {
-    constructor({ client } = {}) { this.prisma = client || prisma; }
-    toId(id) { return String(id); }
-    toRowId(id) { return String(id); }
-    toRow(r) { return r ? { ...r, id: String(r.id), integrationId: String(r.integrationId) } : null; }
-
-    async createRun(run) {
-        return this.toRow(await this.prisma.workflowRun.create({
-            data: {
-                integrationId: this.toId(run.integrationId), definitionId: run.definitionId, definitionVersion: run.definitionVersion,
-                workflowId: run.workflowId, triggerType: run.triggerType, eventId: run.eventId ?? null, status: run.status,
-                reason: run.reason ?? null, error: run.error ?? null, retryable: Boolean(run.retryable), trace: run.trace || [],
-                runKey: run.runKey ?? null, waitingFor: run.waitingFor ?? null, resumeAt: run.resumeAt ? new Date(run.resumeAt) : null,
-                startedAt: new Date(run.startedAt), endedAt: run.endedAt ? new Date(run.endedAt) : null,
-            },
-        }));
-    }
-
-    /** One run of an installation, by the runtime's run id. */
-    async findRun(integrationId, runKey) {
-        return this.toRow(await this.prisma.workflowRun.findFirst({ where: { integrationId: this.toId(integrationId), runKey: String(runKey) }, orderBy: { startedAt: 'desc' } }));
-    }
-
-    /** Update a run by its row id (a paused run finishing, or pausing again). Only the given fields change. */
-    async updateRun(id, data) {
-        const fields = {};
-        for (const k of ['status', 'reason', 'error', 'retryable', 'trace', 'waitingFor']) if (k in data) fields[k] = data[k] ?? (k === 'trace' ? [] : null);
-        if ('resumeAt' in data) fields.resumeAt = data.resumeAt ? new Date(data.resumeAt) : null;
-        if ('endedAt' in data) fields.endedAt = data.endedAt ? new Date(data.endedAt) : null;
-        return this.toRow(await this.prisma.workflowRun.update({ where: { id: this.toRowId(id) }, data: fields }));
-    }
-
-    /** Newest first. `before` pages by startedAt. */
-    async listRuns(integrationId, { workflowId, status, before, limit = 50 } = {}) {
-        const rows = await this.prisma.workflowRun.findMany({
-            where: { integrationId: this.toId(integrationId), ...(workflowId ? { workflowId } : {}), ...(status ? { status } : {}), ...(before ? { startedAt: { lt: new Date(before) } } : {}) },
-            orderBy: { startedAt: 'desc' },
-            take: Math.min(Math.max(1, limit), 500),
-        });
-        return rows.map((r) => this.toRow(r));
-    }
-
-    /** Delete runs that started before `olderThan`, optionally only in some statuses. Returns the count. */
-    async deleteRunsBefore(olderThan, { statuses } = {}) {
-        const { count } = await this.prisma.workflowRun.deleteMany({ where: { startedAt: { lt: new Date(olderThan) }, ...(statuses ? { status: { in: statuses } } : {}) } });
-        return count;
-    }
-}
-
-class WorkflowRunRepositoryPostgres extends WorkflowRunRepositoryMongo {
-    toId(id) {
-        const n = Number.parseInt(id, 10);
-        if (Number.isNaN(n)) throw new Error(`Invalid integration id: ${id}`);
-        return n;
-    }
-    toRowId(id) {
-        const n = Number.parseInt(id, 10);
-        if (Number.isNaN(n)) throw new Error(`Invalid run id: ${id}`);
-        return n;
-    }
-}
-class WorkflowRunRepositoryDocumentDB extends WorkflowRunRepositoryMongo {}
-
-function createWorkflowRunRepository() {
-    const { DB_TYPE } = require('../../../database/config');
-    switch (DB_TYPE) {
-        case 'mongodb': return new WorkflowRunRepositoryMongo();
-        case 'postgresql': return new WorkflowRunRepositoryPostgres();
-        case 'documentdb': return new WorkflowRunRepositoryDocumentDB();
-        default: throw new Error(`Unsupported database type: ${DB_TYPE}. Supported values: 'mongodb', 'documentdb', 'postgresql'`);
-    }
-}
-
-module.exports = { createWorkflowRunRepository, WorkflowRunRepositoryMongo, WorkflowRunRepositoryPostgres, WorkflowRunRepositoryDocumentDB };

package/integrations/definitions/router.js

@@ -1,170 +0,0 @@
-/**
- * HTTP routes for integration versions, run history, sync progress and approvals, mounted by createIntegrationRouter
- * when the app registers the integration runtime (a class with `IntegrationRuntime`). They answer for EVERY integration,
- * however it was made: an integration with no run history, syncs or other versions gets an empty answer, not a 404.
- * Thin adapters: authenticate, call a use case, map the result to a status.
- *
- * Signed-in users (Frigg's usual authentication: bearer token, x-frigg headers or adopter JWT):
- *   GET  /api/integration-definitions                   what can be installed: latest published version of each
- *                                                        (GET /api/integrations lists the same types as options)
- *   GET  /api/integrations/:integrationId/upgrade?to=    the upgrade plan for an installation (changes nothing)
- *   POST /api/integrations/:integrationId/upgrade        { to? } apply it (refused while anything is needed)
- *   GET  /api/integrations/:integrationId/runs           workflow run history, newest first (?workflowId&status&before&limit)
- *   GET  /api/integrations/:integrationId/syncs          each sync's backfill progress and poll marks
- *   POST /api/integrations/:integrationId/runs/:runId/decision   { decision: approve|reject, note? } on a paused approval
- *
- * A workspace's own integrations (signed-in user; the workspace is the user's Frigg id):
- *   POST /api/integration-definitions                    { document, notes?, publish? = true } publish (or draft) a version
- *   GET  /api/integration-definitions/:id                its versions and the latest document, for the editor
- *
- * App admins (x-frigg-admin-api-key, the validateAdminApiKey middleware that /admin/scripts and /admin/db-migrate use):
- *   POST /admin/integrations/versions                { document, notes?, publish? = true, strict? } validate + publish
- *   GET  /admin/integrations/:id/versions            every version of one integration
- *   POST /admin/integrations/:id/versions/:version/deprecate
- *
- * Installing needs no new route: POST /api/integrations with config { type: '<integration id>' } pins the latest
- * published version, exactly as a code integration is installed by its name.
- */
-const catchAsyncError = require('express-async-handler');
-const { validateAdminApiKey } = require('../../handlers/middleware/admin-auth');
-const { DefinitionError, PublishDefinitionVersion, DeprecateDefinitionVersion, GetDefinitionHistory, GetIntegrationForDecision, GetOwnDefinition } = require('./use-cases/definition-use-cases');
-
-/** An integration with one version (code that is not published as versions): nothing to move to. */
-const noUpgrade = (integration) => ({
-    allowed: false, applied: false, needs: [], actions: [],
-    from: integration.constructor?.Definition?.version ?? null, to: integration.constructor?.Definition?.version ?? null,
-    reason: 'This integration has no other version to move to',
-});
-
-/**
- * Every route this router registers, in one place: method, path and who may call it. The registrations below take their
- * paths from here, so this list cannot drift from what is served.
- *
- * Admin routes sit in core's existing /admin/* namespace (beside /admin/scripts and /admin/db-migrate, same admin-auth
- * middleware). The user routes are on their pre-/api/v2 paths and move onto the /api/v2 route registry via PR #671; having
- * them listed as data is what makes that move mechanical.
- * auth: 'user' = a signed-in user (the workspace is the user's Frigg id), 'admin' = x-frigg-admin-api-key.
- */
-const DEFINITION_ROUTES = Object.freeze({
-    catalogue:        { method: 'GET',  path: '/api/integration-definitions', auth: 'user' },
-    upgradePlan:      { method: 'GET',  path: '/api/integrations/:integrationId/upgrade', auth: 'user' },
-    upgradeApply:     { method: 'POST', path: '/api/integrations/:integrationId/upgrade', auth: 'user' },
-    runs:             { method: 'GET',  path: '/api/integrations/:integrationId/runs', auth: 'user' },
-    decide:           { method: 'POST', path: '/api/integrations/:integrationId/runs/:runId/decision', auth: 'user' },
-    syncs:            { method: 'GET',  path: '/api/integrations/:integrationId/syncs', auth: 'user' },
-    ownPublish:       { method: 'POST', path: '/api/integration-definitions', auth: 'user' },
-    ownRead:          { method: 'GET',  path: '/api/integration-definitions/:definitionId', auth: 'user' },
-    adminPublish:     { method: 'POST', path: '/admin/integrations/versions', auth: 'admin' },
-    adminVersions:    { method: 'GET',  path: '/admin/integrations/:definitionId/versions', auth: 'admin' },
-    adminDeprecate:   { method: 'POST', path: '/admin/integrations/:definitionId/versions/:version/deprecate', auth: 'admin' },
-});
-const path = (key) => DEFINITION_ROUTES[key].path;
-
-function sendError(res, e) {
-    if (e instanceof DefinitionError || e?.name === 'DefinitionError') return res.status(e.status || 400).json({ error: e.message, code: e.code, details: e.details });
-    throw e;
-}
-const guard = (fn) => catchAsyncError(async (req, res) => { try { await fn(req, res); } catch (e) { sendError(res, e); } });
-
-/**
- * @param {import('express').Router} router
- * @param {{ execute(req): Promise<{ getId(): string }> }} authenticateUser
- * @param {{ getIntegrationInstance, integrationClasses: Function[] }} deps
- */
-function setIntegrationRuntimeRoutes(router, authenticateUser, { getIntegrationInstance, integrationClasses }) {
-    const classes = integrationClasses.filter((c) => c.IntegrationRuntime);
-    if (!classes.length) return false;
-    const catalogClass = classes.find((c) => c.IntegrationRuntime.shared) || classes[0];
-    const { definitions, manifests } = catalogClass.IntegrationRuntime;
-
-    const installation = async (req) => {
-        const user = await authenticateUser.execute(req);
-        return getIntegrationInstance.execute(req.params.integrationId, user.getId());
-    };
-    const runtimeOf = (integration) => integration?.constructor?.IntegrationRuntime || null;
-
-    router.route(path('catalogue')).get(guard(async (req, res) => {
-        const user = await authenticateUser.execute(req);
-        const lists = await Promise.all(classes.map((c) => (c.IntegrationRuntime.definitions.list ? c.IntegrationRuntime.definitions.list({ workspaceId: String(user.getId()) }) : [])));
-        const seen = new Set();
-        res.json({ definitions: lists.flat().filter((d) => (seen.has(d.id) ? false : seen.add(d.id))) });
-    }));
-
-    router.route(path('upgradePlan'))
-        .get(guard(async (req, res) => {
-            const integration = await installation(req);
-            if (typeof integration.upgradeTo !== 'function') return res.json(noUpgrade(integration));
-            res.json(await integration.upgradeTo(req.query.to || undefined, { apply: false }));
-        }))
-        .post(guard(async (req, res) => {
-            const integration = await installation(req);
-            if (typeof integration.upgradeTo !== 'function') return res.status(409).json(noUpgrade(integration));
-            const result = await integration.upgradeTo(req.body?.to || undefined, { apply: true });
-            res.status(result.applied ? 200 : 409).json(result);
-        }));
-
-    router.route(path('runs')).get(guard(async (req, res) => {
-        const integration = await installation(req);
-        const store = runtimeOf(integration)?.runs() || catalogClass.IntegrationRuntime.runs();
-        if (!store) return res.json({ runs: [] });
-        const { workflowId, status, before, limit } = req.query;
-        res.json({ runs: await store.listRuns(integration.id, { workflowId, status, before, limit: limit ? Number(limit) : undefined }) });
-    }));
-
-    // Approvers need not own the installation: the run names who may decide it (an approval step's approvers).
-    // Anyone else learns nothing, not even that the installation exists.
-    router.route(path('decide')).post(guard(async (req, res) => {
-        const user = await authenticateUser.execute(req);
-        const { integration, isOwner } = await new GetIntegrationForDecision({ getIntegrationInstance }).execute(req.params.integrationId, user.getId());
-        if (typeof integration?.decide !== 'function') throw new DefinitionError(`Run ${req.params.runId} is not waiting`, { status: 404, code: 'NOT_WAITING' });
-        const out = await integration.decide(req.params.runId, { decision: req.body?.decision, note: req.body?.note, userId: user.getId(), isOwner });
-        res.status(202).json(out);
-    }));
-
-    router.route(path('syncs')).get(guard(async (req, res) => {
-        const integration = await installation(req);
-        res.json({ syncs: typeof integration.syncStatus === 'function' ? await integration.syncStatus() : [] });
-    }));
-
-    // A workspace's own integrations: publish a version, read it back for the editor. The
-    // integration then appears to that workspace like any other; no one else can see, read or install it.
-    const registeredNames = new Set(integrationClasses.map((c) => c.Definition?.name).filter(Boolean));
-    router.route(path('ownPublish')).post(guard(async (req, res) => {
-        const user = await authenticateUser.execute(req);
-        const { document, notes, publish } = req.body || {};
-        const out = await new PublishDefinitionVersion({ repository: repository(), manifests, isReserved: (id) => registeredNames.has(id) })
-            .execute({ document, notes, publish: publish !== false, workspaceId: String(user.getId()), createdBy: String(user.getId()) });
-        const { document: _omit, ...version } = out.version;
-        res.status(out.created ? 201 : 200).json({ ...out, version });
-    }));
-    router.route(path('ownRead')).get(guard(async (req, res) => {
-        const user = await authenticateUser.execute(req);
-        const out = await new GetOwnDefinition({ repository: repository() }).execute({ definitionId: req.params.definitionId, workspaceId: String(user.getId()) });
-        res.json(out);
-    }));
-
-    const admin = (path) => router.route(path).all(validateAdminApiKey);
-    const repository = () => {
-        const repo = definitions.repository;
-        if (!repo) throw new DefinitionError('This app runs bundled definitions; there is no store to publish to', { status: 501, code: 'NO_STORE' });
-        return repo;
-    };
-
-    admin(path('adminPublish')).post(guard(async (req, res) => {
-        const { document, notes, publish, strict, createdBy } = req.body || {};
-        const out = await new PublishDefinitionVersion({ repository: repository(), manifests, isReserved: (id) => registeredNames.has(id) }).execute({ document, notes, createdBy, publish: publish !== false, strict: Boolean(strict) });
-        const { document: _omit, ...version } = out.version;
-        res.status(out.created ? 201 : 200).json({ ...out, version });
-    }));
-    admin(path('adminVersions')).get(guard(async (req, res) => {
-        res.json({ versions: await new GetDefinitionHistory({ repository: repository() }).execute({ definitionId: req.params.definitionId }) });
-    }));
-    admin(path('adminDeprecate')).post(guard(async (req, res) => {
-        const row = await new DeprecateDefinitionVersion({ repository: repository() }).execute(req.params);
-        const { document: _omit, ...version } = row;
-        res.json({ version });
-    }));
-    return true;
-}
-
-module.exports = { setIntegrationRuntimeRoutes, DEFINITION_ROUTES };