@ganju/utils 0.0.17 → 0.0.18

package/dist/dataTriggers.js

@@ -0,0 +1,760 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renameColumnInTriggers = exports.triggersUsingColumn = exports.clearOutbox = exports.outboxSize = exports.deleteOutbox = exports.readOutbox = exports.collectTriggerEvents = exports.ensureChangeCapture = exports.changeCaptureTriggers = exports.replaceManagedTriggers = exports.setTriggerEnabled = exports.dropTrigger = exports.saveTrigger = exports.getTrigger = exports.listTriggers = exports.normaliseTrigger = exports.renderTriggerText = exports.conditionMatches = exports.utf8Bytes = exports.DATA_TRIGGER_MAX_MESSAGE_BYTES = exports.DATA_TRIGGER_MAX_ROW_BYTES = exports.DATA_OUTBOX_BATCH = exports.DATA_TRIGGER_MAX_EMAILS = exports.DATA_TRIGGER_MAX_TEXT = exports.DATA_TRIGGER_MAX_RATE = exports.DATA_TRIGGER_DEFAULT_RATE = exports.DATA_TRIGGER_MAX_DEPTH = exports.DATA_MAX_TRIGGERS = exports.DATA_TRIGGER_ACTIONS = exports.DATA_TRIGGER_EVENTS = void 0;
+const dataCompiler_1 = require("./dataCompiler");
+const dataTypes_1 = require("./dataTypes");
+exports.DATA_TRIGGER_EVENTS = ['insert', 'update', 'delete'];
+exports.DATA_TRIGGER_ACTIONS = [
+    'function',
+    'webhook',
+    'chat',
+    'email',
+    'customer'
+];
+exports.DATA_MAX_TRIGGERS = 50;
+// A chain of triggers (a triggered function's write firing another trigger)
+// stops at this depth with a visible error.
+exports.DATA_TRIGGER_MAX_DEPTH = 3;
+// Runs a minute per trigger; past it, events wait in the queue.
+exports.DATA_TRIGGER_DEFAULT_RATE = 60;
+exports.DATA_TRIGGER_MAX_RATE = 600;
+exports.DATA_TRIGGER_MAX_TEXT = 2000;
+exports.DATA_TRIGGER_MAX_EMAILS = 10;
+// Conditions nest `all` / `any` this deep, with this many tests in all.
+const MAX_CONDITION_DEPTH = 4;
+const MAX_CONDITION_TESTS = 20;
+// Events handed to the queue per alarm step, and the most of a row an event
+// carries: a queue message holds 128 KB, so a larger row is left out and the
+// receiver reads it by id. Sizes are UTF-8 bytes, not characters.
+exports.DATA_OUTBOX_BATCH = 100;
+exports.DATA_TRIGGER_MAX_ROW_BYTES = 48_000;
+exports.DATA_TRIGGER_MAX_MESSAGE_BYTES = 120_000;
+const encoder = new TextEncoder();
+const utf8Bytes = (value) => encoder.encode(typeof value === 'string' ? value : JSON.stringify(value))
+    .length;
+exports.utf8Bytes = utf8Bytes;
+const isPlainObject = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const NAME_PATTERN = /^[a-z][a-z0-9_-]{0,62}$/;
+const SYSTEM_FIELDS = [
+    'id',
+    'created_at',
+    'updated_at',
+    'version',
+    'created_by',
+    'updated_by',
+    'participant_id'
+];
+const isScalar = (value) => value === null ||
+    typeof value === 'string' ||
+    typeof value === 'boolean' ||
+    (typeof value === 'number' && Number.isFinite(value));
+// Conditions
+const TEST_KEYS = ['changedTo', 'changedFrom', 'changed', 'equals'];
+const normaliseCondition = (table, raw, depth = 0, count = { tests: 0 }) => {
+    if (!isPlainObject(raw) || Object.keys(raw).length === 0) {
+        throw new dataTypes_1.DataError('"when" is an object such as { "status": { "changedTo": "READY" } }.');
+    }
+    if (depth >= MAX_CONDITION_DEPTH) {
+        throw new dataTypes_1.DataError(`"when" nests all / any at most ${MAX_CONDITION_DEPTH} deep.`);
+    }
+    if ('all' in raw || 'any' in raw) {
+        const key = 'all' in raw ? 'all' : 'any';
+        if (Object.keys(raw).length !== 1 ||
+            !Array.isArray(raw[key]) ||
+            raw[key].length === 0) {
+            throw new dataTypes_1.DataError(`"${key}" is a non-empty list of conditions, alone in its object.`);
+        }
+        const list = raw[key].map(item => normaliseCondition(table, item, depth + 1, count));
+        return key === 'all' ? { all: list } : { any: list };
+    }
+    const out = {};
+    for (const [column, test] of Object.entries(raw)) {
+        if (!table.columns.some(c => c.name === column) &&
+            !SYSTEM_FIELDS.includes(column)) {
+            throw new dataTypes_1.DataError(`"when" names ${table.name}.${column}, which doesn't exist.`);
+        }
+        if (!isPlainObject(test) || Object.keys(test).length === 0) {
+            throw new dataTypes_1.DataError(`"when".${column} is a test: changedTo, changedFrom, changed or equals.`);
+        }
+        const clean = {};
+        for (const [key, value] of Object.entries(test)) {
+            if (!TEST_KEYS.includes(key)) {
+                throw new dataTypes_1.DataError(`"when".${column}.${key}: a test is changedTo, changedFrom, changed or equals.`);
+            }
+            if (key === 'changed') {
+                if (value !== true)
+                    throw new dataTypes_1.DataError(`"when".${column}.changed is true.`);
+                clean.changed = true;
+            }
+            else {
+                if (!isScalar(value)) {
+                    throw new dataTypes_1.DataError(`"when".${column}.${key} is a text, number, true / false or null.`);
+                }
+                clean[key] = value;
+            }
+            if (++count.tests > MAX_CONDITION_TESTS) {
+                throw new dataTypes_1.DataError(`"when" holds at most ${MAX_CONDITION_TESTS} tests.`);
+            }
+        }
+        out[column] = clean;
+    }
+    return out;
+};
+// Values compare as JSON, so 3 and 3.0 match and "3" doesn't.
+const same = (a, b) => JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+/**
+ * Whether a change matches a condition. A missing side counts as all null:
+ * an insert "changed to" the values it was created with, and a delete
+ * "changed from" the values it had. `equals` tests the row after the change,
+ * or the deleted row.
+ */
+const conditionMatches = (when, row, previous) => {
+    if (!when)
+        return true;
+    if ('all' in when && Array.isArray(when.all)) {
+        return when.all.every(c => (0, exports.conditionMatches)(c, row, previous));
+    }
+    if ('any' in when && Array.isArray(when.any)) {
+        return when.any.some(c => (0, exports.conditionMatches)(c, row, previous));
+    }
+    const after = row ?? {};
+    const before = previous ?? {};
+    const current = row ?? previous ?? {};
+    return Object.entries(when).every(([column, test]) => {
+        const now = after[column] ?? null;
+        const then = before[column] ?? null;
+        if (test.changed && same(now, then))
+            return false;
+        if ('changedTo' in test &&
+            !(same(now, test.changedTo) && !same(then, test.changedTo))) {
+            return false;
+        }
+        if ('changedFrom' in test &&
+            !(same(then, test.changedFrom) && !same(now, test.changedFrom))) {
+            return false;
+        }
+        if ('equals' in test && !same(current[column] ?? null, test.equals))
+            return false;
+        return true;
+    });
+};
+exports.conditionMatches = conditionMatches;
+// Templates
+/**
+ * A message built from a row: each {{field}} becomes that field's value as
+ * plain text. Never markup: the row is customer-written content, and the
+ * senders send it as text.
+ */
+const renderTriggerText = (text, row) => text.replace(/\{\{\s*([a-z][a-z0-9_]*)\s*\}\}/g, (_, field) => {
+    const value = row?.[field];
+    if (value === null || value === undefined)
+        return '';
+    return typeof value === 'object' ? JSON.stringify(value) : String(value);
+});
+exports.renderTriggerText = renderTriggerText;
+const templateFields = (text) => [...text.matchAll(/\{\{\s*([a-z][a-z0-9_]*)\s*\}\}/g)].map(m => m[1]);
+// Definitions
+const cleanText = (value, label, max = exports.DATA_TRIGGER_MAX_TEXT) => {
+    if (typeof value !== 'string' || !value.trim())
+        throw new dataTypes_1.DataError(`${label} is required.`);
+    if (value.length > max)
+        throw new dataTypes_1.DataError(`${label} is at most ${max} characters.`);
+    return value.trim();
+};
+const assertFields = (table, text, label) => {
+    for (const field of templateFields(text)) {
+        if (!table.columns.some(c => c.name === field) &&
+            !SYSTEM_FIELDS.includes(field)) {
+            throw new dataTypes_1.DataError(`${label} uses {{${field}}}, which isn't a column of ${table.name}.`);
+        }
+    }
+};
+const normaliseAction = (table, input) => {
+    const given = exports.DATA_TRIGGER_ACTIONS.filter(key => input[key] !== undefined && input[key] !== null);
+    if (given.length !== 1) {
+        throw new dataTypes_1.DataError('A trigger runs one thing: "function", "webhook", "chat", "email" or "customer".');
+    }
+    const type = given[0];
+    const value = input[type];
+    switch (type) {
+        case 'function':
+            if (typeof value !== 'string' || !/^[a-zA-Z0-9_-]{1,64}$/.test(value)) {
+                throw new dataTypes_1.DataError('"function" is the name of one of this project\'s functions.');
+            }
+            return { type, function: value };
+        case 'webhook': {
+            if (typeof value !== 'string' || value.length > 2000) {
+                throw new dataTypes_1.DataError('"webhook" is an https URL.');
+            }
+            let url;
+            try {
+                url = new URL(value);
+            }
+            catch {
+                throw new dataTypes_1.DataError('"webhook" is an https URL.');
+            }
+            if (url.protocol !== 'https:')
+                throw new dataTypes_1.DataError('"webhook" must use https.');
+            return { type, url: url.toString() };
+        }
+        case 'chat': {
+            if (!isPlainObject(value)) {
+                throw new dataTypes_1.DataError('"chat" is { "channelId", "chatId", "text" }.');
+            }
+            const text = cleanText(value.text, '"chat.text"');
+            assertFields(table, text, '"chat.text"');
+            return {
+                type,
+                channelId: cleanText(value.channelId, '"chat.channelId"', 100),
+                chatId: cleanText(String(value.chatId ?? ''), '"chat.chatId"', 200),
+                text
+            };
+        }
+        case 'email': {
+            if (!isPlainObject(value))
+                throw new dataTypes_1.DataError('"email" is { "to", "subject", "text" }.');
+            const to = (Array.isArray(value.to) ? value.to : [value.to]).map(v => typeof v === 'string' ? v.trim().toLowerCase() : '');
+            if (to.length === 0 ||
+                to.length > exports.DATA_TRIGGER_MAX_EMAILS ||
+                to.some(v => !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v))) {
+                throw new dataTypes_1.DataError(`"email.to" is 1 to ${exports.DATA_TRIGGER_MAX_EMAILS} email addresses.`);
+            }
+            const text = cleanText(value.text, '"email.text"');
+            const subject = value.subject === undefined || value.subject === null
+                ? `${table.name}: {{id}}`
+                : cleanText(value.subject, '"email.subject"', 200);
+            assertFields(table, text, '"email.text"');
+            assertFields(table, subject, '"email.subject"');
+            return { type, to: [...new Set(to)], subject, text };
+        }
+        case 'customer': {
+            if (!table.customerScoped) {
+                throw new dataTypes_1.DataError(`"customer" messages the row's customer, so ${table.name} must be customer-scoped.`);
+            }
+            if (!isPlainObject(value))
+                throw new dataTypes_1.DataError('"customer" is { "text", "template"? }.');
+            const text = cleanText(value.text, '"customer.text"');
+            assertFields(table, text, '"customer.text"');
+            if (value.template === undefined || value.template === null)
+                return { type, text };
+            const t = value.template;
+            if (!isPlainObject(t)) {
+                throw new dataTypes_1.DataError('"customer.template" is { "name", "language", "params"? }.');
+            }
+            const params = t.params === undefined ? [] : t.params;
+            if (!Array.isArray(params) ||
+                params.length > 20 ||
+                !params.every(p => typeof p === 'string')) {
+                throw new dataTypes_1.DataError('"customer.template.params" is a list of texts.');
+            }
+            for (const param of params)
+                assertFields(table, param, '"customer.template.params"');
+            return {
+                type,
+                text,
+                template: {
+                    name: cleanText(t.name, '"customer.template.name"', 512),
+                    language: cleanText(t.language, '"customer.template.language"', 20),
+                    params: params
+                }
+            };
+        }
+    }
+};
+const defaultName = (table, on, action) => {
+    const target = action.type === 'function'
+        ? action.function.toLowerCase().replace(/[^a-z0-9_-]/g, '-')
+        : action.type;
+    return `${table}-${on}-${target}`.slice(0, 63);
+};
+const normaliseTrigger = (schema, input) => {
+    if (!isPlainObject(input))
+        throw new dataTypes_1.DataError('A trigger is an object.');
+    const table = schema.tables.find(t => t.name === input.table);
+    if (!table) {
+        throw new dataTypes_1.DataError(typeof input.table === 'string'
+            ? `There is no table named ${input.table}.`
+            : 'A trigger needs "table".', typeof input.table === 'string' ? 'not_found' : 'invalid');
+    }
+    const on = input.on;
+    if (!exports.DATA_TRIGGER_EVENTS.includes(on)) {
+        throw new dataTypes_1.DataError('"on" is insert, update or delete.');
+    }
+    const action = normaliseAction(table, input);
+    const unnamed = input.name === undefined || input.name === null;
+    const name = unnamed
+        ? defaultName(table.name, on, action)
+        : input.name;
+    if (typeof name !== 'string' || !NAME_PATTERN.test(name)) {
+        throw new dataTypes_1.DataError("A trigger's name is lowercase letters, digits, _ and -, starting with a letter.");
+    }
+    const rate = input.rateLimit ?? exports.DATA_TRIGGER_DEFAULT_RATE;
+    if (typeof rate !== 'number' ||
+        !Number.isInteger(rate) ||
+        rate < 1 ||
+        rate > exports.DATA_TRIGGER_MAX_RATE) {
+        throw new dataTypes_1.DataError(`"rateLimit" is 1 to ${exports.DATA_TRIGGER_MAX_RATE} runs a minute.`);
+    }
+    if (input.enabled !== undefined && typeof input.enabled !== 'boolean') {
+        throw new dataTypes_1.DataError('"enabled" is true or false.');
+    }
+    if (input.replace !== undefined && typeof input.replace !== 'boolean') {
+        throw new dataTypes_1.DataError('"replace" is true or false.');
+    }
+    return {
+        name,
+        defaultName: unnamed,
+        description: typeof input.description === 'string' && input.description.trim()
+            ? input.description.trim().slice(0, dataTypes_1.DATA_MAX_DESCRIPTION)
+            : null,
+        table,
+        on: on,
+        when: input.when === undefined || input.when === null
+            ? null
+            : normaliseCondition(table, input.when),
+        action,
+        enabled: typeof input.enabled === 'boolean' ? input.enabled : null,
+        replace: input.replace !== false,
+        rateLimit: rate
+    };
+};
+exports.normaliseTrigger = normaliseTrigger;
+// The default name, numbered past the names already taken: two unnamed
+// triggers on the same event never replace each other.
+const freeName = (runner, base) => {
+    const taken = new Set(runner.all('SELECT name FROM _ganju_triggers').map(row => String(row.name)));
+    if (!taken.has(base))
+        return base;
+    for (let n = 2;; n++) {
+        const suffix = `-${n}`;
+        const name = `${base.slice(0, 63 - suffix.length)}${suffix}`;
+        if (!taken.has(name))
+            return name;
+    }
+};
+const parse = (value) => {
+    if (typeof value !== 'string')
+        return null;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+};
+const toTrigger = (schema, row) => ({
+    id: String(row.id),
+    name: String(row.name),
+    description: row.description ?? null,
+    table: schema.tables.find(t => t.id === Number(row.table_id))?.name ?? '',
+    on: row.event,
+    when: parse(row.condition),
+    action: parse(row.action),
+    enabled: row.enabled === 1,
+    disabledReason: row.disabled_reason ?? null,
+    managed: row.managed === 'cli' ? 'cli' : null,
+    rateLimit: Number(row.rate_limit),
+    createdAt: String(row.created_at),
+    updatedAt: String(row.updated_at),
+    updatedBy: row.updated_by ?? null
+});
+const listTriggers = (runner, schema) => runner
+    .all('SELECT * FROM _ganju_triggers ORDER BY name')
+    .map(row => toTrigger(schema, row));
+exports.listTriggers = listTriggers;
+const findRow = (runner, nameOrId) => {
+    const row = runner.all('SELECT * FROM _ganju_triggers WHERE name = ? OR id = ?', [String(nameOrId), String(nameOrId)])[0];
+    if (!row)
+        throw new dataTypes_1.DataError(`There is no trigger named ${String(nameOrId)}.`, 'not_found');
+    return row;
+};
+const getTrigger = (runner, schema, nameOrId) => {
+    const row = findRow(runner, nameOrId);
+    return {
+        ...toTrigger(schema, row),
+        secret: row.secret ?? null
+    };
+};
+exports.getTrigger = getTrigger;
+const newSecret = () => {
+    const bytes = new Uint8Array(24);
+    crypto.getRandomValues(bytes);
+    return `whsec_${Array.from(bytes, b => b.toString(16).padStart(2, '0')).join('')}`;
+};
+const upsert = (runner, schema, caller, trigger, managed) => {
+    const existing = runner.all('SELECT * FROM _ganju_triggers WHERE name = ?', [
+        trigger.name
+    ])[0];
+    if (existing && !trigger.replace) {
+        throw new dataTypes_1.DataError(`A trigger named ${trigger.name} already exists; give this one another name.`, 'conflict');
+    }
+    if (existing && (existing.managed === 'cli') !== (managed === 'cli')) {
+        throw new dataTypes_1.DataError(existing.managed === 'cli'
+            ? `${trigger.name} is deployed from ganju.json; change it there.`
+            : `A trigger named ${trigger.name} was made in the dashboard; give this one another name.`, 'conflict');
+    }
+    if (!existing) {
+        const count = Number(runner.all('SELECT count(*) AS n FROM _ganju_triggers')[0]?.n ?? 0);
+        if (count >= exports.DATA_MAX_TRIGGERS) {
+            throw new dataTypes_1.DataError(`A database holds up to ${exports.DATA_MAX_TRIGGERS} triggers.`);
+        }
+    }
+    // A webhook keeps its secret while it stays a webhook.
+    const keep = existing?.secret && trigger.action.type === 'webhook'
+        ? String(existing.secret)
+        : null;
+    const secret = trigger.action.type === 'webhook' ? (keep ?? newSecret()) : null;
+    const id = existing
+        ? String(existing.id)
+        : `trg_${crypto.randomUUID().replace(/-/g, '')}`;
+    // Left out, "enabled" keeps the trigger as it was, and why Ganju turned it
+    // off: a deploy doesn't turn back on what the dashboard or Ganju turned off.
+    const enabled = trigger.enabled ?? (existing ? existing.enabled === 1 : true);
+    const reason = enabled
+        ? null
+        : (existing?.disabled_reason ?? null);
+    runner.all(`INSERT INTO _ganju_triggers (id, name, description, table_id, event, condition, action, enabled, disabled_reason, managed, rate_limit, secret, updated_at, updated_by)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'), ?)
+     ON CONFLICT(id) DO UPDATE SET name = excluded.name, description = excluded.description,
+       table_id = excluded.table_id, event = excluded.event, condition = excluded.condition,
+       action = excluded.action, enabled = excluded.enabled, disabled_reason = excluded.disabled_reason,
+       managed = excluded.managed, rate_limit = excluded.rate_limit, secret = excluded.secret,
+       updated_at = excluded.updated_at, updated_by = excluded.updated_by`, [
+        id,
+        trigger.name,
+        trigger.description,
+        trigger.table.id,
+        trigger.on,
+        trigger.when ? JSON.stringify(trigger.when) : null,
+        JSON.stringify(trigger.action),
+        enabled ? 1 : 0,
+        reason,
+        managed,
+        trigger.rateLimit,
+        secret,
+        caller.actor
+    ]);
+    (0, exports.ensureChangeCapture)(runner, trigger.table);
+    const saved = toTrigger(schema, findRow(runner, id));
+    return secret && secret !== keep
+        ? { trigger: saved, secret }
+        : { trigger: saved };
+};
+const saveTrigger = (runner, schema, caller, input) => runner.transaction(() => {
+    const trigger = (0, exports.normaliseTrigger)(schema, input);
+    if (trigger.defaultName)
+        trigger.name = freeName(runner, trigger.name);
+    return upsert(runner, schema, caller, trigger, null);
+});
+exports.saveTrigger = saveTrigger;
+const dropTrigger = (runner, nameOrId) => {
+    const row = findRow(runner, nameOrId);
+    runner.all('DELETE FROM _ganju_triggers WHERE id = ?', [row.id]);
+    return { dropped: String(row.name) };
+};
+exports.dropTrigger = dropTrigger;
+// On / off, by the owner or by Ganju after failures in a row (with why).
+const setTriggerEnabled = (runner, schema, caller, nameOrId, enabled, reason = null) => {
+    const row = findRow(runner, nameOrId);
+    runner.all(`UPDATE _ganju_triggers SET enabled = ?, disabled_reason = ?, updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now'), updated_by = ? WHERE id = ?`, [enabled ? 1 : 0, enabled ? null : reason, caller.actor, row.id]);
+    if (enabled) {
+        const table = schema.tables.find(t => t.id === Number(row.table_id));
+        if (table)
+            (0, exports.ensureChangeCapture)(runner, table);
+    }
+    return toTrigger(schema, findRow(runner, row.id));
+};
+exports.setTriggerEnabled = setTriggerEnabled;
+/**
+ * The triggers ganju.json deploys: each one saved, and every other trigger
+ * the CLI deployed before removed. Those made in the dashboard stay. One
+ * transaction, so a bad entry changes nothing.
+ */
+const replaceManagedTriggers = (runner, schema, caller, inputs) => {
+    if (!Array.isArray(inputs) || inputs.length > exports.DATA_MAX_TRIGGERS) {
+        throw new dataTypes_1.DataError(`"triggers" is a list of up to ${exports.DATA_MAX_TRIGGERS} triggers.`);
+    }
+    return runner.transaction(() => {
+        const normalised = inputs.map((input, i) => {
+            try {
+                return (0, exports.normaliseTrigger)(schema, input);
+            }
+            catch (error) {
+                if (error instanceof dataTypes_1.DataError) {
+                    throw new dataTypes_1.DataError(`Trigger ${i}: ${error.message}`, error.code, error.details);
+                }
+                throw error;
+            }
+        });
+        const names = new Set();
+        for (const trigger of normalised) {
+            if (names.has(trigger.name)) {
+                throw new dataTypes_1.DataError(`Two triggers are named ${trigger.name}; give each a "name" of its own.`);
+            }
+            names.add(trigger.name);
+        }
+        const removed = [];
+        for (const row of runner.all("SELECT id, name FROM _ganju_triggers WHERE managed = 'cli'")) {
+            if (names.has(String(row.name)))
+                continue;
+            runner.all('DELETE FROM _ganju_triggers WHERE id = ?', [row.id]);
+            removed.push(String(row.name));
+        }
+        const secrets = {};
+        const triggers = normalised.map(trigger => {
+            const saved = upsert(runner, schema, caller, trigger, 'cli');
+            if (saved.secret)
+                secrets[saved.trigger.name] = saved.secret;
+            return saved.trigger;
+        });
+        return { triggers, removed, secrets };
+    });
+};
+exports.replaceManagedTriggers = replaceManagedTriggers;
+// Change capture
+const jsonRowSql = (table, side) => {
+    const fields = [...SYSTEM_FIELDS, ...table.columns.map(c => c.name)];
+    // json_set takes its arguments in pairs, and SQLite caps a function at 127
+    // arguments, so wide tables are built in pieces.
+    let out = "'{}'";
+    for (let i = 0; i < fields.length; i += 50) {
+        const pairs = fields
+            .slice(i, i + 50)
+            .map(f => `'$."${f}"', ${side}."${f}"`)
+            .join(', ');
+        out = `json_set(${out}, ${pairs})`;
+    }
+    return out;
+};
+/**
+ * The SQLite triggers that copy a table's changed rows into _ganju_changes.
+ * Each runs only while an enabled trigger of the owner's listens for that
+ * event on the table. Named like the table's other triggers, so they are
+ * dropped and remade with them when its columns change.
+ */
+const changeCaptureTriggers = (table) => {
+    const t = `"${table.name}"`;
+    const prefix = `tr_${table.id}_`;
+    const listening = (event) => `EXISTS (SELECT 1 FROM _ganju_triggers WHERE table_id = ${table.id} AND event = '${event}' AND enabled = 1)`;
+    const capture = (event, rowId, oldJson, newJson) => `INSERT INTO _ganju_changes (table_id, event, row_id, actor, old, new) VALUES (${table.id}, '${event}', ${rowId}, (SELECT actor FROM _ganju_context WHERE id = 1), ${oldJson}, ${newJson})`;
+    const full = table;
+    return [
+        {
+            name: `${prefix}ev_ai`,
+            sql: `CREATE TRIGGER IF NOT EXISTS "${prefix}ev_ai" AFTER INSERT ON ${t} WHEN ${listening('insert')} BEGIN ${capture('insert', 'new.id', 'NULL', jsonRowSql(full, 'new'))}; END`
+        },
+        {
+            name: `${prefix}ev_au`,
+            sql: `CREATE TRIGGER IF NOT EXISTS "${prefix}ev_au" AFTER UPDATE ON ${t} WHEN ${listening('update')} BEGIN ${capture('update', 'new.id', jsonRowSql(full, 'old'), jsonRowSql(full, 'new'))}; END`
+        },
+        {
+            name: `${prefix}ev_ad`,
+            sql: `CREATE TRIGGER IF NOT EXISTS "${prefix}ev_ad" AFTER DELETE ON ${t} WHEN ${listening('delete')} BEGIN ${capture('delete', 'old.id', jsonRowSql(full, 'old'), 'NULL')}; END`
+        }
+    ];
+};
+exports.changeCaptureTriggers = changeCaptureTriggers;
+// Tables made before triggers existed have no capture triggers until their
+// columns next change; the first trigger on one adds them.
+const ensureChangeCapture = (runner, table) => {
+    for (const trigger of (0, exports.changeCaptureTriggers)(table))
+        runner.all(trigger.sql);
+};
+exports.ensureChangeCapture = ensureChangeCapture;
+const shape = (table, raw) => {
+    const stored = parse(raw);
+    if (!stored)
+        return null;
+    const out = {};
+    for (const field of SYSTEM_FIELDS)
+        out[field] = stored[field] ?? null;
+    for (const column of table.columns) {
+        out[column.name] = (0, dataCompiler_1.fromStored)(column, stored[column.name] ?? null);
+    }
+    if (!table.customerScoped)
+        delete out.participant_id;
+    return out;
+};
+const DEPTH_PATTERN = /^trigger:([^\s]+)$/;
+/**
+ * Turns the changes a write captured into events, inside the write's
+ * transaction. A trigger never matches the writes of a run it started
+ * (actor `trigger:<id>`), and a chain stops at DATA_TRIGGER_MAX_DEPTH with
+ * an event that only records why. Returns how many events were stored.
+ */
+const collectTriggerEvents = (runner, schema, caller) => {
+    const changes = runner.all('SELECT * FROM _ganju_changes ORDER BY id');
+    if (changes.length === 0)
+        return 0;
+    runner.all('DELETE FROM _ganju_changes');
+    const artifactId = runner.all("SELECT value FROM _ganju_meta WHERE key = 'artifact_id'")[0]
+        ?.value ?? null;
+    const triggers = runner
+        .all('SELECT * FROM _ganju_triggers WHERE enabled = 1')
+        .map(row => toTrigger(schema, row));
+    const ownTrigger = DEPTH_PATTERN.exec(caller.actor)?.[1] ?? null;
+    const depth = (caller.triggerDepth ?? 0) + 1;
+    let stored = 0;
+    for (const change of changes) {
+        const table = schema.tables.find(t => t.id === Number(change.table_id));
+        if (!table)
+            continue;
+        const event = change.event;
+        const listening = triggers.filter(t => t.table === table.name && t.on === event);
+        if (listening.length === 0)
+            continue;
+        const row = shape(table, change.new);
+        const previous = shape(table, change.old);
+        for (const trigger of listening) {
+            if (trigger.id === ownTrigger)
+                continue;
+            if (!(0, exports.conditionMatches)(trigger.when, row, previous))
+                continue;
+            const message = {
+                eventId: `evt_${crypto.randomUUID().replace(/-/g, '')}`,
+                artifactId: artifactId ?? '',
+                triggerId: trigger.id,
+                triggerName: trigger.name,
+                table: table.name,
+                event,
+                rowId: Number(change.row_id),
+                row,
+                previous,
+                actor: change.actor ?? null,
+                depth,
+                at: new Date().toISOString()
+            };
+            if (depth > exports.DATA_TRIGGER_MAX_DEPTH) {
+                message.row = null;
+                message.previous = null;
+                message.error = `Not run: a chain of triggers stops at depth ${exports.DATA_TRIGGER_MAX_DEPTH} (this change was made by ${caller.actor}).`;
+            }
+            else if ((0, exports.utf8Bytes)([row, previous]) > exports.DATA_TRIGGER_MAX_ROW_BYTES) {
+                message.row = null;
+                message.previous = null;
+                message.truncated = true;
+            }
+            runner.all('INSERT INTO _ganju_outbox (id, trigger_id, message) VALUES (?, ?, ?)', [message.eventId, trigger.id, JSON.stringify(message)]);
+            stored++;
+        }
+    }
+    return stored;
+};
+exports.collectTriggerEvents = collectTriggerEvents;
+// The outbox, oldest first, for the alarm to hand to the queue.
+const readOutbox = (runner, limit = exports.DATA_OUTBOX_BATCH) => runner
+    .all('SELECT seq, message FROM _ganju_outbox ORDER BY seq LIMIT ?', [limit])
+    .map(row => ({
+    seq: Number(row.seq),
+    message: JSON.parse(String(row.message))
+}));
+exports.readOutbox = readOutbox;
+const deleteOutbox = (runner, throughSeq) => {
+    runner.all('DELETE FROM _ganju_outbox WHERE seq <= ?', [throughSeq]);
+};
+exports.deleteOutbox = deleteOutbox;
+const outboxSize = (runner) => Number(runner.all('SELECT count(*) AS n FROM _ganju_outbox')[0]?.n ?? 0);
+exports.outboxSize = outboxSize;
+// After a restore: events pending at the restored moment were sent then.
+// Those stored before `before` came back with the restore; later ones are
+// writes made since, and stay.
+const clearOutbox = (runner, before) => {
+    const n = Number(runner.all('SELECT count(*) AS n FROM _ganju_outbox WHERE created_at < ?', [
+        before
+    ])[0]?.n ?? 0);
+    runner.all('DELETE FROM _ganju_outbox WHERE created_at < ?', [before]);
+    runner.all('DELETE FROM _ganju_changes');
+    return n;
+};
+exports.clearOutbox = clearOutbox;
+const conditionColumns = (condition) => {
+    if (!isPlainObject(condition))
+        return [];
+    if (Array.isArray(condition.all))
+        return condition.all.flatMap(conditionColumns);
+    if (Array.isArray(condition.any))
+        return condition.any.flatMap(conditionColumns);
+    return Object.keys(condition);
+};
+const actionTexts = (action) => {
+    switch (action?.type) {
+        case 'chat':
+            return [action.text];
+        case 'email':
+            return [action.subject, action.text];
+        case 'customer':
+            return [action.text, ...(action.template?.params ?? [])];
+        default:
+            return [];
+    }
+};
+/**
+ * The triggers whose condition or {{field}} texts name a column. Dropping it
+ * is refused while any does, since they are only checked when saved and
+ * would quietly stop matching.
+ */
+const triggersUsingColumn = (runner, tableId, column) => runner
+    .all('SELECT name, condition, action FROM _ganju_triggers WHERE table_id = ? ORDER BY name', [tableId])
+    .filter(row => conditionColumns(parse(row.condition)).includes(column) ||
+    actionTexts(parse(row.action)).some(text => templateFields(text).includes(column)))
+    .map(row => String(row.name));
+exports.triggersUsingColumn = triggersUsingColumn;
+const renameInCondition = (condition, from, to) => {
+    if (!isPlainObject(condition))
+        return condition;
+    if (Array.isArray(condition.all))
+        return { all: condition.all.map(c => renameInCondition(c, from, to)) };
+    if (Array.isArray(condition.any))
+        return { any: condition.any.map(c => renameInCondition(c, from, to)) };
+    return Object.fromEntries(Object.entries(condition).map(([key, test]) => [
+        key === from ? to : key,
+        test
+    ]));
+};
+const renameInText = (text, from, to) => text.replace(/\{\{\s*([a-z][a-z0-9_]*)\s*\}\}/g, (match, field) => field === from ? `{{${to}}}` : match);
+const renameInAction = (action, from, to) => {
+    const r = (text) => renameInText(text, from, to);
+    switch (action.type) {
+        case 'chat':
+            return { ...action, text: r(action.text) };
+        case 'email':
+            return { ...action, subject: r(action.subject), text: r(action.text) };
+        case 'customer':
+            return {
+                ...action,
+                text: r(action.text),
+                ...(action.template
+                    ? {
+                        template: {
+                            ...action.template,
+                            params: action.template.params?.map(r)
+                        }
+                    }
+                    : {})
+            };
+        default:
+            return action;
+    }
+};
+/**
+ * A renamed column, renamed in the triggers that use it too, inside the
+ * rename's transaction. Those deployed from ganju.json then differ from the
+ * file until it is changed to match. Returns the triggers changed.
+ */
+const renameColumnInTriggers = (runner, tableId, from, to) => {
+    const names = (0, exports.triggersUsingColumn)(runner, tableId, from);
+    for (const name of names) {
+        const row = runner.all('SELECT id, condition, action FROM _ganju_triggers WHERE name = ?', [name])[0];
+        const condition = parse(row.condition);
+        const action = parse(row.action);
+        runner.all(`UPDATE _ganju_triggers SET condition = ?, action = ?, updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now') WHERE id = ?`, [
+            condition === null
+                ? null
+                : JSON.stringify(renameInCondition(condition, from, to)),
+            action ? JSON.stringify(renameInAction(action, from, to)) : row.action,
+            row.id
+        ]);
+    }
+    return names;
+};
+exports.renameColumnInTriggers = renameColumnInTriggers;