@amalgm/automations 0.2.0 → 0.2.2

package/dist/src/run-journal.js

@@ -0,0 +1,56 @@
+export function emptyJournal() {
+    return { version: 1, steps: [] };
+}
+export function runJournal(value, plan) {
+    if (value === undefined)
+        return emptyJournal();
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Run step journal is invalid');
+    const source = value;
+    if (source.version !== 1 || !Array.isArray(source.steps))
+        throw new Error('Run step journal is invalid');
+    const planIds = new Set(plan.map(({ id }) => id));
+    const steps = source.steps.map(runStep);
+    const ids = new Set();
+    for (const step of steps) {
+        if (!planIds.has(step.id))
+            throw new Error(`Run step is not in the immutable plan: ${step.id}`);
+        if (ids.has(step.id))
+            throw new Error(`Run step journal has a duplicate id: ${step.id}`);
+        ids.add(step.id);
+    }
+    return { version: 1, steps };
+}
+export function completed(journal, stepId) {
+    return journal.steps.some((step) => step.id === stepId && step.status === 'completed');
+}
+export function stepAttempt(journal, stepId) {
+    return journal.steps.find((step) => step.id === stepId)?.attempts ?? 0;
+}
+export function putStep(journal, step) {
+    const index = journal.steps.findIndex(({ id }) => id === step.id);
+    const steps = [...journal.steps];
+    if (index === -1)
+        steps.push(step);
+    else
+        steps[index] = step;
+    return { version: 1, steps };
+}
+/** Journals are constructed from JSON fields only; this is the persistence boundary. */
+export function journalJson(journal) {
+    return journal;
+}
+function runStep(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Run step is invalid');
+    const item = value;
+    if (typeof item.id !== 'string' || !item.id)
+        throw new Error('Run step id is invalid');
+    if (item.status !== 'running' && item.status !== 'completed' && item.status !== 'failed') {
+        throw new Error(`Run step status is invalid: ${item.id}`);
+    }
+    if (!Number.isInteger(item.attempts) || Number(item.attempts) < 1 || typeof item.startedAt !== 'string') {
+        throw new Error(`Run step attempt is invalid: ${item.id}`);
+    }
+    return item;
+}

package/dist/src/runner.d.ts

@@ -0,0 +1,14 @@
+import type { ClaimedAutomationRun, MachineRuns } from './machine.js';
+export interface AutomationMachineRunnerOptions {
+    readonly runs: MachineRuns;
+    readonly execute: (run: ClaimedAutomationRun) => Promise<void>;
+    readonly batchSize?: number;
+    readonly leaseSeconds?: number;
+    readonly pollIntervalMs?: number;
+    readonly maxBackoffMs?: number;
+    readonly log?: (event: string, details?: Readonly<Record<string, unknown>>) => void;
+}
+export declare function createAutomationMachineRunner(options: AutomationMachineRunnerOptions): Readonly<{
+    start(): void;
+    close(): Promise<void>;
+}>;

package/dist/src/runner.js

@@ -0,0 +1,70 @@
+export function createAutomationMachineRunner(options) {
+    const batchSize = integer(options.batchSize ?? 8, 1, 20, 'batchSize');
+    const leaseSeconds = integer(options.leaseSeconds ?? 60, 30, 900, 'leaseSeconds');
+    const pollIntervalMs = integer(options.pollIntervalMs ?? 1_000, 1, 60_000, 'pollIntervalMs');
+    const maxBackoffMs = integer(options.maxBackoffMs ?? Math.max(30_000, pollIntervalMs), pollIntervalMs, 300_000, 'maxBackoffMs');
+    let active = null;
+    let timer = null;
+    let stopped = true;
+    let failures = 0;
+    let nextDelay = pollIntervalMs;
+    const schedule = (delay) => {
+        if (stopped)
+            return;
+        timer = setTimeout(drain, delay);
+        timer.unref?.();
+    };
+    const drain = () => {
+        if (stopped || active)
+            return active;
+        active = options.runs.claim({ limit: batchSize, leaseSeconds })
+            .then(async (runs) => {
+            failures = 0;
+            if (runs.length)
+                options.log?.('automations.claimed', { count: runs.length });
+            const settled = await Promise.allSettled(runs.map(options.execute));
+            settled.forEach((result) => {
+                if (result.status === 'rejected') {
+                    options.log?.('automations.run.failed', { error: safe(result.reason) });
+                }
+            });
+            nextDelay = runs.length === batchSize ? 0 : pollIntervalMs;
+        })
+            .catch((error) => {
+            failures += 1;
+            const delayMs = Math.min(maxBackoffMs, pollIntervalMs * (2 ** Math.min(failures - 1, 10)));
+            options.log?.('automations.poll.failed', { error: safe(error), retryInMs: delayMs });
+            nextDelay = delayMs;
+        })
+            .finally(() => {
+            active = null;
+            schedule(nextDelay);
+        });
+        return active;
+    };
+    return Object.freeze({
+        start() {
+            if (!stopped)
+                return;
+            stopped = false;
+            failures = 0;
+            void drain();
+        },
+        async close() {
+            stopped = true;
+            if (timer)
+                clearTimeout(timer);
+            timer = null;
+            await active;
+        },
+    });
+}
+function integer(value, minimum, maximum, name) {
+    if (!Number.isInteger(value) || value < minimum || value > maximum) {
+        throw new Error(`${name} must be an integer from ${minimum} to ${maximum}`);
+    }
+    return value;
+}
+function safe(error) {
+    return (error instanceof Error ? error.message : String(error)).replace(/[\r\n]+/g, ' ').slice(0, 500);
+}

package/dist/src/schema.d.ts

@@ -13,22 +13,22 @@ export declare const pageQuerySchema: z.ZodObject<{
 }>;
 export declare const createAutomationSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
-    targetId: z.ZodString;
+    targetId: z.ZodOptional<z.ZodString>;
     name: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     description: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     enabled: z.ZodOptional<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
-    id?: string | undefined;
-    targetId: string;
+    targetId?: string | undefined;
+    enabled?: boolean | undefined;
     name?: string | undefined;
+    id?: string | undefined;
     description?: string | undefined;
-    enabled?: boolean | undefined;
 }, {
-    id?: string | undefined;
-    targetId: string;
+    targetId?: string | undefined;
+    enabled?: boolean | undefined;
     name?: string | undefined;
+    id?: string | undefined;
     description?: string | undefined;
-    enabled?: boolean | undefined;
 }>;
 export declare const updateAutomationSchema: z.ZodEffects<z.ZodObject<{
     targetId: z.ZodOptional<z.ZodString>;
@@ -37,24 +37,24 @@ export declare const updateAutomationSchema: z.ZodEffects<z.ZodObject<{
     enabled: z.ZodOptional<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     targetId?: string | undefined;
+    enabled?: boolean | undefined;
     name?: string | null | undefined;
     description?: string | null | undefined;
-    enabled?: boolean | undefined;
 }, {
     targetId?: string | undefined;
+    enabled?: boolean | undefined;
     name?: string | null | undefined;
     description?: string | null | undefined;
-    enabled?: boolean | undefined;
 }>, {
     targetId?: string | undefined;
+    enabled?: boolean | undefined;
     name?: string | null | undefined;
     description?: string | null | undefined;
-    enabled?: boolean | undefined;
 }, {
     targetId?: string | undefined;
+    enabled?: boolean | undefined;
     name?: string | null | undefined;
     description?: string | null | undefined;
-    enabled?: boolean | undefined;
 }>;
 export declare const listAutomationsSchema: z.ZodObject<{
     limit: z.ZodOptional<z.ZodNumber>;
@@ -63,15 +63,15 @@ export declare const listAutomationsSchema: z.ZodObject<{
     targetId: z.ZodOptional<z.ZodString>;
     enabled: z.ZodOptional<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
-    limit?: number | undefined;
-    offset?: number | undefined;
     targetId?: string | undefined;
     enabled?: boolean | undefined;
-}, {
     limit?: number | undefined;
     offset?: number | undefined;
+}, {
     targetId?: string | undefined;
     enabled?: boolean | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
 }>;
 export declare const createScheduleTriggerSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
@@ -80,16 +80,16 @@ export declare const createScheduleTriggerSchema: z.ZodObject<{
     enabled: z.ZodOptional<z.ZodBoolean>;
     maxOccurrences: z.ZodOptional<z.ZodNumber>;
 }, "strict", z.ZodTypeAny, {
-    id?: string | undefined;
     cron: string;
-    timezone?: string | undefined;
     enabled?: boolean | undefined;
+    id?: string | undefined;
+    timezone?: string | undefined;
     maxOccurrences?: number | undefined;
 }, {
-    id?: string | undefined;
     cron: string;
-    timezone?: string | undefined;
     enabled?: boolean | undefined;
+    id?: string | undefined;
+    timezone?: string | undefined;
     maxOccurrences?: number | undefined;
 }>;
 export declare const updateScheduleTriggerSchema: z.ZodEffects<z.ZodObject<{
@@ -98,24 +98,24 @@ export declare const updateScheduleTriggerSchema: z.ZodEffects<z.ZodObject<{
     enabled: z.ZodOptional<z.ZodBoolean>;
     maxOccurrences: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, "strict", z.ZodTypeAny, {
+    enabled?: boolean | undefined;
     cron?: string | undefined;
     timezone?: string | undefined;
-    enabled?: boolean | undefined;
     maxOccurrences?: number | null | undefined;
 }, {
+    enabled?: boolean | undefined;
     cron?: string | undefined;
     timezone?: string | undefined;
-    enabled?: boolean | undefined;
     maxOccurrences?: number | null | undefined;
 }>, {
+    enabled?: boolean | undefined;
     cron?: string | undefined;
     timezone?: string | undefined;
-    enabled?: boolean | undefined;
     maxOccurrences?: number | null | undefined;
 }, {
+    enabled?: boolean | undefined;
     cron?: string | undefined;
     timezone?: string | undefined;
-    enabled?: boolean | undefined;
     maxOccurrences?: number | null | undefined;
 }>;
 export declare const createWebhookTriggerSchema: z.ZodObject<{
@@ -125,17 +125,17 @@ export declare const createWebhookTriggerSchema: z.ZodObject<{
     secret: z.ZodString;
     enabled: z.ZodOptional<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
-    id?: string | undefined;
-    source?: string | undefined;
-    event?: string | undefined;
     secret: string;
     enabled?: boolean | undefined;
-}, {
-    id?: string | undefined;
-    source?: string | undefined;
     event?: string | undefined;
+    source?: string | undefined;
+    id?: string | undefined;
+}, {
     secret: string;
     enabled?: boolean | undefined;
+    event?: string | undefined;
+    source?: string | undefined;
+    id?: string | undefined;
 }>;
 export declare const updateWebhookTriggerSchema: z.ZodEffects<z.ZodObject<{
     source: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
@@ -143,25 +143,25 @@ export declare const updateWebhookTriggerSchema: z.ZodEffects<z.ZodObject<{
     secret: z.ZodOptional<z.ZodString>;
     enabled: z.ZodOptional<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
-    source?: string | undefined;
+    enabled?: boolean | undefined;
     event?: string | undefined;
     secret?: string | undefined;
-    enabled?: boolean | undefined;
-}, {
     source?: string | undefined;
+}, {
+    enabled?: boolean | undefined;
     event?: string | undefined;
     secret?: string | undefined;
-    enabled?: boolean | undefined;
-}>, {
     source?: string | undefined;
+}>, {
+    enabled?: boolean | undefined;
     event?: string | undefined;
     secret?: string | undefined;
-    enabled?: boolean | undefined;
-}, {
     source?: string | undefined;
+}, {
+    enabled?: boolean | undefined;
     event?: string | undefined;
     secret?: string | undefined;
-    enabled?: boolean | undefined;
+    source?: string | undefined;
 }>;
 export declare const createWorkflowSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
@@ -171,17 +171,17 @@ export declare const createWorkflowSchema: z.ZodObject<{
     allowlist: z.ZodOptional<z.ZodType<Json, z.ZodTypeDef, Json>>;
     limits: z.ZodOptional<z.ZodType<Json, z.ZodTypeDef, Json>>;
 }, "strict", z.ZodTypeAny, {
-    id?: string | undefined;
-    name?: string | undefined;
     script: string;
+    name?: string | undefined;
     compiled?: Json | undefined;
+    id?: string | undefined;
     allowlist?: Json | undefined;
     limits?: Json | undefined;
 }, {
-    id?: string | undefined;
-    name?: string | undefined;
     script: string;
+    name?: string | undefined;
     compiled?: Json | undefined;
+    id?: string | undefined;
     allowlist?: Json | undefined;
     limits?: Json | undefined;
 }>;
@@ -193,26 +193,26 @@ export declare const updateWorkflowSchema: z.ZodEffects<z.ZodObject<{
     limits: z.ZodOptional<z.ZodNullable<z.ZodType<Json, z.ZodTypeDef, Json>>>;
 }, "strict", z.ZodTypeAny, {
     name?: string | null | undefined;
-    script?: string | undefined;
     compiled?: Json | undefined;
+    script?: string | undefined;
     allowlist?: Json | undefined;
     limits?: Json | undefined;
 }, {
     name?: string | null | undefined;
-    script?: string | undefined;
     compiled?: Json | undefined;
+    script?: string | undefined;
     allowlist?: Json | undefined;
     limits?: Json | undefined;
 }>, {
     name?: string | null | undefined;
-    script?: string | undefined;
     compiled?: Json | undefined;
+    script?: string | undefined;
     allowlist?: Json | undefined;
     limits?: Json | undefined;
 }, {
     name?: string | null | undefined;
-    script?: string | undefined;
     compiled?: Json | undefined;
+    script?: string | undefined;
     allowlist?: Json | undefined;
     limits?: Json | undefined;
 }>;
@@ -222,13 +222,13 @@ export declare const listRunsSchema: z.ZodObject<{
 } & {
     status: z.ZodOptional<z.ZodEnum<["pending", "sent", "running", "completed", "failed"]>>;
 }, "strict", z.ZodTypeAny, {
+    status?: "pending" | "sent" | "running" | "completed" | "failed" | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
-    status?: "completed" | "failed" | "pending" | "running" | "sent" | undefined;
 }, {
+    status?: "pending" | "sent" | "running" | "completed" | "failed" | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
-    status?: "completed" | "failed" | "pending" | "running" | "sent" | undefined;
 }>;
 export declare function parseCreateAutomation(value: unknown): CreateAutomation;
 export declare function parseUpdateAutomation(value: unknown): UpdateAutomation;

package/dist/src/schema.js

@@ -1,5 +1,6 @@
 import { z } from 'zod/v3';
 import { ValidationError } from './errors.js';
+import { compiledAutomationPlan } from './plan.js';
 import { IDENTIFIER } from './validation.js';
 const maxPageSize = 100;
 const identifierMessage = 'Identifier is invalid';
@@ -21,7 +22,7 @@ const jsonSchema = z.lazy(() => z.union([
 ]));
 export const createAutomationSchema = z.object({
     id: identifierSchema.optional(),
-    targetId: identifierSchema,
+    targetId: identifierSchema.optional(),
     name: text(500, 'Automation name').optional(),
     description: text(10_000, 'Automation description').optional(),
     enabled: z.boolean().optional(),
@@ -102,10 +103,16 @@ export function parseUpdateWebhookTrigger(value) {
     return parse(updateWebhookTriggerSchema, value);
 }
 export function parseCreateWorkflow(value) {
-    return parse(createWorkflowSchema, value);
+    const workflow = parse(createWorkflowSchema, value);
+    if (workflow.compiled !== undefined)
+        validateCompiledPlan(workflow.compiled);
+    return workflow;
 }
 export function parseUpdateWorkflow(value) {
-    return parse(updateWorkflowSchema, value);
+    const workflow = parse(updateWorkflowSchema, value);
+    if (workflow.compiled !== undefined && workflow.compiled !== null)
+        validateCompiledPlan(workflow.compiled);
+    return workflow;
 }
 export function parsePageQuery(value) {
     return parse(pageQuerySchema, value);
@@ -119,3 +126,11 @@ export function parse(schema, value) {
         return result.data;
     throw new ValidationError(result.error.issues[0]?.message || 'Input is invalid');
 }
+function validateCompiledPlan(value) {
+    try {
+        compiledAutomationPlan(value);
+    }
+    catch (error) {
+        throw new ValidationError(error instanceof Error ? error.message : String(error));
+    }
+}

package/dist/src/supabase-crud/mappers.js

@@ -58,6 +58,8 @@ export function run(row) {
         workflowId: row.workflow_id,
         targetId: row.target_id,
         status: row.status,
+        attempts: row.attempts,
+        ...(row.retry_at ? { retryAt: timestamp(row.retry_at) } : {}),
         input: row.input,
         createdAt: timestamp(row.created_at),
         ...(row.sent_at ? { sentAt: timestamp(row.sent_at) } : {}),

package/dist/src/supabase-crud/rows.d.ts

@@ -42,6 +42,8 @@ export type RunRow = {
     workflow_id: string;
     target_id: string;
     status: AutomationRun['status'];
+    attempts: number;
+    retry_at: Date | string | null;
     input: AutomationRun['input'];
     created_at: Date | string;
     sent_at: Date | string | null;

package/dist/src/supabase-machine.js

@@ -43,6 +43,7 @@ function run(row) {
         input: row.input,
         status: row.status,
         attempts: row.attempts,
+        ...(row.retry_at ? { retryAt: timestamp(row.retry_at) } : {}),
         leaseToken: row.lease_token,
         leaseExpiresAt: timestamp(row.lease_expires_at),
         createdAt: timestamp(row.created_at),
@@ -56,6 +57,7 @@ function run(row) {
 function update(value) {
     return {
         status: value.status,
+        ...(value.retryAt === undefined ? {} : { retryAt: value.retryAt }),
         ...(value.output === undefined ? {} : { output: value.output }),
         ...(value.error === undefined ? {} : { error: value.error }),
     };

package/dist/src/supabase-store.d.ts

@@ -1,4 +1,4 @@
-import type { AutomationStore, AutomationTarget, AutomationRun, DueCronTrigger, RunInput, RunUpdate, StoredEventTrigger } from './types.js';
+import type { AutomationStore, AutomationTarget, AutomationRun, DueCronTrigger, RunInput, StoredEventTrigger } from './types.js';
 export interface SupabaseRpcClient {
     rpc(functionName: string, arguments_: Record<string, unknown>): PromiseLike<{
         data: unknown;
@@ -17,7 +17,4 @@ export declare class SupabaseStore implements AutomationStore {
         kind: 'event';
     }>, now: Date): Promise<AutomationRun | null>;
     enqueueCron(trigger: DueCronTrigger, nextRunAt: string, now: Date): Promise<AutomationRun | null>;
-    pendingRuns(target: AutomationTarget): Promise<AutomationRun[]>;
-    markSent(runId: string, target: AutomationTarget, now: Date): Promise<boolean>;
-    updateRun(target: AutomationTarget, runId: string, update: RunUpdate): Promise<AutomationRun | null>;
 }

package/dist/src/supabase-store.js

@@ -61,30 +61,6 @@ export class SupabaseStore {
             scheduledFor: trigger.nextRunAt,
         }, now, nextRunAt);
     }
-    async pendingRuns(target) {
-        const rows = await this.#call('list_amalgm_pending_runs', {
-            p_user_id: target.userId,
-            p_target_id: target.targetId,
-        });
-        return rows.map(automationRun);
-    }
-    markSent(runId, target, now) {
-        return this.#call('mark_amalgm_run_sent', {
-            p_run_id: runId,
-            p_user_id: target.userId,
-            p_target_id: target.targetId,
-            p_now: now.toISOString(),
-        });
-    }
-    async updateRun(target, runId, update) {
-        const rows = await this.#call('update_amalgm_run', {
-            p_run_id: runId,
-            p_user_id: target.userId,
-            p_target_id: target.targetId,
-            p_update: update,
-        });
-        return rows[0] ? automationRun(rows[0]) : null;
-    }
     async #enqueue(trigger, input, now, nextRunAt) {
         const rows = await this.#call('enqueue_amalgm_run', {
             p_kind: trigger.kind,

package/dist/src/tool-surface.d.ts

@@ -0,0 +1,46 @@
+import type { Automation, AutomationCrud, AutomationRun, CreateAutomation, CreateScheduleTrigger, CreateWebhookTrigger, CreateWorkflow, ListAutomations, ListRuns, Page, Trigger, UpdateAutomation, UpdateScheduleTrigger, UpdateWebhookTrigger, UpdateWorkflow, Workflow } from './contract.js';
+export interface AutomationView {
+    automation: Automation;
+    triggers: Trigger[];
+    workflow: Workflow | null;
+    runs?: Page<AutomationRun>;
+}
+export interface CreateAutomationDefinition extends CreateAutomation {
+    schedules?: CreateScheduleTrigger[];
+    webhooks?: CreateWebhookTrigger[];
+    workflow?: CreateWorkflow;
+}
+interface Changes<Create extends {
+    id?: string;
+}, Update> {
+    create?: Create[];
+    update?: Array<{
+        id: string;
+        patch: Update;
+    }>;
+    delete?: string[];
+}
+export type WorkflowChange = {
+    create: CreateWorkflow;
+} | {
+    update: UpdateWorkflow;
+} | {
+    delete: true;
+};
+export interface UpdateAutomationDefinition {
+    patch?: UpdateAutomation;
+    schedules?: Changes<CreateScheduleTrigger, UpdateScheduleTrigger>;
+    webhooks?: Changes<CreateWebhookTrigger, UpdateWebhookTrigger>;
+    workflow?: WorkflowChange;
+}
+export interface AutomationToolSurface {
+    create(input: CreateAutomationDefinition): Promise<AutomationView>;
+    list(query?: ListAutomations): Promise<Page<Automation>>;
+    get(automationId: string, runs?: false | ListRuns): Promise<AutomationView>;
+    update(automationId: string, input: UpdateAutomationDefinition): Promise<AutomationView>;
+    delete(automationId: string): Promise<{
+        deleted: string;
+    }>;
+}
+export declare function createAutomationToolSurface(sdk: AutomationCrud): AutomationToolSurface;
+export {};