@fungi.computer/braid 0.0.0-stage → 0.1.0

package/dist/runtime/schedules.js

@@ -0,0 +1,149 @@
+import { z } from "zod";
+import * as Result from "effect/Result";
+import { afterAdmitted, afterRefused, isDue, nextOccurrence, occurrenceKey, paused, cancelled, } from "@fungi.computer/almanac";
+import { canonicalJson, contentDigest } from "../index.js";
+import { armedWorkflowTriggerSchema, workflowArmerKey, workflowTriggerControlledBy, workflowTriggerPrincipalMember, } from "./trigger-owner.js";
+import { storedTriggerRows } from "./stored-trigger-rows.js";
+const recordSchema = armedWorkflowTriggerSchema.extend({
+    id: z.string().min(1).max(256),
+    cron: z.strictObject({
+        expression: z.string().max(256),
+        timeZone: z.string().max(128),
+    }),
+    nextDueAt: z.number().int(),
+    state: z.enum(["active", "paused", "cancelled", "finished"]),
+    lastError: z.string().nullable(),
+    attempt: z.number().int().nonnegative(),
+    retryAt: z.number().int().nullable(),
+});
+const bindingOf = (record) => armedWorkflowTriggerSchema.strip().parse(record);
+/** Team-owned schedule records; Almanac alone decides occurrences and transitions. */
+export function createWorkflowSchedules(options) {
+    const { sql, reportFailure } = options;
+    sql.exec(`CREATE TABLE IF NOT EXISTS hub_workflow_schedules (scheduleId TEXT PRIMARY KEY, record TEXT NOT NULL) STRICT`);
+    const rows = storedTriggerRows(sql, {
+        table: "hub_workflow_schedules",
+        key: "scheduleId",
+        record: recordSchema,
+    });
+    const records = () => rows.all().map((record) => {
+        if (record.state !== "active")
+            return record;
+        const reason = options.triggers.refusal(bindingOf(record));
+        if (reason === null)
+            return record;
+        const next = { ...paused(record), lastError: reason, retryAt: null };
+        store(next);
+        return next;
+    });
+    const nextWake = () => {
+        const due = records()
+            .filter((record) => record.state === "active")
+            .map((record) => Math.max(record.nextDueAt, record.retryAt ?? record.nextDueAt));
+        return due.length === 0 ? null : Math.min(...due);
+    };
+    const store = (record) => {
+        const checked = recordSchema.parse(record);
+        sql.exec("INSERT INTO hub_workflow_schedules(scheduleId,record) VALUES(?,?) ON CONFLICT(scheduleId) DO UPDATE SET record=excluded.record", checked.id, JSON.stringify(checked));
+    };
+    return {
+        nextWake,
+        async arm(armer, target, computerId, installationAuthority) {
+            await options.authorize(armer.armedBy, target.installationId);
+            const armed = await options.triggers.arm(armer, target, computerId, installationAuthority);
+            if (armed.kind === "refused")
+                return armed;
+            if (armed.trigger.on !== "schedule")
+                return {
+                    kind: "refused",
+                    reason: "Workflow trigger is not a schedule",
+                };
+            const cron = armed.trigger.cron;
+            const next = nextOccurrence(cron, options.now());
+            if (Result.isFailure(next))
+                return { kind: "refused", reason: next.failure.message };
+            const id = await contentDigest([
+                "workflow-schedule",
+                ...workflowArmerKey(armer),
+                target.installationId,
+                target.workflowId,
+                target.triggerId,
+            ]);
+            await options.commit(() => {
+                const previous = records().find((record) => record.id === id);
+                if (previous !== undefined &&
+                    canonicalJson(z.json().parse(bindingOf(previous))) !==
+                        canonicalJson(z.json().parse(armed.binding)))
+                    options.triggers.disarm(bindingOf(previous));
+                store({
+                    ...armed.binding,
+                    id,
+                    cron,
+                    nextDueAt: next.success,
+                    state: "active",
+                    lastError: null,
+                    attempt: 0,
+                    retryAt: null,
+                });
+            });
+            await options.wake(nextWake());
+            return { kind: "armed", scheduleId: id };
+        },
+        async list(principal, installationId) {
+            await options.authorize(workflowTriggerPrincipalMember(principal), installationId);
+            return records()
+                .filter((record) => record.installationId === installationId)
+                .map((record) => ({
+                scheduleId: record.id,
+                workflowId: record.workflowId,
+                triggerId: record.triggerId,
+                nextDueAt: record.nextDueAt,
+                state: record.state,
+                lastError: record.lastError,
+            }));
+        },
+        async disarm(principal, installationId, scheduleId) {
+            const memberId = workflowTriggerPrincipalMember(principal);
+            await options.authorize(memberId, installationId);
+            const record = rows.read(scheduleId);
+            if (record === null)
+                return { kind: "not_found" };
+            if (record.installationId !== installationId ||
+                !workflowTriggerControlledBy(principal, record))
+                return { kind: "not_found" };
+            await options.commit(() => {
+                store(cancelled(record));
+                options.triggers.disarm(bindingOf(record));
+            });
+            await options.wake(nextWake());
+            return { kind: "disarmed" };
+        },
+        async fireDue() {
+            for (const record of records()) {
+                if (!isDue(record, options.now()) ||
+                    (record.retryAt !== null && record.retryAt > options.now()))
+                    continue;
+                const binding = bindingOf(record);
+                let next;
+                try {
+                    const result = await options.triggers.fire(binding, `${options.teamId()}/schedule/${record.id}`, {
+                        scheduledAt: new Date(record.nextDueAt).toISOString(),
+                        eventId: occurrenceKey(record),
+                    });
+                    next =
+                        result.kind === "refused"
+                            ? { ...paused(record), lastError: result.reason, retryAt: null }
+                            : { ...afterAdmitted(record, options.now()), retryAt: null };
+                }
+                catch (cause) {
+                    reportFailure({ source: "workflow_schedule_fire", cause });
+                    const refused = afterRefused(record, options.now(), "Workflow execution temporarily unavailable");
+                    next = { ...refused.schedule, retryAt: refused.retryAt };
+                }
+                // A disarm or re-arm admitted during upstream I/O wins over this firing.
+                sql.exec("UPDATE hub_workflow_schedules SET record=? WHERE scheduleId=? AND record=?", JSON.stringify(recordSchema.parse(next)), record.id, JSON.stringify(record));
+            }
+            await options.wake(nextWake());
+        },
+    };
+}

package/dist/runtime/stored-trigger-rows.d.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
+/** Stored trigger rows decode strictly; an undecodable row is corruption. */
+export declare function storedTriggerRows<Record extends z.ZodType>(sql: WatchdogSqliteOwner["sql"], table: Readonly<{
+    table: "hub_workflow_schedules" | "hub_workflow_event_triggers";
+    key: "scheduleId" | "id";
+    record: Record;
+}>): {
+    all: () => z.core.output<Record>[];
+    read(id: string): z.core.output<Record> | null;
+    remove(id: string): void;
+};

package/dist/runtime/stored-trigger-rows.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+const rowSchema = z.strictObject({ id: z.string(), record: z.string() });
+/** Stored trigger rows decode strictly; an undecodable row is corruption. */
+export function storedTriggerRows(sql, table) {
+    const select = `SELECT ${table.key} AS id, record FROM ${table.table}`;
+    const decode = (raw) => table.record.parse(JSON.parse(rowSchema.parse(raw).record));
+    return {
+        all: () => sql.exec(`${select} ORDER BY ${table.key}`).toArray().map(decode),
+        read(id) {
+            const row = sql.exec(`${select} WHERE ${table.key}=?`, id).toArray()[0];
+            return row === undefined ? null : decode(row);
+        },
+        remove(id) {
+            sql.exec(`DELETE FROM ${table.table} WHERE ${table.key}=?`, id);
+        },
+    };
+}