@amalgm/automations 0.1.0

package/dist/src/schema.js

@@ -0,0 +1,119 @@
+import { z } from 'zod/v3';
+import { ValidationError } from './errors.js';
+import { IDENTIFIER } from './validation.js';
+const maxPageSize = 100;
+const identifierMessage = 'Identifier is invalid';
+const text = (maximum, label) => z.string()
+    .max(maximum, `${label} is too long`)
+    .refine((value) => value.trim().length > 0, `${label} is required`);
+export const identifierSchema = z.string().regex(IDENTIFIER, identifierMessage);
+export const pageQuerySchema = z.object({
+    limit: z.number().int().min(1).max(maxPageSize).optional(),
+    offset: z.number().int().min(0).optional(),
+}).strict();
+const jsonSchema = z.lazy(() => z.union([
+    z.null(),
+    z.boolean(),
+    z.number().finite(),
+    z.string(),
+    z.array(jsonSchema),
+    z.record(jsonSchema),
+]));
+export const createAutomationSchema = z.object({
+    id: identifierSchema.optional(),
+    targetId: identifierSchema,
+    name: text(500, 'Automation name').optional(),
+    description: text(10_000, 'Automation description').optional(),
+    enabled: z.boolean().optional(),
+}).strict();
+export const updateAutomationSchema = z.object({
+    targetId: identifierSchema.optional(),
+    name: text(500, 'Automation name').nullable().optional(),
+    description: text(10_000, 'Automation description').nullable().optional(),
+    enabled: z.boolean().optional(),
+}).strict().refine((patch) => Object.keys(patch).length > 0, 'Automation update must include a change');
+export const listAutomationsSchema = pageQuerySchema.extend({
+    targetId: identifierSchema.optional(),
+    enabled: z.boolean().optional(),
+}).strict();
+export const createScheduleTriggerSchema = z.object({
+    id: identifierSchema.optional(),
+    cron: text(200, 'Schedule cron'),
+    timezone: text(200, 'Schedule timezone').optional(),
+    enabled: z.boolean().optional(),
+}).strict();
+export const updateScheduleTriggerSchema = z.object({
+    cron: text(200, 'Schedule cron').optional(),
+    timezone: text(200, 'Schedule timezone').optional(),
+    enabled: z.boolean().optional(),
+}).strict().refine((patch) => Object.keys(patch).length > 0, 'Schedule trigger update must include a change');
+export const createWebhookTriggerSchema = z.object({
+    id: identifierSchema.optional(),
+    source: text(200, 'Webhook source').optional(),
+    event: text(200, 'Webhook event').optional(),
+    secret: z.string().min(16, 'Webhook secret must be at least 16 characters').max(10_000, 'Webhook secret is too long'),
+    enabled: z.boolean().optional(),
+}).strict();
+export const updateWebhookTriggerSchema = z.object({
+    source: text(200, 'Webhook source').optional(),
+    event: text(200, 'Webhook event').optional(),
+    secret: z.string().min(16, 'Webhook secret must be at least 16 characters').max(10_000, 'Webhook secret is too long').optional(),
+    enabled: z.boolean().optional(),
+}).strict().refine((patch) => Object.keys(patch).length > 0, 'Webhook trigger update must include a change');
+export const createWorkflowSchema = z.object({
+    id: identifierSchema.optional(),
+    name: text(500, 'Workflow name').optional(),
+    script: text(1_000_000, 'Workflow script'),
+    compiled: jsonSchema.optional(),
+    allowlist: jsonSchema.optional(),
+    limits: jsonSchema.optional(),
+}).strict();
+export const updateWorkflowSchema = z.object({
+    name: text(500, 'Workflow name').nullable().optional(),
+    script: text(1_000_000, 'Workflow script').optional(),
+    compiled: jsonSchema.nullable().optional(),
+    allowlist: jsonSchema.nullable().optional(),
+    limits: jsonSchema.nullable().optional(),
+}).strict().refine((patch) => Object.keys(patch).length > 0, 'Workflow update must include a change');
+export const listRunsSchema = pageQuerySchema.extend({
+    status: z.enum(['pending', 'sent', 'running', 'completed', 'failed']).optional(),
+}).strict();
+export function parseCreateAutomation(value) {
+    return parse(createAutomationSchema, value);
+}
+export function parseUpdateAutomation(value) {
+    return parse(updateAutomationSchema, value);
+}
+export function parseListAutomations(value) {
+    return parse(listAutomationsSchema, value);
+}
+export function parseCreateScheduleTrigger(value) {
+    return parse(createScheduleTriggerSchema, value);
+}
+export function parseUpdateScheduleTrigger(value) {
+    return parse(updateScheduleTriggerSchema, value);
+}
+export function parseCreateWebhookTrigger(value) {
+    return parse(createWebhookTriggerSchema, value);
+}
+export function parseUpdateWebhookTrigger(value) {
+    return parse(updateWebhookTriggerSchema, value);
+}
+export function parseCreateWorkflow(value) {
+    return parse(createWorkflowSchema, value);
+}
+export function parseUpdateWorkflow(value) {
+    return parse(updateWorkflowSchema, value);
+}
+export function parsePageQuery(value) {
+    return parse(pageQuerySchema, value);
+}
+export function parseListRuns(value) {
+    return parse(listRunsSchema, value);
+}
+export function parse(schema, value) {
+    const result = schema.safeParse(value);
+    if (result.success)
+        return result.data;
+    throw new ValidationError(result.error.issues[0]?.message || 'Input is invalid');
+}

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

@@ -0,0 +1,44 @@
+import type { Automation, AutomationRun, CreateAutomation, CreateScheduleTrigger, CreateWebhookTrigger, CreateWorkflow, Page, ScheduleTrigger, Trigger, UpdateAutomation, UpdateScheduleTrigger, UpdateWebhookTrigger, UpdateWorkflow, WebhookTrigger, Workflow } from './contract.js';
+import type { AutomationCrudRepository, NormalizedListAutomations, NormalizedListRuns } from './crud.js';
+export interface SupabaseRpcClient {
+    rpc(functionName: string, arguments_: Record<string, unknown>): PromiseLike<{
+        data: unknown;
+        error: {
+            code?: string;
+            message?: string;
+        } | null;
+    }>;
+}
+export declare class SupabaseAutomationCrudRepository implements AutomationCrudRepository {
+    #private;
+    private readonly client;
+    constructor(client: SupabaseRpcClient);
+    createAutomation(userId: string, input: Required<CreateAutomation>): Promise<Automation>;
+    listAutomations(userId: string, query: NormalizedListAutomations): Promise<Page<Automation>>;
+    getAutomation(userId: string, automationId: string): Promise<Automation | null>;
+    updateAutomation(userId: string, automationId: string, patch: UpdateAutomation): Promise<Automation | null>;
+    deleteAutomation(userId: string, automationId: string): Promise<boolean>;
+    createScheduleTrigger(userId: string, automationId: string, input: Required<CreateScheduleTrigger>): Promise<ScheduleTrigger>;
+    listScheduleTriggers(userId: string, automationId: string, query: Required<{
+        limit?: number;
+        offset?: number;
+    }>): Promise<Page<ScheduleTrigger>>;
+    getScheduleTrigger(userId: string, automationId: string, triggerId: string): Promise<ScheduleTrigger | null>;
+    updateScheduleTrigger(userId: string, automationId: string, triggerId: string, patch: UpdateScheduleTrigger): Promise<ScheduleTrigger | null>;
+    deleteScheduleTrigger(userId: string, automationId: string, triggerId: string): Promise<boolean>;
+    createWebhookTrigger(userId: string, automationId: string, input: Required<CreateWebhookTrigger>): Promise<WebhookTrigger>;
+    listWebhookTriggers(userId: string, automationId: string, query: Required<{
+        limit?: number;
+        offset?: number;
+    }>): Promise<Page<WebhookTrigger>>;
+    getWebhookTrigger(userId: string, automationId: string, triggerId: string): Promise<WebhookTrigger | null>;
+    updateWebhookTrigger(userId: string, automationId: string, triggerId: string, patch: UpdateWebhookTrigger): Promise<WebhookTrigger | null>;
+    deleteWebhookTrigger(userId: string, automationId: string, triggerId: string): Promise<boolean>;
+    listTriggers(userId: string, automationId: string): Promise<Trigger[]>;
+    createWorkflow(userId: string, automationId: string, input: Required<CreateWorkflow>): Promise<Workflow>;
+    getWorkflow(userId: string, automationId: string): Promise<Workflow | null>;
+    updateWorkflow(userId: string, automationId: string, patch: UpdateWorkflow): Promise<Workflow | null>;
+    deleteWorkflow(userId: string, automationId: string): Promise<boolean>;
+    listRuns(userId: string, automationId: string, query: NormalizedListRuns): Promise<Page<AutomationRun>>;
+    getRun(userId: string, automationId: string, runId: string): Promise<AutomationRun | null>;
+}

package/dist/src/supabase-crud.js

@@ -0,0 +1,271 @@
+import { ConflictError } from './errors.js';
+export class SupabaseAutomationCrudRepository {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async createAutomation(userId, input) {
+        return automation(await this.#call('create_amalgm_automation', {
+            p_user_id: userId,
+            p_automation: input,
+        }));
+    }
+    async listAutomations(userId, query) {
+        const result = await this.#call('list_amalgm_automations', {
+            p_user_id: userId,
+            p_target_id: query.targetId || null,
+            p_enabled: query.enabled ?? null,
+            p_limit: query.limit,
+            p_offset: query.offset,
+        });
+        return paged(result, automation, query);
+    }
+    async getAutomation(userId, automationId) {
+        const row = await this.#call('get_amalgm_automation', {
+            p_user_id: userId,
+            p_automation_id: automationId,
+        });
+        return row ? automation(row) : null;
+    }
+    async updateAutomation(userId, automationId, patch) {
+        const row = await this.#call('update_amalgm_automation', {
+            p_user_id: userId,
+            p_automation_id: automationId,
+            p_patch: patch,
+        });
+        return row ? automation(row) : null;
+    }
+    deleteAutomation(userId, automationId) {
+        return this.#call('delete_amalgm_automation', {
+            p_user_id: userId,
+            p_automation_id: automationId,
+        });
+    }
+    async createScheduleTrigger(userId, automationId, input) {
+        return schedule(await this.#call('create_amalgm_schedule_trigger', {
+            p_user_id: userId,
+            p_automation_id: automationId,
+            p_trigger: input,
+        }));
+    }
+    async listScheduleTriggers(userId, automationId, query) {
+        return this.#listTriggers('list_amalgm_schedule_triggers', userId, automationId, query, schedule);
+    }
+    async getScheduleTrigger(userId, automationId, triggerId) {
+        const row = await this.#call('get_amalgm_schedule_trigger', {
+            p_user_id: userId,
+            p_automation_id: automationId,
+            p_trigger_id: triggerId,
+        });
+        return row ? schedule(row) : null;
+    }
+    async updateScheduleTrigger(userId, automationId, triggerId, patch) {
+        const row = await this.#call('update_amalgm_schedule_trigger', {
+            p_user_id: userId,
+            p_automation_id: automationId,
+            p_trigger_id: triggerId,
+            p_patch: patch,
+        });
+        return row ? schedule(row) : null;
+    }
+    deleteScheduleTrigger(userId, automationId, triggerId) {
+        return this.#call('delete_amalgm_schedule_trigger', {
+            p_user_id: userId,
+            p_automation_id: automationId,
+            p_trigger_id: triggerId,
+        });
+    }
+    async createWebhookTrigger(userId, automationId, input) {
+        return webhook(await this.#call('create_amalgm_webhook_trigger', {
+            p_user_id: userId,
+            p_automation_id: automationId,
+            p_trigger: input,
+        }));
+    }
+    async listWebhookTriggers(userId, automationId, query) {
+        return this.#listTriggers('list_amalgm_webhook_triggers', userId, automationId, query, webhook);
+    }
+    async getWebhookTrigger(userId, automationId, triggerId) {
+        const row = await this.#call('get_amalgm_webhook_trigger', {
+            p_user_id: userId,
+            p_automation_id: automationId,
+            p_trigger_id: triggerId,
+        });
+        return row ? webhook(row) : null;
+    }
+    async updateWebhookTrigger(userId, automationId, triggerId, patch) {
+        const row = await this.#call('update_amalgm_webhook_trigger', {
+            p_user_id: userId,
+            p_automation_id: automationId,
+            p_trigger_id: triggerId,
+            p_patch: patch,
+        });
+        return row ? webhook(row) : null;
+    }
+    deleteWebhookTrigger(userId, automationId, triggerId) {
+        return this.#call('delete_amalgm_webhook_trigger', {
+            p_user_id: userId,
+            p_automation_id: automationId,
+            p_trigger_id: triggerId,
+        });
+    }
+    async listTriggers(userId, automationId) {
+        const rows = await this.#call('list_amalgm_triggers', {
+            p_user_id: userId,
+            p_automation_id: automationId,
+        });
+        return rows.map((row) => row.kind === 'schedule' ? schedule(row) : webhook(row));
+    }
+    async createWorkflow(userId, automationId, input) {
+        return workflow(await this.#call('create_amalgm_workflow', {
+            p_user_id: userId,
+            p_automation_id: automationId,
+            p_workflow: input,
+        }));
+    }
+    async getWorkflow(userId, automationId) {
+        const row = await this.#call('get_amalgm_workflow', {
+            p_user_id: userId,
+            p_automation_id: automationId,
+        });
+        return row ? workflow(row) : null;
+    }
+    async updateWorkflow(userId, automationId, patch) {
+        const row = await this.#call('update_amalgm_workflow', {
+            p_user_id: userId,
+            p_automation_id: automationId,
+            p_patch: patch,
+        });
+        return row ? workflow(row) : null;
+    }
+    deleteWorkflow(userId, automationId) {
+        return this.#call('delete_amalgm_workflow', {
+            p_user_id: userId,
+            p_automation_id: automationId,
+        });
+    }
+    async listRuns(userId, automationId, query) {
+        const result = await this.#call('list_amalgm_runs', {
+            p_user_id: userId,
+            p_automation_id: automationId,
+            p_status: query.status || null,
+            p_limit: query.limit,
+            p_offset: query.offset,
+        });
+        return paged(result, run, query);
+    }
+    async getRun(userId, automationId, runId) {
+        const row = await this.#call('get_amalgm_run', {
+            p_user_id: userId,
+            p_automation_id: automationId,
+            p_run_id: runId,
+        });
+        return row ? run(row) : null;
+    }
+    async #listTriggers(functionName, userId, automationId, query, mapper) {
+        const result = await this.#call(functionName, {
+            p_user_id: userId,
+            p_automation_id: automationId,
+            p_limit: query.limit,
+            p_offset: query.offset,
+        });
+        return paged(result, mapper, query);
+    }
+    async #call(functionName, arguments_) {
+        const { data, error } = await this.client.rpc(functionName, arguments_);
+        if (error) {
+            if (error.code === '23505' || /duplicate key|unique constraint/i.test(error.message || '')) {
+                throw new ConflictError(resource(functionName));
+            }
+            throw new Error(error.message || `Supabase function ${functionName} failed`);
+        }
+        return data;
+    }
+}
+function resource(functionName) {
+    if (functionName.includes('workflow'))
+        return 'Workflow';
+    if (functionName.includes('trigger'))
+        return 'Trigger';
+    if (functionName.includes('automation'))
+        return 'Automation';
+    return 'Automation resource';
+}
+function automation(row) {
+    return {
+        id: row.id,
+        targetId: row.target_id,
+        ...(row.name ? { name: row.name } : {}),
+        ...(row.description ? { description: row.description } : {}),
+        enabled: row.enabled,
+        createdAt: timestamp(row.created_at),
+        updatedAt: timestamp(row.updated_at),
+    };
+}
+function schedule(row) {
+    return {
+        id: row.id,
+        automationId: row.automation_id,
+        kind: 'schedule',
+        enabled: row.enabled,
+        cron: row.cron,
+        timezone: row.timezone,
+        createdAt: timestamp(row.created_at),
+        updatedAt: timestamp(row.updated_at),
+    };
+}
+function webhook(row) {
+    return {
+        id: row.id,
+        automationId: row.automation_id,
+        kind: 'webhook',
+        enabled: row.enabled,
+        source: row.source,
+        event: row.event,
+        secretConfigured: row.secret_configured,
+        createdAt: timestamp(row.created_at),
+        updatedAt: timestamp(row.updated_at),
+    };
+}
+function workflow(row) {
+    return {
+        id: row.id,
+        automationId: row.automation_id,
+        ...(row.name ? { name: row.name } : {}),
+        script: row.script,
+        ...(row.compiled !== null ? { compiled: row.compiled } : {}),
+        ...(row.allowlist !== null ? { allowlist: row.allowlist } : {}),
+        ...(row.limits !== null ? { limits: row.limits } : {}),
+        createdAt: timestamp(row.created_at),
+        updatedAt: timestamp(row.updated_at),
+    };
+}
+function run(row) {
+    return {
+        id: row.id,
+        automationId: row.automation_id,
+        triggerId: row.trigger_id,
+        workflowId: row.workflow_id,
+        targetId: row.target_id,
+        status: row.status,
+        input: row.input,
+        createdAt: timestamp(row.created_at),
+        ...(row.sent_at ? { sentAt: timestamp(row.sent_at) } : {}),
+        ...(row.started_at ? { startedAt: timestamp(row.started_at) } : {}),
+        ...(row.finished_at ? { finishedAt: timestamp(row.finished_at) } : {}),
+        ...(row.output !== null ? { output: row.output } : {}),
+        ...(row.error !== null ? { error: row.error } : {}),
+    };
+}
+function paged(result, mapper, query) {
+    return {
+        items: result.items.map(mapper),
+        total: result.total,
+        limit: query.limit,
+        offset: query.offset,
+        hasMore: query.offset + result.items.length < result.total,
+    };
+}
+function timestamp(value) {
+    return new Date(value).toISOString();
+}

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

@@ -0,0 +1,26 @@
+import type { AutomationStore, AutomationTarget, AutomationRun, DueCronTrigger, PreparedAutomation, RunInput, RunUpdate, StoredEventTrigger } from './types.js';
+export interface SupabaseRpcClient {
+    rpc(functionName: string, arguments_: Record<string, unknown>): PromiseLike<{
+        data: unknown;
+        error: {
+            message?: string;
+        } | null;
+    }>;
+}
+export declare class SupabaseStore implements AutomationStore {
+    #private;
+    readonly client: SupabaseRpcClient;
+    constructor(client: SupabaseRpcClient);
+    saveAutomation(automation: PreparedAutomation): Promise<void>;
+    deleteAutomation(userId: string, automationId: string): Promise<boolean>;
+    eventTriggers(target: AutomationTarget): Promise<StoredEventTrigger[]>;
+    dueCronTriggers(now: Date): Promise<DueCronTrigger[]>;
+    enqueueEvent(trigger: StoredEventTrigger, input: Extract<RunInput, {
+        kind: 'event';
+    }>, now: Date): Promise<AutomationRun | null>;
+    enqueueCron(trigger: DueCronTrigger, nextRunAt: string, now: Date): Promise<AutomationRun | null>;
+    pendingRuns(target: AutomationTarget): Promise<AutomationRun[]>;
+    listRuns(userId: string, automationId?: string): 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

@@ -0,0 +1,123 @@
+function automationRun(row) {
+    return {
+        id: row.id,
+        userId: row.user_id,
+        targetId: row.target_id,
+        automationId: row.automation_id,
+        triggerId: row.trigger_id,
+        workflowId: row.workflow_id,
+        automation: row.automation_payload,
+        input: row.input,
+        status: row.status,
+        createdAt: new Date(row.created_at).toISOString(),
+        ...(row.sent_at ? { sentAt: new Date(row.sent_at).toISOString() } : {}),
+        ...(row.started_at ? { startedAt: new Date(row.started_at).toISOString() } : {}),
+        ...(row.finished_at ? { finishedAt: new Date(row.finished_at).toISOString() } : {}),
+        ...(row.output !== null ? { output: row.output } : {}),
+        ...(row.error !== null ? { error: row.error } : {}),
+    };
+}
+export class SupabaseStore {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async saveAutomation(automation) {
+        await this.#call('save_amalgm_automation', { p_automation: automation });
+    }
+    deleteAutomation(userId, automationId) {
+        return this.#call('delete_amalgm_automation', {
+            p_user_id: userId,
+            p_automation_id: automationId,
+        });
+    }
+    async eventTriggers(target) {
+        const rows = await this.#call('list_amalgm_event_triggers', {
+            p_user_id: target.userId,
+            p_target_id: target.targetId,
+        });
+        return rows.map((row) => ({
+            kind: 'event',
+            userId: row.user_id,
+            automationId: row.automation_id,
+            triggerId: row.trigger_id,
+            targetId: row.target_id,
+            source: row.source,
+            event: row.event,
+            secret: row.secret,
+        }));
+    }
+    async dueCronTriggers(now) {
+        const rows = await this.#call('list_due_amalgm_crons', { p_now: now.toISOString() });
+        return rows.map((row) => ({
+            kind: 'cron',
+            userId: row.user_id,
+            automationId: row.automation_id,
+            triggerId: row.trigger_id,
+            targetId: row.target_id,
+            cron: row.cron,
+            timezone: row.timezone,
+            nextRunAt: new Date(row.next_run_at).toISOString(),
+        }));
+    }
+    enqueueEvent(trigger, input, now) {
+        return this.#enqueue(trigger, input, now, null);
+    }
+    enqueueCron(trigger, nextRunAt, now) {
+        return this.#enqueue(trigger, {
+            kind: 'cron',
+            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);
+    }
+    async listRuns(userId, automationId) {
+        const rows = await this.#call('list_amalgm_runs', {
+            p_user_id: userId,
+            p_automation_id: automationId || null,
+        });
+        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,
+            p_user_id: trigger.userId,
+            p_automation_id: trigger.automationId,
+            p_trigger_id: trigger.triggerId,
+            p_target_id: trigger.targetId,
+            p_expected_next_run_at: trigger.kind === 'cron' ? trigger.nextRunAt : null,
+            p_next_run_at: nextRunAt,
+            p_input: input,
+            p_now: now.toISOString(),
+        });
+        return rows[0] ? automationRun(rows[0]) : null;
+    }
+    async #call(functionName, arguments_) {
+        const { data, error } = await this.client.rpc(functionName, arguments_);
+        if (error)
+            throw new Error(error.message || `Supabase function ${functionName} failed`);
+        return data;
+    }
+}