@amalgm/automations 0.1.2 → 0.2.1

package/dist/src/contract.d.ts

@@ -1,7 +1,7 @@
 export type Json = null | boolean | number | string | Json[] | {
     [key: string]: Json;
 };
-export type AutomationScope = 'automations:read' | 'automations:write' | 'runs:read' | '*';
+export type AutomationScope = 'automations:read' | 'automations:write' | 'runs:read' | 'runs:execute' | '*';
 /** Identity resolved by Amalgm before the SDK is bound to a caller. */
 export interface AutomationPrincipal {
     userId: string;
@@ -31,7 +31,8 @@ export interface Automation {
 }
 export interface CreateAutomation {
     id?: string;
-    targetId: string;
+    /** Omit when the authenticated principal resolves exactly one target. */
+    targetId?: string;
     name?: string;
     description?: string;
     enabled?: boolean;
@@ -57,6 +58,9 @@ export interface ScheduleTrigger extends TriggerBase {
     kind: 'schedule';
     cron: string;
     timezone: string;
+    nextRunAt: string;
+    maxOccurrences?: number;
+    remainingOccurrences?: number;
 }
 export interface WebhookTrigger extends TriggerBase {
     kind: 'webhook';
@@ -70,11 +74,24 @@ export interface CreateScheduleTrigger {
     cron: string;
     timezone?: string;
     enabled?: boolean;
+    /** Omit for an unbounded schedule. */
+    maxOccurrences?: number;
 }
 export interface UpdateScheduleTrigger {
     cron?: string;
     timezone?: string;
     enabled?: boolean;
+    /** Set a new finite budget, or null to make the schedule unbounded. */
+    maxOccurrences?: number | null;
+}
+export interface ToolActionStep {
+    id: string;
+    actionId: string;
+    input: Json;
+}
+export interface AutomationPlan {
+    version: 1;
+    steps: ToolActionStep[];
 }
 export interface CreateWebhookTrigger {
     id?: string;

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

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

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, resolveTarget } from './context.js';
+export function automationOperations(context) {
+    const { principal, repository } = context;
+    return {
+        create: async (input) => {
+            context.write();
+            const parsed = parseCreateAutomation(input);
+            const targetId = resolveTarget(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,
+                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,14 @@
+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;
+export declare function resolveTarget(principal: AutomationPrincipal, targetId?: string): string;

package/dist/src/crud/context.js

@@ -0,0 +1,43 @@
+import { ForbiddenError, NotFoundError, ValidationError } 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');
+    }
+}
+export function resolveTarget(principal, targetId) {
+    if (targetId) {
+        assertTarget(principal, targetId);
+        return id(targetId, 'targetId');
+    }
+    if (principal.targetIds?.length === 1)
+        return principal.targetIds[0];
+    throw new ValidationError('targetId is required unless the credential resolves exactly one 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;