@dxos/functions 0.5.3-main.bbd33a9 → 0.5.3-main.bfb5bca

package/schema/functions.json

@@ -51,6 +51,11 @@
             "description": "Function URI.",
             "title": "string"
           },
+          "enabled": {
+            "type": "boolean",
+            "description": "a boolean",
+            "title": "boolean"
+          },
           "meta": {
             "$ref": "#/$defs/object"
           },

package/src/runtime/dev-server.ts

@@ -46,6 +46,7 @@ export class DevServer {
     private readonly _functionsRegistry: FunctionRegistry,
     private readonly _options: DevServerOptions,
   ) {
+    // TODO(burdon): Add/remove listener in start/stop.
     this._functionsRegistry.registered.on(async ({ added }) => {
       added.forEach((def) => this._load(def));
       await this._safeUpdateRegistration();
@@ -188,8 +189,8 @@ export class DevServer {
         registrationId: this._functionServiceRegistration,
         functions: this.functions.map(({ def: { id, route } }) => ({ id, route })),
       });
-    } catch (e) {
-      log.catch(e);
+    } catch (err) {
+      log.catch(err);
     }
   }
 
@@ -211,7 +212,6 @@ export class DevServer {
   private async _invoke(path: string, event: FunctionEvent) {
     const { handler } = this._handlers[path] ?? {};
     invariant(handler, `invalid path: ${path}`);
-
     const context: FunctionContext = {
       client: this._client,
       dataDir: this._options.dataDir,

package/src/runtime/scheduler.test.ts

@@ -29,6 +29,15 @@ describe('scheduler', () => {
     await testBuilder.destroy();
   });
 
+  const createScheduler = (callback: SchedulerOptions['callback']) => {
+    const scheduler = new Scheduler(new FunctionRegistry(client), new TriggerRegistry(client), { callback });
+    after(async () => {
+      await scheduler.stop();
+    });
+
+    return scheduler;
+  };
+
   test('timer', async () => {
     const manifest: FunctionManifest = {
       functions: [
@@ -41,6 +50,7 @@ describe('scheduler', () => {
       triggers: [
         {
           function: 'example.com/function/test',
+          enabled: true,
           spec: {
             type: 'timer',
             cron: '0/1 * * * * *', // Every 1s.
@@ -75,6 +85,7 @@ describe('scheduler', () => {
       triggers: [
         {
           function: 'example.com/function/test',
+          enabled: true,
           spec: {
             type: 'webhook',
             method: 'GET',
@@ -108,6 +119,7 @@ describe('scheduler', () => {
       triggers: [
         {
           function: 'example.com/function/test',
+          enabled: true,
           spec: {
             type: 'websocket',
             // url: 'https://hub.dxos.network/api/mailbox/test',
@@ -154,6 +166,7 @@ describe('scheduler', () => {
       triggers: [
         {
           function: 'example.com/function/test',
+          enabled: true,
           spec: {
             type: 'subscription',
             filter: [{ type: TestType.typename }],
@@ -165,7 +178,7 @@ describe('scheduler', () => {
     let count = 0;
     const done = new Trigger();
     const scheduler = createScheduler(async () => {
-      if (++count === 2) {
+      if (++count === 1) {
         done.wake();
       }
     });
@@ -180,12 +193,4 @@ describe('scheduler', () => {
 
     await done.wait();
   });
-
-  const createScheduler = (callback: SchedulerOptions['callback']) => {
-    const scheduler = new Scheduler(new FunctionRegistry(client), new TriggerRegistry(client), { callback });
-    after(async () => {
-      await scheduler.stop();
-    });
-    return scheduler;
-  };
 });

package/src/runtime/scheduler.ts

@@ -72,28 +72,28 @@ export class Scheduler {
     await Promise.all(mountTasks).catch(log.catch);
   }
 
-  private async activate(space: Space, functions: FunctionDef[], fnTrigger: FunctionTrigger) {
-    const definition = functions.find((def) => def.uri === fnTrigger.function);
+  private async activate(space: Space, functions: FunctionDef[], trigger: FunctionTrigger) {
+    const definition = functions.find((def) => def.uri === trigger.function);
     if (!definition) {
-      log.info('function is not found for trigger', { fnTrigger });
+      log.info('function is not found for trigger', { trigger });
       return;
     }
 
-    await this.triggers.activate({ space }, fnTrigger, async (args) => {
+    await this.triggers.activate(space, trigger, async (args) => {
       const mutex = this._functionUriToCallMutex.get(definition.uri) ?? new Mutex();
       this._functionUriToCallMutex.set(definition.uri, mutex);
 
       log.info('function triggered, waiting for mutex', { uri: definition.uri });
       return mutex.executeSynchronized(() => {
         log.info('mutex acquired', { uri: definition.uri });
-        return this._execFunction(definition, fnTrigger, {
-          meta: fnTrigger.meta,
+        return this._execFunction(definition, trigger, {
+          meta: trigger.meta ?? {},
           data: { ...args, spaceKey: space.key },
         });
       });
     });
 
-    log('activated trigger', { space: space.key, trigger: fnTrigger });
+    log('activated trigger', { space: space.key, trigger });
   }
 
   private async _execFunction<TData, TMeta>(

package/src/testing/functions-integration.test.ts

@@ -44,6 +44,7 @@ describe('functions e2e', () => {
     space.db.add(
       create(FunctionTrigger, {
         function: uri,
+        enabled: true,
         meta: triggerMeta,
         spec: {
           type: 'subscription',

package/src/testing/setup.ts

@@ -10,16 +10,16 @@ import { range } from '@dxos/util';
 import { TestType } from './types';
 import { FunctionDef, FunctionTrigger } from '../types';
 
-// TODO(burdon): Create new or extend existing TestBuilder.
+// TODO(burdon): Extend/wrap TestBuilder.
 
 export const createInitializedClients = async (testBuilder: TestBuilder, count: number = 1, config?: Config) => {
   const clients = range(count).map(() => new Client({ config, services: testBuilder.createLocalClientServices() }));
-  testBuilder.ctx.onDispose(() => Promise.all(clients.map((c) => c.destroy())));
+  testBuilder.ctx.onDispose(() => Promise.all(clients.map((client) => client.destroy())));
   return Promise.all(
     clients.map(async (client, index) => {
       await client.initialize();
       await client.halo.createIdentity({ displayName: `Peer ${index}` });
-      client.addSchema(TestType, FunctionDef, FunctionTrigger);
+      client.addSchema(FunctionDef, FunctionTrigger, TestType);
       return client;
     }),
   );
@@ -34,12 +34,10 @@ export const createFunctionRuntime = async (testBuilder: TestBuilder): Promise<C
     },
   });
 
-  const client = (await createInitializedClients(testBuilder, 1, config))[0];
-
-  // TODO(burdon): Better way to configure plugin? (Rationalize chess.test).
-  const functionsPlugin = new FunctionsPlugin();
-  await functionsPlugin.initialize({ client, clientServices: client.services });
-  await functionsPlugin.open();
-  testBuilder.ctx.onDispose(() => functionsPlugin.close());
+  const [client] = await createInitializedClients(testBuilder, 1, config);
+  const plugin = new FunctionsPlugin();
+  await plugin.initialize({ client, clientServices: client.services });
+  await plugin.open();
+  testBuilder.ctx.onDispose(() => plugin.close());
   return client;
 };

package/src/trigger/trigger-registry.test.ts

@@ -31,6 +31,7 @@ const manifest: FunctionManifest = {
         ],
       },
       function: 'example.com/function/webhook-test',
+      enabled: true,
       spec: {
         type: 'webhook',
         method: 'GET',
@@ -46,6 +47,7 @@ const manifest: FunctionManifest = {
         ],
       },
       function: 'example.com/function/subscription-test',
+      enabled: true,
       spec: {
         type: 'subscription',
         filter: [
@@ -74,7 +76,7 @@ describe('trigger registry', () => {
 
   describe('register', () => {
     test('creates new triggers', async () => {
-      const client = (await createInitializedClients(testBuilder))[0];
+      const [client] = await createInitializedClients(testBuilder);
       const registry = createRegistry(client);
       const space = await client.spaces.create();
       await registry.register(space, manifest);
@@ -84,11 +86,24 @@ describe('trigger registry', () => {
       const expected = manifest.triggers?.map((trigger) => trigger.function).sort();
       expect(objects.map((object: FunctionTrigger) => object.function).sort()).to.deep.eq(expected);
     });
+
+    test('set meta', () => {
+      const trigger = create(FunctionTrigger, {
+        function: 'example.com/function/webhook-test',
+        spec: {
+          type: 'webhook',
+          method: 'GET',
+        },
+      });
+
+      (trigger.meta ??= {}).test = 100;
+      expect(trigger.meta.test).to.eq(100);
+    });
   });
 
   describe('activate', () => {
     test('invokes the provided callback', async () => {
-      const client = (await createInitializedClients(testBuilder))[0];
+      const [client] = await createInitializedClients(testBuilder);
       const space = await client.spaces.create();
       const registry = createRegistry(client);
       await registry.register(space, manifest);
@@ -98,7 +113,7 @@ describe('trigger registry', () => {
       const callbackInvoked = new Trigger();
       const { objects: allTriggers } = await space.db.query(Filter.schema(FunctionTrigger)).run();
       const webhookTrigger = allTriggers.find((trigger: FunctionTrigger) => trigger.spec.type === 'webhook')!;
-      await registry.activate({ space }, webhookTrigger, async () => {
+      await registry.activate(space, webhookTrigger, async () => {
         callbackInvoked.wake();
         return 200;
       });
@@ -108,7 +123,7 @@ describe('trigger registry', () => {
     });
 
     test('removes from inactive list', async () => {
-      const client = (await createInitializedClients(testBuilder))[0];
+      const [client] = await createInitializedClients(testBuilder);
       const space = await client.spaces.create();
       const registry = createRegistry(client);
       await registry.register(space, manifest);
@@ -116,17 +131,19 @@ describe('trigger registry', () => {
       await waitForInactiveTriggers(registry, space);
 
       const inactiveTrigger = registry.getInactiveTriggers(space)[0];
-      await registry.activate({ space }, inactiveTrigger, async () => 200);
+      await registry.activate(space, inactiveTrigger, async () => 200);
 
       const updatedInactiveList = registry.getInactiveTriggers(space);
       expect(updatedInactiveList.find((trigger: FunctionTrigger) => trigger.function === inactiveTrigger.function)).to
         .be.undefined;
     });
+
+    // TODO(burdon): Test enable/disable trigger.
   });
 
   describe('deactivate', () => {
     test('trigger object deletion deactivates a trigger', async () => {
-      const client = (await createInitializedClients(testBuilder))[0];
+      const [client] = await createInitializedClients(testBuilder);
       const space = await client.spaces.create();
       const registry = createRegistry(client);
       await registry.register(space, manifest);
@@ -136,7 +153,7 @@ describe('trigger registry', () => {
       const { objects: allTriggers } = await space.db.query(Filter.schema(FunctionTrigger)).run();
       const echoTrigger = allTriggers.find((trigger: FunctionTrigger) => trigger.spec.type === 'subscription')!;
       let count = 0;
-      await registry.activate({ space }, echoTrigger, async () => {
+      await registry.activate(space, echoTrigger, async () => {
         count++;
         return 200;
       });
@@ -152,7 +169,7 @@ describe('trigger registry', () => {
     });
 
     test('registry closing deactivates a trigger', async () => {
-      const client = (await createInitializedClients(testBuilder))[0];
+      const [client] = await createInitializedClients(testBuilder);
       const space = await client.spaces.create();
       const registry = createRegistry(client);
       await registry.register(space, manifest);
@@ -162,7 +179,7 @@ describe('trigger registry', () => {
       const { objects: allTriggers } = await space.db.query(Filter.schema(FunctionTrigger)).run();
       const echoTrigger = allTriggers.find((trigger: FunctionTrigger) => trigger.spec.type === 'subscription')!;
       let count = 0;
-      await registry.activate({ space }, echoTrigger, async () => {
+      await registry.activate(space, echoTrigger, async () => {
         count++;
         return 200;
       });
@@ -176,8 +193,8 @@ describe('trigger registry', () => {
   });
 
   describe('trigger events', () => {
-    test.only('event fired when all registered when opened', async () => {
-      const client = (await createInitializedClients(testBuilder))[0];
+    test('event fired when all registered when opened', async () => {
+      const [client] = await createInitializedClients(testBuilder);
       const registry = createRegistry(client);
       const triggers = createTriggers(client.spaces.default, 3);
 
@@ -194,7 +211,7 @@ describe('trigger registry', () => {
     });
 
     test('event fired when a new trigger is added', async () => {
-      const client = (await createInitializedClients(testBuilder))[0];
+      const [client] = await createInitializedClients(testBuilder);
       const registry = createRegistry(client);
       const space = await client.spaces.create();
 
@@ -210,7 +227,7 @@ describe('trigger registry', () => {
     });
 
     test('event fired when a new trigger is removed', async () => {
-      const client = (await createInitializedClients(testBuilder))[0];
+      const [client] = await createInitializedClients(testBuilder);
       const registry = createRegistry(client);
       const space = await client.spaces.create();
       const triggers = createTriggers(space, 3);

package/src/trigger/trigger-registry.ts

@@ -6,11 +6,11 @@ import { Event } from '@dxos/async';
 import { type Client } from '@dxos/client';
 import { create, Filter, getMeta, type Space } from '@dxos/client/echo';
 import { Context, Resource } from '@dxos/context';
-import { ECHO_ATTR_META, foreignKey, foreignKeyEquals, splitMeta } from '@dxos/echo-schema';
+import { compareForeignKeys, ECHO_ATTR_META, foreignKey } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { ComplexMap, diff, intersection } from '@dxos/util';
+import { ComplexMap, diff } from '@dxos/util';
 
 import { createSubscriptionTrigger, createTimerTrigger, createWebhookTrigger, createWebsocketTrigger } from './type';
 import { type FunctionManifest, FunctionTrigger, type FunctionTriggerType, type TriggerSpec } from '../types';
@@ -19,12 +19,10 @@ type ResponseCode = number;
 
 export type TriggerCallback = (args: object) => Promise<ResponseCode>;
 
-export type TriggerContext = { space: Space };
-
 // TODO(burdon): Make object?
 export type TriggerFactory<Spec extends TriggerSpec, Options = any> = (
   ctx: Context,
-  context: TriggerContext,
+  space: Space,
   spec: Spec,
   callback: TriggerCallback,
   options?: Options,
@@ -70,19 +68,18 @@ export class TriggerRegistry extends Resource {
     return this._getTriggers(space, (t) => t.activationCtx == null);
   }
 
-  async activate(triggerCtx: TriggerContext, trigger: FunctionTrigger, callback: TriggerCallback): Promise<void> {
-    log('activate', { space: triggerCtx.space.key, trigger });
-    const activationCtx = new Context({ name: `trigger_${trigger.function}` });
+  async activate(space: Space, trigger: FunctionTrigger, callback: TriggerCallback): Promise<void> {
+    log('activate', { space: space.key, trigger });
+
+    const activationCtx = new Context({ name: `FunctionTrigger-${trigger.function}` });
     this._ctx.onDispose(() => activationCtx.dispose());
-    const registeredTrigger = this._triggersBySpaceKey
-      .get(triggerCtx.space.key)
-      ?.find((reg) => reg.trigger.id === trigger.id);
+    const registeredTrigger = this._triggersBySpaceKey.get(space.key)?.find((reg) => reg.trigger.id === trigger.id);
     invariant(registeredTrigger, `Trigger is not registered: ${trigger.function}`);
     registeredTrigger.activationCtx = activationCtx;
 
     try {
       const options = this._options?.[trigger.spec.type];
-      await triggerHandlers[trigger.spec.type](activationCtx, triggerCtx, trigger.spec, callback, options);
+      await triggerHandlers[trigger.spec.type](activationCtx, space, trigger.spec, callback, options);
     } catch (err) {
       delete registeredTrigger.activationCtx;
       throw err;
@@ -97,24 +94,35 @@ export class TriggerRegistry extends Resource {
     if (!manifest.triggers?.length) {
       return;
     }
+
     if (!space.db.graph.runtimeSchemaRegistry.hasSchema(FunctionTrigger)) {
       space.db.graph.runtimeSchemaRegistry.registerSchema(FunctionTrigger);
     }
 
+    // Create FK to enable syncing if none are set (NOTE: Possible collision).
+    const manifestTriggers = manifest.triggers.map((trigger) => {
+      let keys = trigger[ECHO_ATTR_META]?.keys;
+      delete trigger[ECHO_ATTR_META];
+      if (!keys?.length) {
+        keys = [foreignKey('manifest', [trigger.function, trigger.spec.type].join(':'))];
+      }
+
+      return create(FunctionTrigger, trigger, { keys });
+    });
+
     // Sync triggers.
     const { objects: existing } = await space.db.query(Filter.schema(FunctionTrigger)).run();
-    const { added } = diff(existing, manifest.triggers, (a, b) => {
-      // Create FK to enable syncing if none are set.
-      // TODO(burdon): Warn if not unique.
-      const keys = b[ECHO_ATTR_META]?.keys ?? [foreignKey('manifest', [b.function, b.spec.type].join('-'))];
-      return intersection(getMeta(a)?.keys ?? [], keys, foreignKeyEquals).length > 0;
-    });
+    const { added } = diff(existing, manifestTriggers, compareForeignKeys);
 
     // TODO(burdon): Update existing.
     added.forEach((trigger) => {
-      const { meta, object } = splitMeta(trigger);
-      space.db.add(create(FunctionTrigger, object, meta));
+      space.db.add(trigger);
+      log.info('added', { meta: getMeta(trigger) });
     });
+
+    if (added.length > 0) {
+      await space.db.flush();
+    }
   }
 
   protected override async _open(): Promise<void> {
@@ -134,55 +142,52 @@ export class TriggerRegistry extends Resource {
 
         // Subscribe to updates.
         this._ctx.onDispose(
-          space.db.query(Filter.schema(FunctionTrigger)).subscribe(async (triggers) => {
-            log.info('update', { space: space.key, triggers: triggers.objects.length });
-            await this._handleRemovedTriggers(space, triggers.objects, registered);
-            this._handleNewTriggers(space, triggers.objects, registered);
+          space.db.query(Filter.schema(FunctionTrigger)).subscribe(async ({ objects: current }) => {
+            log.info('update', { space: space.key, registered: registered.length, current: current.length });
+            await this._handleRemovedTriggers(space, current, registered);
+            this._handleNewTriggers(space, current, registered);
           }),
         );
       }
     });
 
     this._ctx.onDispose(() => spaceListSubscription.unsubscribe());
+    log.info('opened');
   }
 
   protected override async _close(_: Context): Promise<void> {
     log.info('close...');
     this._triggersBySpaceKey.clear();
+    log.info('closed');
   }
 
-  private _handleNewTriggers(space: Space, allTriggers: FunctionTrigger[], registered: RegisteredTrigger[]) {
-    const newTriggers = allTriggers.filter((candidate) => {
-      return registered.find((reg) => reg.trigger.id === candidate.id) == null;
+  private _handleNewTriggers(space: Space, current: FunctionTrigger[], registered: RegisteredTrigger[]) {
+    const added = current.filter((candidate) => {
+      return candidate.enabled && registered.find((reg) => reg.trigger.id === candidate.id) == null;
     });
 
-    if (newTriggers.length > 0) {
-      const newRegisteredTriggers: RegisteredTrigger[] = newTriggers.map((trigger) => ({ trigger }));
+    if (added.length > 0) {
+      const newRegisteredTriggers: RegisteredTrigger[] = added.map((trigger) => ({ trigger }));
       registered.push(...newRegisteredTriggers);
       log.info('added', () => ({
         spaceKey: space.key,
-        triggers: newTriggers.map((trigger) => trigger.function),
+        triggers: added.map((trigger) => trigger.function),
       }));
-      this.registered.emit({ space, triggers: newTriggers });
+
+      this.registered.emit({ space, triggers: added });
     }
   }
 
   private async _handleRemovedTriggers(
     space: Space,
-    allTriggers: FunctionTrigger[],
+    current: FunctionTrigger[],
     registered: RegisteredTrigger[],
   ): Promise<void> {
     const removed: FunctionTrigger[] = [];
     for (let i = registered.length - 1; i >= 0; i--) {
       const wasRemoved =
-        allTriggers.find((trigger: FunctionTrigger) => trigger.id === registered[i].trigger.id) == null;
+        current.filter((trigger) => trigger.enabled).find((trigger) => trigger.id === registered[i].trigger.id) == null;
       if (wasRemoved) {
-        if (removed.length) {
-          log.info('removed', () => ({
-            spaceKey: space.key,
-            triggers: removed.map((trigger) => trigger.function),
-          }));
-        }
         const unregistered = registered.splice(i, 1)[0];
         await unregistered.activationCtx?.dispose();
         removed.push(unregistered.trigger);
@@ -190,6 +195,11 @@ export class TriggerRegistry extends Resource {
     }
 
     if (removed.length > 0) {
+      log.info('removed', () => ({
+        spaceKey: space.key,
+        triggers: removed.map((trigger) => trigger.function),
+      }));
+
       this.removed.emit({ space, triggers: removed });
     }
   }

package/src/trigger/type/subscription-trigger.ts

@@ -4,16 +4,17 @@
 
 import { TextV0Type } from '@braneframe/types';
 import { debounce, UpdateScheduler } from '@dxos/async';
+import { Filter, type Space } from '@dxos/client/echo';
 import { type Context } from '@dxos/context';
-import { createSubscription, Filter, getAutomergeObjectCore, type Query } from '@dxos/echo-db';
+import { createSubscription, getAutomergeObjectCore, type Query } from '@dxos/echo-db';
 import { log } from '@dxos/log';
 
 import type { SubscriptionTrigger } from '../../types';
-import { type TriggerCallback, type TriggerContext, type TriggerFactory } from '../trigger-registry';
+import { type TriggerCallback, type TriggerFactory } from '../trigger-registry';
 
 export const createSubscriptionTrigger: TriggerFactory<SubscriptionTrigger> = async (
   ctx: Context,
-  triggerCtx: TriggerContext,
+  space: Space,
   spec: SubscriptionTrigger,
   callback: TriggerCallback,
 ) => {
@@ -30,6 +31,7 @@ export const createSubscriptionTrigger: TriggerFactory<SubscriptionTrigger> = as
     { maxFrequency: 4 },
   );
 
+  // TODO(burdon): Factor out diff.
   // TODO(burdon): Don't fire initially?
   // TODO(burdon): Create queue. Only allow one invocation per trigger at a time?
   const subscriptions: (() => void)[] = [];
@@ -52,11 +54,11 @@ export const createSubscriptionTrigger: TriggerFactory<SubscriptionTrigger> = as
   // TODO(burdon): Disable trigger if keeps failing.
   const { filter, options: { deep, delay } = {} } = spec;
   const update = ({ objects }: Query) => {
+    log.info('update', { objects: objects.length });
     subscription.update(objects);
 
     // TODO(burdon): Hack to monitor changes to Document's text object.
     if (deep) {
-      log.info('update', { objects: objects.length });
       for (const object of objects) {
         const content = object.content;
         if (content instanceof TextV0Type) {
@@ -68,11 +70,15 @@ export const createSubscriptionTrigger: TriggerFactory<SubscriptionTrigger> = as
     }
   };
 
-  // TODO(burdon): Is Filter.or implemented?
+  // TODO(burdon): OR not working.
   // TODO(burdon): [Bug]: all callbacks are fired on the first mutation.
   // TODO(burdon): [Bug]: not updated when document is deleted (either top or hierarchically).
-  const query = triggerCtx.space.db.query(Filter.or(filter.map(({ type, props }) => Filter.typename(type, props))));
-  subscriptions.push(query.subscribe(delay ? debounce(update, delay) : update));
+  log.info('subscription', { filter });
+  // const query = triggerCtx.space.db.query(Filter.or(filter.map(({ type, props }) => Filter.typename(type, props))));
+  if (filter) {
+    const query = space.db.query(Filter.typename(filter[0].type, filter[0].props));
+    subscriptions.push(query.subscribe(delay ? debounce(update, delay) : update));
+  }
 
   ctx.onDispose(() => {
     subscriptions.forEach((unsubscribe) => unsubscribe());

package/src/trigger/type/timer-trigger.ts

@@ -5,15 +5,16 @@
 import { CronJob } from 'cron';
 
 import { DeferredTask } from '@dxos/async';
+import { type Space } from '@dxos/client/echo';
 import { type Context } from '@dxos/context';
 import { log } from '@dxos/log';
 
 import type { TimerTrigger } from '../../types';
-import { type TriggerCallback, type TriggerContext, type TriggerFactory } from '../trigger-registry';
+import { type TriggerCallback, type TriggerFactory } from '../trigger-registry';
 
 export const createTimerTrigger: TriggerFactory<TimerTrigger> = async (
   ctx: Context,
-  triggerContext: TriggerContext,
+  space: Space,
   spec: TimerTrigger,
   callback: TriggerCallback,
 ) => {
@@ -34,7 +35,7 @@ export const createTimerTrigger: TriggerFactory<TimerTrigger> = async (
       last = now;
 
       run++;
-      log.info('tick', { space: triggerContext.space.key.truncate(), count: run, delta });
+      log.info('tick', { space: space.key.truncate(), count: run, delta });
       task.schedule();
     },
   });

package/src/trigger/type/webhook-trigger.ts

@@ -5,15 +5,16 @@
 import { getPort } from 'get-port-please';
 import http from 'node:http';
 
+import { type Space } from '@dxos/client/echo';
 import { type Context } from '@dxos/context';
 import { log } from '@dxos/log';
 
 import type { WebhookTrigger } from '../../types';
-import { type TriggerCallback, type TriggerContext, type TriggerFactory } from '../trigger-registry';
+import { type TriggerCallback, type TriggerFactory } from '../trigger-registry';
 
 export const createWebhookTrigger: TriggerFactory<WebhookTrigger> = async (
   ctx: Context,
-  _: TriggerContext,
+  space: Space,
   spec: WebhookTrigger,
   callback: TriggerCallback,
 ) => {

package/src/trigger/type/websocket-trigger.ts

@@ -5,11 +5,12 @@
 import WebSocket from 'ws';
 
 import { sleep, Trigger } from '@dxos/async';
+import { type Space } from '@dxos/client/echo';
 import { type Context } from '@dxos/context';
 import { log } from '@dxos/log';
 
 import { type WebsocketTrigger } from '../../types';
-import { type TriggerCallback, type TriggerContext, type TriggerFactory } from '../trigger-registry';
+import { type TriggerCallback, type TriggerFactory } from '../trigger-registry';
 
 interface WebsocketTriggerOptions {
   retryDelay: number;
@@ -22,7 +23,7 @@ interface WebsocketTriggerOptions {
  */
 export const createWebsocketTrigger: TriggerFactory<WebsocketTrigger, WebsocketTriggerOptions> = async (
   ctx: Context,
-  triggerCtx: TriggerContext,
+  space: Space,
   spec: WebsocketTrigger,
   callback: TriggerCallback,
   options: WebsocketTriggerOptions = { retryDelay: 2, maxAttempts: 5 },
@@ -51,7 +52,7 @@ export const createWebsocketTrigger: TriggerFactory<WebsocketTrigger, WebsocketT
         if (event.code === 1006) {
           setTimeout(async () => {
             log.info(`reconnecting in ${options.retryDelay}s...`, { url });
-            await createWebsocketTrigger(ctx, triggerCtx, spec, callback, options);
+            await createWebsocketTrigger(ctx, space, spec, callback, options);
           }, options.retryDelay * 1_000);
         }