@amalgm/automations 0.1.2 → 0.2.1

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,52 +63,60 @@ 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>;
     cron: z.ZodEffects<z.ZodString, string, string>;
     timezone: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     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;
-    cron: string;
     timezone?: string | undefined;
+    maxOccurrences?: number | undefined;
+}, {
+    cron: string;
     enabled?: boolean | undefined;
+    id?: string | undefined;
+    timezone?: string | undefined;
+    maxOccurrences?: number | undefined;
 }>;
 export declare const updateScheduleTriggerSchema: z.ZodEffects<z.ZodObject<{
     cron: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     timezone: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     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<{
     id: z.ZodOptional<z.ZodString>;
@@ -117,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>>;
@@ -135,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>;
@@ -163,16 +171,16 @@ 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;
+    id?: string | undefined;
     compiled?: Json | undefined;
     allowlist?: Json | undefined;
     limits?: Json | undefined;
 }, {
-    id?: string | undefined;
-    name?: string | undefined;
     script: string;
+    name?: string | undefined;
+    id?: string | undefined;
     compiled?: Json | undefined;
     allowlist?: Json | undefined;
     limits?: Json | undefined;
@@ -214,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

@@ -21,7 +21,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(),
@@ -41,11 +41,13 @@ export const createScheduleTriggerSchema = z.object({
     cron: text(200, 'Schedule cron'),
     timezone: text(200, 'Schedule timezone').optional(),
     enabled: z.boolean().optional(),
+    maxOccurrences: z.number().int().min(1).max(100_000).optional(),
 }).strict();
 export const updateScheduleTriggerSchema = z.object({
     cron: text(200, 'Schedule cron').optional(),
     timezone: text(200, 'Schedule timezone').optional(),
     enabled: z.boolean().optional(),
+    maxOccurrences: z.number().int().min(1).max(100_000).nullable().optional(),
 }).strict().refine((patch) => Object.keys(patch).length > 0, 'Schedule trigger update must include a change');
 export const createWebhookTriggerSchema = z.object({
     id: identifierSchema.optional(),

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

@@ -0,0 +1,5 @@
+import type { AutomationCrudRepository } from '../crud.js';
+import { type SupabaseRpcClient } from './rpc.js';
+type Operations = Pick<AutomationCrudRepository, 'createAutomation' | 'listAutomations' | 'getAutomation' | 'updateAutomation' | 'deleteAutomation'>;
+export declare function automationRepository(client: SupabaseRpcClient): Operations;
+export {};

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

@@ -0,0 +1,36 @@
+import { automation, paged } from './mappers.js';
+import { call } from './rpc.js';
+export function automationRepository(client) {
+    return {
+        createAutomation: async (userId, input) => automation(await call(client, 'create_amalgm_automation', {
+            p_user_id: userId,
+            p_automation: input,
+        })),
+        listAutomations: async (userId, query) => paged(await call(client, '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,
+        }), automation, query),
+        getAutomation: async (userId, automationId) => {
+            const row = await call(client, 'get_amalgm_automation', {
+                p_user_id: userId,
+                p_automation_id: automationId,
+            });
+            return row ? automation(row) : null;
+        },
+        updateAutomation: async (userId, automationId, patch) => {
+            const row = await call(client, 'update_amalgm_automation', {
+                p_user_id: userId,
+                p_automation_id: automationId,
+                p_patch: patch,
+            });
+            return row ? automation(row) : null;
+        },
+        deleteAutomation: (userId, automationId) => call(client, 'delete_amalgm_automation', {
+            p_user_id: userId,
+            p_automation_id: automationId,
+        }),
+    };
+}

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

@@ -0,0 +1,8 @@
+import type { Automation, AutomationRun, Page, PageQuery, ScheduleTrigger, WebhookTrigger, Workflow } from '../contract.js';
+import type { AutomationRow, PageResult, RunRow, TriggerRow, WorkflowRow } from './rows.js';
+export declare function automation(row: AutomationRow): Automation;
+export declare function schedule(row: TriggerRow): ScheduleTrigger;
+export declare function webhook(row: TriggerRow): WebhookTrigger;
+export declare function workflow(row: WorkflowRow): Workflow;
+export declare function run(row: RunRow): AutomationRun;
+export declare function paged<T, U>(result: PageResult<T>, mapper: (row: T) => U, query: Required<PageQuery>): Page<U>;

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

@@ -0,0 +1,81 @@
+export 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),
+    };
+}
+export function schedule(row) {
+    return {
+        id: row.id,
+        automationId: row.automation_id,
+        kind: 'schedule',
+        enabled: row.enabled,
+        cron: row.cron,
+        timezone: row.timezone,
+        nextRunAt: timestamp(row.next_run_at),
+        ...(row.max_occurrences === null ? {} : { maxOccurrences: row.max_occurrences }),
+        ...(row.remaining_occurrences === null ? {} : { remainingOccurrences: row.remaining_occurrences }),
+        createdAt: timestamp(row.created_at),
+        updatedAt: timestamp(row.updated_at),
+    };
+}
+export 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),
+    };
+}
+export 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),
+    };
+}
+export 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 } : {}),
+    };
+}
+export 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-crud/rows.d.ts

@@ -0,0 +1,56 @@
+import type { AutomationRun, Workflow } from '../contract.js';
+export type AutomationRow = {
+    id: string;
+    target_id: string;
+    name: string | null;
+    description: string | null;
+    enabled: boolean;
+    created_at: Date | string;
+    updated_at: Date | string;
+};
+export type TriggerRow = {
+    id: string;
+    automation_id: string;
+    kind: 'schedule' | 'webhook';
+    enabled: boolean;
+    cron: string | null;
+    timezone: string | null;
+    next_run_at: Date | string | null;
+    max_occurrences: number | null;
+    remaining_occurrences: number | null;
+    source: string | null;
+    event: string | null;
+    secret_configured: boolean;
+    created_at: Date | string;
+    updated_at: Date | string;
+};
+export type WorkflowRow = {
+    id: string;
+    automation_id: string;
+    name: string | null;
+    script: string;
+    compiled: Workflow['compiled'] | null;
+    allowlist: Workflow['allowlist'] | null;
+    limits: Workflow['limits'] | null;
+    created_at: Date | string;
+    updated_at: Date | string;
+};
+export type RunRow = {
+    id: string;
+    automation_id: string;
+    trigger_id: string;
+    workflow_id: string;
+    target_id: string;
+    status: AutomationRun['status'];
+    input: AutomationRun['input'];
+    created_at: Date | string;
+    sent_at: Date | string | null;
+    started_at: Date | string | null;
+    finished_at: Date | string | null;
+    output: AutomationRun['output'] | null;
+    error: string | null;
+};
+export type PageResult<T> = {
+    items: T[];
+    total: number;
+};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,10 @@
+export interface SupabaseRpcClient {
+    rpc(functionName: string, arguments_: Record<string, unknown>): PromiseLike<{
+        data: unknown;
+        error: {
+            code?: string;
+            message?: string;
+        } | null;
+    }>;
+}
+export declare function call<T>(client: SupabaseRpcClient, functionName: string, arguments_: Record<string, unknown>): Promise<T>;

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

@@ -0,0 +1,19 @@
+import { ConflictError } from '../errors.js';
+export async function call(client, functionName, arguments_) {
+    const { data, error } = await client.rpc(functionName, arguments_);
+    if (!error)
+        return data;
+    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`);
+}
+function resource(functionName) {
+    if (functionName.includes('workflow'))
+        return 'Workflow';
+    if (functionName.includes('trigger'))
+        return 'Trigger';
+    if (functionName.includes('automation'))
+        return 'Automation';
+    return 'Automation resource';
+}

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

@@ -0,0 +1,5 @@
+import type { AutomationCrudRepository } from '../crud.js';
+import { type SupabaseRpcClient } from './rpc.js';
+type Operations = Pick<AutomationCrudRepository, 'createScheduleTrigger' | 'listScheduleTriggers' | 'getScheduleTrigger' | 'updateScheduleTrigger' | 'deleteScheduleTrigger' | 'createWebhookTrigger' | 'listWebhookTriggers' | 'getWebhookTrigger' | 'updateWebhookTrigger' | 'deleteWebhookTrigger' | 'listTriggers'>;
+export declare function triggerRepository(client: SupabaseRpcClient): Operations;
+export {};

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

@@ -0,0 +1,46 @@
+import { paged, schedule, webhook } from './mappers.js';
+import { call } from './rpc.js';
+export function triggerRepository(client) {
+    const list = async (functionName, userId, automationId, query, mapper) => paged(await call(client, functionName, {
+        p_user_id: userId,
+        p_automation_id: automationId,
+        p_limit: query.limit,
+        p_offset: query.offset,
+    }), mapper, query);
+    return {
+        createScheduleTrigger: async (userId, automationId, input) => schedule(await call(client, 'create_amalgm_schedule_trigger', { p_user_id: userId, p_automation_id: automationId, p_trigger: input })),
+        listScheduleTriggers: (userId, automationId, query) => list('list_amalgm_schedule_triggers', userId, automationId, query, schedule),
+        getScheduleTrigger: async (userId, automationId, triggerId) => {
+            const row = await call(client, 'get_amalgm_schedule_trigger', {
+                p_user_id: userId, p_automation_id: automationId, p_trigger_id: triggerId,
+            });
+            return row ? schedule(row) : null;
+        },
+        updateScheduleTrigger: async (userId, automationId, triggerId, patch) => {
+            const row = await call(client, '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) => call(client, 'delete_amalgm_schedule_trigger', { p_user_id: userId, p_automation_id: automationId, p_trigger_id: triggerId }),
+        createWebhookTrigger: async (userId, automationId, input) => webhook(await call(client, 'create_amalgm_webhook_trigger', { p_user_id: userId, p_automation_id: automationId, p_trigger: input })),
+        listWebhookTriggers: (userId, automationId, query) => list('list_amalgm_webhook_triggers', userId, automationId, query, webhook),
+        getWebhookTrigger: async (userId, automationId, triggerId) => {
+            const row = await call(client, 'get_amalgm_webhook_trigger', {
+                p_user_id: userId, p_automation_id: automationId, p_trigger_id: triggerId,
+            });
+            return row ? webhook(row) : null;
+        },
+        updateWebhookTrigger: async (userId, automationId, triggerId, patch) => {
+            const row = await call(client, '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) => call(client, 'delete_amalgm_webhook_trigger', { p_user_id: userId, p_automation_id: automationId, p_trigger_id: triggerId }),
+        listTriggers: async (userId, automationId) => (await call(client, 'list_amalgm_triggers', {
+            p_user_id: userId,
+            p_automation_id: automationId,
+        })).map((row) => row.kind === 'schedule' ? schedule(row) : webhook(row)),
+    };
+}

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

@@ -0,0 +1,5 @@
+import type { AutomationCrudRepository } from '../crud.js';
+import { type SupabaseRpcClient } from './rpc.js';
+type Operations = Pick<AutomationCrudRepository, 'createWorkflow' | 'getWorkflow' | 'updateWorkflow' | 'deleteWorkflow' | 'listRuns' | 'getRun'>;
+export declare function workflowRunRepository(client: SupabaseRpcClient): Operations;
+export {};

package/dist/src/supabase-crud/workflow-runs.js

@@ -0,0 +1,41 @@
+import { paged, run, workflow } from './mappers.js';
+import { call } from './rpc.js';
+export function workflowRunRepository(client) {
+    return {
+        createWorkflow: async (userId, automationId, input) => workflow(await call(client, 'create_amalgm_workflow', { p_user_id: userId, p_automation_id: automationId, p_workflow: input })),
+        getWorkflow: async (userId, automationId) => {
+            const row = await call(client, 'get_amalgm_workflow', {
+                p_user_id: userId,
+                p_automation_id: automationId,
+            });
+            return row ? workflow(row) : null;
+        },
+        updateWorkflow: async (userId, automationId, patch) => {
+            const row = await call(client, 'update_amalgm_workflow', {
+                p_user_id: userId,
+                p_automation_id: automationId,
+                p_patch: patch,
+            });
+            return row ? workflow(row) : null;
+        },
+        deleteWorkflow: (userId, automationId) => call(client, 'delete_amalgm_workflow', {
+            p_user_id: userId,
+            p_automation_id: automationId,
+        }),
+        listRuns: async (userId, automationId, query) => paged(await call(client, 'list_amalgm_runs', {
+            p_user_id: userId,
+            p_automation_id: automationId,
+            p_status: query.status || null,
+            p_limit: query.limit,
+            p_offset: query.offset,
+        }), run, query),
+        getRun: async (userId, automationId, runId) => {
+            const row = await call(client, 'get_amalgm_run', {
+                p_user_id: userId,
+                p_automation_id: automationId,
+                p_run_id: runId,
+            });
+            return row ? run(row) : null;
+        },
+    };
+}

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

@@ -1,44 +1,8 @@
-import type { Automation, AutomationRun, CreateAutomation, CreateWebhookTrigger, CreateWorkflow, Page, ScheduleTrigger, Trigger, UpdateAutomation, UpdateWebhookTrigger, UpdateWorkflow, WebhookTrigger, Workflow } from './contract.js';
-import type { AutomationCrudRepository, NormalizedListAutomations, NormalizedListRuns, StoredScheduleCreate, StoredScheduleUpdate } from './crud.js';
-export interface SupabaseRpcClient {
-    rpc(functionName: string, arguments_: Record<string, unknown>): PromiseLike<{
-        data: unknown;
-        error: {
-            code?: string;
-            message?: string;
-        } | null;
-    }>;
+import type { AutomationCrudRepository } from './crud.js';
+import type { SupabaseRpcClient } from './supabase-crud/rpc.js';
+export type { SupabaseRpcClient } from './supabase-crud/rpc.js';
+export interface SupabaseAutomationCrudRepository extends AutomationCrudRepository {
 }
-export declare class SupabaseAutomationCrudRepository implements AutomationCrudRepository {
-    #private;
-    private readonly client;
+export declare class SupabaseAutomationCrudRepository {
     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: StoredScheduleCreate): 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: StoredScheduleUpdate): 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>;
 }