@amalgm/automations 0.1.0

package/dist/src/client.js

@@ -0,0 +1,85 @@
+import { AutomationError } from './errors.js';
+export function createAutomationClient(options) {
+    const baseUrl = options.baseUrl.replace(/\/$/, '');
+    const request = createRequester(baseUrl, options.authorization, options.fetch || globalThis.fetch);
+    return {
+        automations: {
+            create: (input) => request('/v1/automations', 'POST', input),
+            list: (query = {}) => request(`/v1/automations${queryString(query)}`, 'GET'),
+            get: (automationId) => request(`/v1/automations/${part(automationId)}`, 'GET', undefined, true),
+            update: (automationId, patch) => request(`/v1/automations/${part(automationId)}`, 'PATCH', patch),
+            delete: (automationId) => request(`/v1/automations/${part(automationId)}`, 'DELETE'),
+        },
+        triggers: {
+            list: (automationId) => request(`/v1/automations/${part(automationId)}/triggers`, 'GET'),
+            schedule: {
+                create: (automationId, input) => request(schedulePath(automationId), 'POST', input),
+                list: (automationId, query = {}) => request(`${schedulePath(automationId)}${queryString(query)}`, 'GET'),
+                get: (automationId, triggerId) => request(`${schedulePath(automationId)}/${part(triggerId)}`, 'GET', undefined, true),
+                update: (automationId, triggerId, patch) => request(`${schedulePath(automationId)}/${part(triggerId)}`, 'PATCH', patch),
+                delete: (automationId, triggerId) => request(`${schedulePath(automationId)}/${part(triggerId)}`, 'DELETE'),
+            },
+            webhook: {
+                create: (automationId, input) => request(webhookPath(automationId), 'POST', input),
+                list: (automationId, query = {}) => request(`${webhookPath(automationId)}${queryString(query)}`, 'GET'),
+                get: (automationId, triggerId) => request(`${webhookPath(automationId)}/${part(triggerId)}`, 'GET', undefined, true),
+                update: (automationId, triggerId, patch) => request(`${webhookPath(automationId)}/${part(triggerId)}`, 'PATCH', patch),
+                delete: (automationId, triggerId) => request(`${webhookPath(automationId)}/${part(triggerId)}`, 'DELETE'),
+            },
+        },
+        workflow: {
+            create: (automationId, input) => request(workflowPath(automationId), 'POST', input),
+            get: (automationId) => request(workflowPath(automationId), 'GET', undefined, true),
+            update: (automationId, patch) => request(workflowPath(automationId), 'PATCH', patch),
+            delete: (automationId) => request(workflowPath(automationId), 'DELETE'),
+        },
+        runs: {
+            list: (automationId, query = {}) => request(`${runsPath(automationId)}${queryString(query)}`, 'GET'),
+            get: (automationId, runId) => request(`${runsPath(automationId)}/${part(runId)}`, 'GET', undefined, true),
+        },
+    };
+}
+function createRequester(baseUrl, authorization, fetch) {
+    return async (path, method, body, nullable = false) => {
+        const token = await authorization();
+        const response = await fetch(`${baseUrl}${path}`, {
+            method,
+            headers: {
+                accept: 'application/json',
+                ...(body === undefined ? {} : { 'content-type': 'application/json' }),
+                ...(token ? { authorization: token } : {}),
+            },
+            ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+        });
+        if (response.status === 204)
+            return undefined;
+        const payload = await response.json().catch(() => ({}));
+        if (response.status === 404 && nullable)
+            return null;
+        if (!response.ok) {
+            throw new AutomationError(payload.code === 'conflict' || payload.code === 'forbidden' || payload.code === 'internal' || payload.code === 'not_found'
+                ? payload.code
+                : response.status >= 500 ? 'internal' : 'validation', payload.error || `Automations API returned ${response.status}`);
+        }
+        return payload;
+    };
+}
+function part(value) {
+    return encodeURIComponent(value);
+}
+function schedulePath(automationId) {
+    return `/v1/automations/${part(automationId)}/triggers/schedules`;
+}
+function webhookPath(automationId) {
+    return `/v1/automations/${part(automationId)}/triggers/webhooks`;
+}
+function workflowPath(automationId) {
+    return `/v1/automations/${part(automationId)}/workflow`;
+}
+function runsPath(automationId) {
+    return `/v1/automations/${part(automationId)}/runs`;
+}
+function queryString(query) {
+    const entries = Object.entries(query).filter(([, value]) => value !== undefined);
+    return entries.length === 0 ? '' : `?${new URLSearchParams(entries.map(([key, value]) => [key, String(value)])).toString()}`;
+}

package/dist/src/contract.d.ts

@@ -0,0 +1,176 @@
+export type Json = null | boolean | number | string | Json[] | {
+    [key: string]: Json;
+};
+export type AutomationScope = 'automations:read' | 'automations:write' | 'runs:read' | '*';
+/** Identity resolved by Amalgm before the SDK is bound to a caller. */
+export interface AutomationPrincipal {
+    userId: string;
+    scopes: readonly AutomationScope[];
+    /** Omit to permit every target owned by this principal. */
+    targetIds?: readonly string[];
+}
+export interface PageQuery {
+    limit?: number;
+    offset?: number;
+}
+export interface Page<T> {
+    items: T[];
+    total: number;
+    limit: number;
+    offset: number;
+    hasMore: boolean;
+}
+export interface Automation {
+    id: string;
+    targetId: string;
+    name?: string;
+    description?: string;
+    enabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreateAutomation {
+    id?: string;
+    targetId: string;
+    name?: string;
+    description?: string;
+    enabled?: boolean;
+}
+export interface UpdateAutomation {
+    targetId?: string;
+    name?: string | null;
+    description?: string | null;
+    enabled?: boolean;
+}
+export interface ListAutomations extends PageQuery {
+    targetId?: string;
+    enabled?: boolean;
+}
+interface TriggerBase {
+    id: string;
+    automationId: string;
+    enabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ScheduleTrigger extends TriggerBase {
+    kind: 'schedule';
+    cron: string;
+    timezone: string;
+}
+export interface WebhookTrigger extends TriggerBase {
+    kind: 'webhook';
+    source: string;
+    event: string;
+    secretConfigured: boolean;
+}
+export type Trigger = ScheduleTrigger | WebhookTrigger;
+export interface CreateScheduleTrigger {
+    id?: string;
+    cron: string;
+    timezone?: string;
+    enabled?: boolean;
+}
+export interface UpdateScheduleTrigger {
+    cron?: string;
+    timezone?: string;
+    enabled?: boolean;
+}
+export interface CreateWebhookTrigger {
+    id?: string;
+    source?: string;
+    event?: string;
+    secret: string;
+    enabled?: boolean;
+}
+export interface UpdateWebhookTrigger {
+    source?: string;
+    event?: string;
+    secret?: string;
+    enabled?: boolean;
+}
+export interface Workflow {
+    id: string;
+    automationId: string;
+    name?: string;
+    script: string;
+    compiled?: Json;
+    allowlist?: Json;
+    limits?: Json;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreateWorkflow {
+    id?: string;
+    name?: string;
+    script: string;
+    compiled?: Json;
+    allowlist?: Json;
+    limits?: Json;
+}
+export interface UpdateWorkflow {
+    name?: string | null;
+    script?: string;
+    compiled?: Json | null;
+    allowlist?: Json | null;
+    limits?: Json | null;
+}
+export type RunStatus = 'pending' | 'sent' | 'running' | 'completed' | 'failed';
+export interface AutomationRun {
+    id: string;
+    automationId: string;
+    triggerId: string;
+    workflowId: string;
+    targetId: string;
+    status: RunStatus;
+    input: Json;
+    createdAt: string;
+    sentAt?: string;
+    startedAt?: string;
+    finishedAt?: string;
+    output?: Json;
+    error?: string;
+}
+export interface ListRuns extends PageQuery {
+    status?: RunStatus;
+}
+export interface AutomationCrud {
+    readonly automations: {
+        create(input: CreateAutomation): Promise<Automation>;
+        list(query?: ListAutomations): Promise<Page<Automation>>;
+        get(automationId: string): Promise<Automation | null>;
+        update(automationId: string, patch: UpdateAutomation): Promise<Automation>;
+        delete(automationId: string): Promise<void>;
+    };
+    readonly triggers: {
+        list(automationId: string): Promise<Trigger[]>;
+        readonly schedule: {
+            create(automationId: string, input: CreateScheduleTrigger): Promise<ScheduleTrigger>;
+            list(automationId: string, query?: PageQuery): Promise<Page<ScheduleTrigger>>;
+            get(automationId: string, triggerId: string): Promise<ScheduleTrigger | null>;
+            update(automationId: string, triggerId: string, patch: UpdateScheduleTrigger): Promise<ScheduleTrigger>;
+            delete(automationId: string, triggerId: string): Promise<void>;
+        };
+        readonly webhook: {
+            create(automationId: string, input: CreateWebhookTrigger): Promise<WebhookTrigger>;
+            list(automationId: string, query?: PageQuery): Promise<Page<WebhookTrigger>>;
+            get(automationId: string, triggerId: string): Promise<WebhookTrigger | null>;
+            update(automationId: string, triggerId: string, patch: UpdateWebhookTrigger): Promise<WebhookTrigger>;
+            delete(automationId: string, triggerId: string): Promise<void>;
+        };
+    };
+    readonly workflow: {
+        create(automationId: string, input: CreateWorkflow): Promise<Workflow>;
+        get(automationId: string): Promise<Workflow | null>;
+        update(automationId: string, patch: UpdateWorkflow): Promise<Workflow>;
+        delete(automationId: string): Promise<void>;
+    };
+    readonly runs: {
+        list(automationId: string, query?: ListRuns): Promise<Page<AutomationRun>>;
+        get(automationId: string, runId: string): Promise<AutomationRun | null>;
+    };
+}
+export interface AutomationCrudService {
+    for(principal: AutomationPrincipal): AutomationCrud;
+}
+export {};

package/dist/src/contract.js

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

package/dist/src/crud.d.ts

@@ -0,0 +1,32 @@
+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 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: Required<CreateScheduleTrigger>): 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: 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<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>;
+export declare class AutomationCrudService implements AutomationCrudServiceContract {
+    private readonly repository;
+    constructor(repository: AutomationCrudRepository);
+    for(principal: AutomationPrincipal): AutomationCrud;
+}

package/dist/src/crud.js

@@ -0,0 +1,241 @@
+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';
+export class AutomationCrudService {
+    repository;
+    constructor(repository) {
+        this.repository = repository;
+    }
+    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');
+        };
+        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,
+                        });
+                    },
+                    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);
+                        if (parsed.cron !== undefined || parsed.timezone !== undefined) {
+                            const existing = await this.repository.getScheduleTrigger(principal.userId, automationId, triggerId);
+                            if (!existing)
+                                throw new NotFoundError('Schedule trigger');
+                            schedule(parsed.cron ?? existing.cron, parsed.timezone ?? existing.timezone);
+                        }
+                        const updated = await this.repository.updateScheduleTrigger(principal.userId, automationId, id(triggerId, 'Schedule trigger id'), parsed);
+                        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'));
+                },
+            },
+        };
+    }
+}
+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');
+    }
+}

package/dist/src/errors.d.ts

@@ -0,0 +1,17 @@
+export type AutomationErrorCode = 'conflict' | 'forbidden' | 'internal' | 'not_found' | 'validation';
+export declare class AutomationError extends Error {
+    readonly code: AutomationErrorCode;
+    constructor(code: AutomationErrorCode, message: string);
+}
+export declare class ValidationError extends AutomationError {
+    constructor(message: string);
+}
+export declare class ForbiddenError extends AutomationError {
+    constructor(message?: string);
+}
+export declare class ConflictError extends AutomationError {
+    constructor(resource: string);
+}
+export declare class NotFoundError extends AutomationError {
+    constructor(resource: string);
+}

package/dist/src/errors.js

@@ -0,0 +1,32 @@
+export class AutomationError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'AutomationError';
+    }
+}
+export class ValidationError extends AutomationError {
+    constructor(message) {
+        super('validation', message);
+        this.name = 'ValidationError';
+    }
+}
+export class ForbiddenError extends AutomationError {
+    constructor(message = 'This credential cannot access Automations') {
+        super('forbidden', message);
+        this.name = 'ForbiddenError';
+    }
+}
+export class ConflictError extends AutomationError {
+    constructor(resource) {
+        super('conflict', `${resource} already exists`);
+        this.name = 'ConflictError';
+    }
+}
+export class NotFoundError extends AutomationError {
+    constructor(resource) {
+        super('not_found', `${resource} was not found`);
+        this.name = 'NotFoundError';
+    }
+}

package/dist/src/http.d.ts

@@ -0,0 +1,7 @@
+import type { AutomationCrudService, AutomationPrincipal } from './contract.js';
+export type AuthenticateAutomationRequest = (request: Request) => Promise<AutomationPrincipal>;
+export type AutomationApi = (request: Request) => Promise<Response>;
+export declare function createAutomationApi(options: {
+    service: AutomationCrudService;
+    authenticate: AuthenticateAutomationRequest;
+}): AutomationApi;