@amalgm/automations 0.1.2 → 0.2.0

package/dist/src/crud/automations.js

@@ -0,0 +1,55 @@
+import { ConflictError, NotFoundError } from '../errors.js';
+import { parseCreateAutomation, parseListAutomations, parseUpdateAutomation } from '../schema.js';
+import { id, newId, page } from '../validation.js';
+import { assertTarget } from './context.js';
+export function automationOperations(context) {
+    const { principal, repository } = context;
+    return {
+        create: async (input) => {
+            context.write();
+            const parsed = parseCreateAutomation(input);
+            assertTarget(principal, parsed.targetId);
+            if (parsed.id && await repository.getAutomation(principal.userId, id(parsed.id, 'Automation id'))) {
+                throw new ConflictError('Automation');
+            }
+            return repository.createAutomation(principal.userId, {
+                id: parsed.id ? id(parsed.id, 'Automation id') : newId('automation'),
+                targetId: parsed.targetId,
+                name: parsed.name || '',
+                description: parsed.description || '',
+                enabled: parsed.enabled !== false,
+            });
+        },
+        list: async (query = {}) => {
+            context.read();
+            const parsed = parseListAutomations(query);
+            if (parsed.targetId)
+                assertTarget(principal, parsed.targetId);
+            return repository.listAutomations(principal.userId, {
+                ...page(parsed),
+                ...(parsed.targetId ? { targetId: id(parsed.targetId, 'targetId') } : {}),
+                ...(parsed.enabled === undefined ? {} : { enabled: parsed.enabled }),
+            });
+        },
+        get: async (automationId) => {
+            context.read();
+            return repository.getAutomation(principal.userId, id(automationId, 'Automation id'));
+        },
+        update: async (automationId, patch) => {
+            context.write();
+            const parsed = parseUpdateAutomation(patch);
+            if (parsed.targetId !== undefined)
+                assertTarget(principal, parsed.targetId);
+            const updated = await repository.updateAutomation(principal.userId, id(automationId, 'Automation id'), parsed);
+            if (!updated)
+                throw new NotFoundError('Automation');
+            return updated;
+        },
+        delete: async (automationId) => {
+            context.write();
+            const deleted = await repository.deleteAutomation(principal.userId, id(automationId, 'Automation id'));
+            if (!deleted)
+                throw new NotFoundError('Automation');
+        },
+    };
+}

package/dist/src/crud/context.d.ts

@@ -0,0 +1,13 @@
+import type { AutomationPrincipal } from '../contract.js';
+import type { AutomationCrudRepository } from './repository.js';
+export interface CrudContext {
+    repository: AutomationCrudRepository;
+    principal: AutomationPrincipal;
+    clock: () => Date;
+    read(): void;
+    write(): void;
+    runsRead(): void;
+    exists(automationId: string): Promise<void>;
+}
+export declare function createContext(repository: AutomationCrudRepository, principal: AutomationPrincipal, clock: () => Date): CrudContext;
+export declare function assertTarget(principal: AutomationPrincipal, targetId: string): void;

package/dist/src/crud/context.js

@@ -0,0 +1,34 @@
+import { ForbiddenError, NotFoundError } from '../errors.js';
+import { id, requiredText } from '../validation.js';
+export function createContext(repository, principal, clock) {
+    assertPrincipal(principal);
+    return {
+        repository,
+        principal,
+        clock,
+        read: () => assertScope(principal, 'automations:read'),
+        write: () => assertScope(principal, 'automations:write'),
+        runsRead: () => assertScope(principal, 'runs:read'),
+        exists: async (automationId) => {
+            const found = await repository.getAutomation(principal.userId, id(automationId, 'Automation id'));
+            if (!found)
+                throw new NotFoundError('Automation');
+        },
+    };
+}
+export function assertTarget(principal, targetId) {
+    if (principal.targetIds && !principal.targetIds.includes(targetId)) {
+        throw new ForbiddenError('This credential cannot access that target');
+    }
+}
+function assertPrincipal(principal) {
+    requiredText(principal.userId, 'Authenticated user id');
+    if (!Array.isArray(principal.scopes))
+        throw new ForbiddenError();
+    principal.targetIds?.forEach((targetId) => id(targetId, 'Authorized target id'));
+}
+function assertScope(principal, scope) {
+    if (!principal.scopes.includes('*') && !principal.scopes.includes(scope)) {
+        throw new ForbiddenError(`This credential requires ${scope}`);
+    }
+}

package/dist/src/crud/repository.d.ts

@@ -0,0 +1,35 @@
+import type { Automation, AutomationRun, CreateAutomation, CreateScheduleTrigger, CreateWebhookTrigger, CreateWorkflow, ListAutomations, ListRuns, Page, PageQuery, ScheduleTrigger, Trigger, UpdateAutomation, UpdateScheduleTrigger, UpdateWebhookTrigger, UpdateWorkflow, WebhookTrigger, Workflow } from '../contract.js';
+export type StoredScheduleCreate = Omit<Required<CreateScheduleTrigger>, 'maxOccurrences'> & {
+    maxOccurrences: number | null;
+    nextRunAt: string;
+};
+export type StoredScheduleUpdate = UpdateScheduleTrigger & {
+    nextRunAt?: string;
+    remainingOccurrences?: number | null;
+};
+export type NormalizedListAutomations = Required<PageQuery> & Omit<ListAutomations, keyof PageQuery>;
+export type NormalizedListRuns = Required<PageQuery> & Omit<ListRuns, keyof PageQuery>;
+export interface AutomationCrudRepository {
+    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<PageQuery>): 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<PageQuery>): 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/crud/repository.js

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

package/dist/src/crud/runs.d.ts

@@ -0,0 +1,3 @@
+import type { AutomationCrud } from '../contract.js';
+import type { CrudContext } from './context.js';
+export declare function runOperations(context: CrudContext): AutomationCrud['runs'];

package/dist/src/crud/runs.js

@@ -0,0 +1,19 @@
+import { parseListRuns } from '../schema.js';
+import { id, page } from '../validation.js';
+export function runOperations(context) {
+    const { principal, repository } = context;
+    return {
+        list: async (automationId, query = {}) => {
+            context.runsRead();
+            const parsed = parseListRuns(query);
+            return repository.listRuns(principal.userId, id(automationId, 'Automation id'), {
+                ...page(parsed),
+                ...(parsed.status ? { status: parsed.status } : {}),
+            });
+        },
+        get: async (automationId, runId) => {
+            context.runsRead();
+            return repository.getRun(principal.userId, id(automationId, 'Automation id'), id(runId, 'Run id'));
+        },
+    };
+}

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

@@ -0,0 +1,3 @@
+import type { AutomationCrud } from '../contract.js';
+import type { CrudContext } from './context.js';
+export declare function triggerOperations(context: CrudContext): AutomationCrud['triggers'];

package/dist/src/crud/triggers.js

@@ -0,0 +1,118 @@
+import { ConflictError, NotFoundError } from '../errors.js';
+import { parseCreateScheduleTrigger, parseCreateWebhookTrigger, parsePageQuery, parseUpdateScheduleTrigger, parseUpdateWebhookTrigger, } from '../schema.js';
+import { nextCronAt } from '../schedule.js';
+import { id, newId, page, schedule } from '../validation.js';
+export function triggerOperations(context) {
+    const { principal, repository } = context;
+    const unique = async (automationId, triggerId) => {
+        const exists = (await repository.listTriggers(principal.userId, automationId))
+            .some((trigger) => trigger.id === triggerId);
+        if (exists)
+            throw new ConflictError('Trigger');
+    };
+    return {
+        list: async (automationId) => {
+            context.read();
+            await context.exists(automationId);
+            return repository.listTriggers(principal.userId, automationId);
+        },
+        schedule: {
+            create: async (automationId, input) => {
+                context.write();
+                await context.exists(automationId);
+                const parsed = parseCreateScheduleTrigger(input);
+                const timezone = parsed.timezone || 'UTC';
+                schedule(parsed.cron, timezone);
+                if (parsed.id)
+                    await unique(automationId, parsed.id);
+                return repository.createScheduleTrigger(principal.userId, automationId, {
+                    id: parsed.id ? id(parsed.id, 'Schedule trigger id') : newId('schedule'),
+                    cron: parsed.cron,
+                    timezone,
+                    enabled: parsed.enabled !== false,
+                    maxOccurrences: parsed.maxOccurrences ?? null,
+                    nextRunAt: nextCronAt(parsed.cron, timezone, context.clock()),
+                });
+            },
+            list: async (automationId, query = {}) => {
+                context.read();
+                await context.exists(automationId);
+                return repository.listScheduleTriggers(principal.userId, automationId, page(parsePageQuery(query)));
+            },
+            get: async (automationId, triggerId) => {
+                context.read();
+                await context.exists(automationId);
+                return repository.getScheduleTrigger(principal.userId, automationId, id(triggerId, 'Schedule trigger id'));
+            },
+            update: async (automationId, triggerId, patch) => {
+                context.write();
+                await context.exists(automationId);
+                const parsed = parseUpdateScheduleTrigger(patch);
+                let stored = parsed.maxOccurrences === undefined
+                    ? { ...parsed }
+                    : { ...parsed, remainingOccurrences: parsed.maxOccurrences };
+                if (parsed.cron !== undefined || parsed.timezone !== undefined) {
+                    const current = await repository.getScheduleTrigger(principal.userId, automationId, triggerId);
+                    if (!current)
+                        throw new NotFoundError('Schedule trigger');
+                    const cron = parsed.cron ?? current.cron;
+                    const timezone = parsed.timezone ?? current.timezone;
+                    schedule(cron, timezone);
+                    stored = { ...stored, nextRunAt: nextCronAt(cron, timezone, context.clock()) };
+                }
+                const updated = await repository.updateScheduleTrigger(principal.userId, automationId, id(triggerId, 'Schedule trigger id'), stored);
+                if (!updated)
+                    throw new NotFoundError('Schedule trigger');
+                return updated;
+            },
+            delete: async (automationId, triggerId) => {
+                context.write();
+                await context.exists(automationId);
+                const deleted = await repository.deleteScheduleTrigger(principal.userId, automationId, id(triggerId, 'Schedule trigger id'));
+                if (!deleted)
+                    throw new NotFoundError('Schedule trigger');
+            },
+        },
+        webhook: {
+            create: async (automationId, input) => {
+                context.write();
+                await context.exists(automationId);
+                const parsed = parseCreateWebhookTrigger(input);
+                if (parsed.id)
+                    await unique(automationId, parsed.id);
+                return repository.createWebhookTrigger(principal.userId, automationId, {
+                    id: parsed.id ? id(parsed.id, 'Webhook trigger id') : newId('webhook'),
+                    source: parsed.source || '*',
+                    event: parsed.event || '*',
+                    secret: parsed.secret,
+                    enabled: parsed.enabled !== false,
+                });
+            },
+            list: async (automationId, query = {}) => {
+                context.read();
+                await context.exists(automationId);
+                return repository.listWebhookTriggers(principal.userId, automationId, page(parsePageQuery(query)));
+            },
+            get: async (automationId, triggerId) => {
+                context.read();
+                await context.exists(automationId);
+                return repository.getWebhookTrigger(principal.userId, automationId, id(triggerId, 'Webhook trigger id'));
+            },
+            update: async (automationId, triggerId, patch) => {
+                context.write();
+                await context.exists(automationId);
+                const updated = await repository.updateWebhookTrigger(principal.userId, automationId, id(triggerId, 'Webhook trigger id'), parseUpdateWebhookTrigger(patch));
+                if (!updated)
+                    throw new NotFoundError('Webhook trigger');
+                return updated;
+            },
+            delete: async (automationId, triggerId) => {
+                context.write();
+                await context.exists(automationId);
+                const deleted = await repository.deleteWebhookTrigger(principal.userId, automationId, id(triggerId, 'Webhook trigger id'));
+                if (!deleted)
+                    throw new NotFoundError('Webhook trigger');
+            },
+        },
+    };
+}

package/dist/src/crud/workflow.d.ts

@@ -0,0 +1,3 @@
+import type { AutomationCrud } from '../contract.js';
+import type { CrudContext } from './context.js';
+export declare function workflowOperations(context: CrudContext): AutomationCrud['workflow'];

package/dist/src/crud/workflow.js

@@ -0,0 +1,42 @@
+import { ConflictError, NotFoundError } from '../errors.js';
+import { parseCreateWorkflow, parseUpdateWorkflow } from '../schema.js';
+import { id, newId } from '../validation.js';
+export function workflowOperations(context) {
+    const { principal, repository } = context;
+    return {
+        create: async (automationId, input) => {
+            context.write();
+            await context.exists(automationId);
+            if (await repository.getWorkflow(principal.userId, automationId))
+                throw new ConflictError('Workflow');
+            const parsed = parseCreateWorkflow(input);
+            return repository.createWorkflow(principal.userId, automationId, {
+                id: parsed.id ? id(parsed.id, 'Workflow id') : newId('workflow'),
+                name: parsed.name || '',
+                script: parsed.script,
+                compiled: parsed.compiled ?? null,
+                allowlist: parsed.allowlist ?? null,
+                limits: parsed.limits ?? null,
+            });
+        },
+        get: async (automationId) => {
+            context.read();
+            await context.exists(automationId);
+            return repository.getWorkflow(principal.userId, automationId);
+        },
+        update: async (automationId, patch) => {
+            context.write();
+            await context.exists(automationId);
+            const updated = await repository.updateWorkflow(principal.userId, automationId, parseUpdateWorkflow(patch));
+            if (!updated)
+                throw new NotFoundError('Workflow');
+            return updated;
+        },
+        delete: async (automationId) => {
+            context.write();
+            await context.exists(automationId);
+            if (!await repository.deleteWorkflow(principal.userId, automationId))
+                throw new NotFoundError('Workflow');
+        },
+    };
+}

package/dist/src/crud.d.ts

@@ -1,36 +1,6 @@
-import type { Automation, AutomationCrud, AutomationCrudService as AutomationCrudServiceContract, AutomationPrincipal, AutomationRun, CreateAutomation, CreateScheduleTrigger, CreateWebhookTrigger, CreateWorkflow, ListAutomations, ListRuns, Page, PageQuery, ScheduleTrigger, Trigger, UpdateAutomation, UpdateScheduleTrigger, UpdateWebhookTrigger, UpdateWorkflow, WebhookTrigger, Workflow } from './contract.js';
-export type StoredScheduleCreate = Required<CreateScheduleTrigger> & {
-    nextRunAt: string;
-};
-export type StoredScheduleUpdate = UpdateScheduleTrigger & {
-    nextRunAt?: string;
-};
-export interface AutomationCrudRepository {
-    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<PageQuery>): 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<PageQuery>): 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>;
-}
-export type NormalizedListAutomations = Required<PageQuery> & Omit<ListAutomations, keyof PageQuery>;
-export type NormalizedListRuns = Required<PageQuery> & Omit<ListRuns, keyof PageQuery>;
+import type { AutomationCrud, AutomationCrudService as AutomationCrudServiceContract, AutomationPrincipal } from './contract.js';
+import type { AutomationCrudRepository } from './crud/repository.js';
+export type { AutomationCrudRepository, NormalizedListAutomations, NormalizedListRuns, StoredScheduleCreate, StoredScheduleUpdate, } from './crud/repository.js';
 export declare class AutomationCrudService implements AutomationCrudServiceContract {
     private readonly repository;
     private readonly clock;

package/dist/src/crud.js

@@ -1,7 +1,8 @@
-import { ConflictError, ForbiddenError, NotFoundError } from './errors.js';
-import { parseCreateAutomation, parseCreateScheduleTrigger, parseCreateWebhookTrigger, parseCreateWorkflow, parseListAutomations, parseListRuns, parsePageQuery, parseUpdateAutomation, parseUpdateScheduleTrigger, parseUpdateWebhookTrigger, parseUpdateWorkflow, } from './schema.js';
-import { id, newId, page, requiredText, schedule, } from './validation.js';
-import { nextCronAt } from './schedule.js';
+import { automationOperations } from './crud/automations.js';
+import { createContext } from './crud/context.js';
+import { runOperations } from './crud/runs.js';
+import { triggerOperations } from './crud/triggers.js';
+import { workflowOperations } from './crud/workflow.js';
 export class AutomationCrudService {
     repository;
     clock;
@@ -10,240 +11,12 @@ export class AutomationCrudService {
         this.clock = clock;
     }
     for(principal) {
-        assertPrincipal(principal);
-        const read = () => assertScope(principal, 'automations:read');
-        const write = () => assertScope(principal, 'automations:write');
-        const runsRead = () => assertScope(principal, 'runs:read');
-        const exists = async (automationId) => {
-            const automation = await this.repository.getAutomation(principal.userId, id(automationId, 'Automation id'));
-            if (!automation)
-                throw new NotFoundError('Automation');
-        };
+        const context = createContext(this.repository, principal, this.clock);
         return {
-            automations: {
-                create: async (input) => {
-                    write();
-                    const parsed = parseCreateAutomation(input);
-                    const targetId = parsed.targetId;
-                    assertTarget(principal, targetId);
-                    if (parsed.id && await this.repository.getAutomation(principal.userId, id(parsed.id, 'Automation id'))) {
-                        throw new ConflictError('Automation');
-                    }
-                    return this.repository.createAutomation(principal.userId, {
-                        id: parsed.id ? id(parsed.id, 'Automation id') : newId('automation'),
-                        targetId,
-                        name: parsed.name || '',
-                        description: parsed.description || '',
-                        enabled: parsed.enabled !== false,
-                    });
-                },
-                list: async (query = {}) => {
-                    read();
-                    const parsed = parseListAutomations(query);
-                    if (parsed.targetId)
-                        assertTarget(principal, parsed.targetId);
-                    return this.repository.listAutomations(principal.userId, {
-                        ...page(parsed),
-                        ...(parsed.targetId ? { targetId: id(parsed.targetId, 'targetId') } : {}),
-                        ...(parsed.enabled === undefined ? {} : { enabled: parsed.enabled }),
-                    });
-                },
-                get: async (automationId) => {
-                    read();
-                    return this.repository.getAutomation(principal.userId, id(automationId, 'Automation id'));
-                },
-                update: async (automationId, patch) => {
-                    write();
-                    const parsed = parseUpdateAutomation(patch);
-                    if (parsed.targetId !== undefined) {
-                        assertTarget(principal, parsed.targetId);
-                    }
-                    const updated = await this.repository.updateAutomation(principal.userId, id(automationId, 'Automation id'), parsed);
-                    if (!updated)
-                        throw new NotFoundError('Automation');
-                    return updated;
-                },
-                delete: async (automationId) => {
-                    write();
-                    const deleted = await this.repository.deleteAutomation(principal.userId, id(automationId, 'Automation id'));
-                    if (!deleted)
-                        throw new NotFoundError('Automation');
-                },
-            },
-            triggers: {
-                list: async (automationId) => {
-                    read();
-                    await exists(automationId);
-                    return this.repository.listTriggers(principal.userId, automationId);
-                },
-                schedule: {
-                    create: async (automationId, input) => {
-                        write();
-                        await exists(automationId);
-                        const parsed = parseCreateScheduleTrigger(input);
-                        const timezone = parsed.timezone || 'UTC';
-                        schedule(parsed.cron, timezone);
-                        if (parsed.id && (await this.repository.listTriggers(principal.userId, automationId))
-                            .some((trigger) => trigger.id === parsed.id))
-                            throw new ConflictError('Trigger');
-                        return this.repository.createScheduleTrigger(principal.userId, automationId, {
-                            id: parsed.id ? id(parsed.id, 'Schedule trigger id') : newId('schedule'),
-                            cron: parsed.cron,
-                            timezone,
-                            enabled: parsed.enabled !== false,
-                            nextRunAt: nextCronAt(parsed.cron, timezone, this.clock()),
-                        });
-                    },
-                    list: async (automationId, query = {}) => {
-                        read();
-                        await exists(automationId);
-                        return this.repository.listScheduleTriggers(principal.userId, automationId, page(parsePageQuery(query)));
-                    },
-                    get: async (automationId, triggerId) => {
-                        read();
-                        await exists(automationId);
-                        return this.repository.getScheduleTrigger(principal.userId, automationId, id(triggerId, 'Schedule trigger id'));
-                    },
-                    update: async (automationId, triggerId, patch) => {
-                        write();
-                        await exists(automationId);
-                        const parsed = parseUpdateScheduleTrigger(patch);
-                        let storedPatch = parsed;
-                        if (parsed.cron !== undefined || parsed.timezone !== undefined) {
-                            const existing = await this.repository.getScheduleTrigger(principal.userId, automationId, triggerId);
-                            if (!existing)
-                                throw new NotFoundError('Schedule trigger');
-                            const cron = parsed.cron ?? existing.cron;
-                            const timezone = parsed.timezone ?? existing.timezone;
-                            schedule(cron, timezone);
-                            storedPatch = { ...parsed, nextRunAt: nextCronAt(cron, timezone, this.clock()) };
-                        }
-                        const updated = await this.repository.updateScheduleTrigger(principal.userId, automationId, id(triggerId, 'Schedule trigger id'), storedPatch);
-                        if (!updated)
-                            throw new NotFoundError('Schedule trigger');
-                        return updated;
-                    },
-                    delete: async (automationId, triggerId) => {
-                        write();
-                        await exists(automationId);
-                        const deleted = await this.repository.deleteScheduleTrigger(principal.userId, automationId, id(triggerId, 'Schedule trigger id'));
-                        if (!deleted)
-                            throw new NotFoundError('Schedule trigger');
-                    },
-                },
-                webhook: {
-                    create: async (automationId, input) => {
-                        write();
-                        await exists(automationId);
-                        const parsed = parseCreateWebhookTrigger(input);
-                        if (parsed.id && (await this.repository.listTriggers(principal.userId, automationId))
-                            .some((trigger) => trigger.id === parsed.id))
-                            throw new ConflictError('Trigger');
-                        return this.repository.createWebhookTrigger(principal.userId, automationId, {
-                            id: parsed.id ? id(parsed.id, 'Webhook trigger id') : newId('webhook'),
-                            source: parsed.source || '*',
-                            event: parsed.event || '*',
-                            secret: parsed.secret,
-                            enabled: parsed.enabled !== false,
-                        });
-                    },
-                    list: async (automationId, query = {}) => {
-                        read();
-                        await exists(automationId);
-                        return this.repository.listWebhookTriggers(principal.userId, automationId, page(parsePageQuery(query)));
-                    },
-                    get: async (automationId, triggerId) => {
-                        read();
-                        await exists(automationId);
-                        return this.repository.getWebhookTrigger(principal.userId, automationId, id(triggerId, 'Webhook trigger id'));
-                    },
-                    update: async (automationId, triggerId, patch) => {
-                        write();
-                        await exists(automationId);
-                        const parsed = parseUpdateWebhookTrigger(patch);
-                        const updated = await this.repository.updateWebhookTrigger(principal.userId, automationId, id(triggerId, 'Webhook trigger id'), parsed);
-                        if (!updated)
-                            throw new NotFoundError('Webhook trigger');
-                        return updated;
-                    },
-                    delete: async (automationId, triggerId) => {
-                        write();
-                        await exists(automationId);
-                        const deleted = await this.repository.deleteWebhookTrigger(principal.userId, automationId, id(triggerId, 'Webhook trigger id'));
-                        if (!deleted)
-                            throw new NotFoundError('Webhook trigger');
-                    },
-                },
-            },
-            workflow: {
-                create: async (automationId, input) => {
-                    write();
-                    await exists(automationId);
-                    if (await this.repository.getWorkflow(principal.userId, automationId)) {
-                        throw new ConflictError('Workflow');
-                    }
-                    const parsed = parseCreateWorkflow(input);
-                    return this.repository.createWorkflow(principal.userId, automationId, {
-                        id: parsed.id ? id(parsed.id, 'Workflow id') : newId('workflow'),
-                        name: parsed.name || '',
-                        script: parsed.script,
-                        compiled: parsed.compiled ?? null,
-                        allowlist: parsed.allowlist ?? null,
-                        limits: parsed.limits ?? null,
-                    });
-                },
-                get: async (automationId) => {
-                    read();
-                    await exists(automationId);
-                    return this.repository.getWorkflow(principal.userId, automationId);
-                },
-                update: async (automationId, patch) => {
-                    write();
-                    await exists(automationId);
-                    const parsed = parseUpdateWorkflow(patch);
-                    const updated = await this.repository.updateWorkflow(principal.userId, automationId, parsed);
-                    if (!updated)
-                        throw new NotFoundError('Workflow');
-                    return updated;
-                },
-                delete: async (automationId) => {
-                    write();
-                    await exists(automationId);
-                    if (!await this.repository.deleteWorkflow(principal.userId, automationId)) {
-                        throw new NotFoundError('Workflow');
-                    }
-                },
-            },
-            runs: {
-                list: async (automationId, query = {}) => {
-                    runsRead();
-                    const parsed = parseListRuns(query);
-                    return this.repository.listRuns(principal.userId, id(automationId, 'Automation id'), {
-                        ...page(parsed),
-                        ...(parsed.status ? { status: parsed.status } : {}),
-                    });
-                },
-                get: async (automationId, runId) => {
-                    runsRead();
-                    return this.repository.getRun(principal.userId, id(automationId, 'Automation id'), id(runId, 'Run id'));
-                },
-            },
+            automations: automationOperations(context),
+            triggers: triggerOperations(context),
+            workflow: workflowOperations(context),
+            runs: runOperations(context),
         };
     }
 }
-function assertPrincipal(principal) {
-    requiredText(principal.userId, 'Authenticated user id');
-    if (!Array.isArray(principal.scopes))
-        throw new ForbiddenError();
-    principal.targetIds?.forEach((targetId) => id(targetId, 'Authorized target id'));
-}
-function assertScope(principal, scope) {
-    if (!principal.scopes.includes('*') && !principal.scopes.includes(scope)) {
-        throw new ForbiddenError(`This credential requires ${scope}`);
-    }
-}
-function assertTarget(principal, targetId) {
-    if (principal.targetIds && !principal.targetIds.includes(targetId)) {
-        throw new ForbiddenError('This credential cannot access that target');
-    }
-}