@dxos/functions 0.5.3-next.57eca40 → 0.5.3-next.63cdcad

package/dist/types/src/types.d.ts

@@ -6,7 +6,7 @@ import { S } from '@dxos/echo-schema';
  * https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions
  */
 export type FunctionTriggerType = 'subscription' | 'timer' | 'webhook' | 'websocket';
-declare const SubscriptionTriggerSchema: S.struct<{
+declare const SubscriptionTriggerSchema: S.mutable<S.struct<{
     type: S.literal<["subscription"]>;
     filter: S.array<S.struct<{
         type: S.$string;
@@ -23,12 +23,12 @@ declare const SubscriptionTriggerSchema: S.struct<{
         readonly deep?: boolean | undefined;
         readonly delay?: number | undefined;
     } | undefined, never>;
-}>;
+}>>;
 export type SubscriptionTrigger = S.Schema.Type<typeof SubscriptionTriggerSchema>;
-declare const TimerTriggerSchema: S.struct<{
+declare const TimerTriggerSchema: S.mutable<S.struct<{
     type: S.literal<["timer"]>;
     cron: S.$string;
-}>;
+}>>;
 export type TimerTrigger = S.Schema.Type<typeof TimerTriggerSchema>;
 declare const WebhookTriggerSchema: S.mutable<S.struct<{
     type: S.literal<["webhook"]>;
@@ -36,7 +36,7 @@ declare const WebhookTriggerSchema: S.mutable<S.struct<{
     port: S.PropertySignature<"?:", number | undefined, never, "?:", number | undefined, never>;
 }>>;
 export type WebhookTrigger = S.Schema.Type<typeof WebhookTriggerSchema>;
-declare const WebsocketTriggerSchema: S.struct<{
+declare const WebsocketTriggerSchema: S.mutable<S.struct<{
     type: S.literal<["websocket"]>;
     url: S.$string;
     init: S.PropertySignature<"?:", {
@@ -44,7 +44,7 @@ declare const WebsocketTriggerSchema: S.struct<{
     } | undefined, never, "?:", {
         readonly [x: string]: any;
     } | undefined, never>;
-}>;
+}>>;
 export type WebsocketTrigger = S.Schema.Type<typeof WebsocketTriggerSchema>;
 export type TriggerSpec = TimerTrigger | WebhookTrigger | WebsocketTrigger | SubscriptionTrigger;
 declare const FunctionDef_base: import("@dxos/echo-schema").EchoSchemaClass<{
@@ -62,36 +62,42 @@ export declare class FunctionDef extends FunctionDef_base {
 }
 declare const FunctionTrigger_base: import("@dxos/echo-schema").EchoSchemaClass<{
     function: string;
-    meta?: object | undefined;
+    enabled?: boolean | undefined;
+    meta?: {
+        [x: string]: any;
+    } | undefined;
     spec: {
-        readonly filter: readonly {
+        filter: readonly {
             readonly type: string;
             readonly props?: {
                 readonly [x: string]: any;
             } | undefined;
         }[];
-        readonly type: "subscription";
-        readonly options?: {
+        type: "subscription";
+        options?: {
             readonly deep?: boolean | undefined;
             readonly delay?: number | undefined;
         } | undefined;
     } | {
-        readonly type: "timer";
-        readonly cron: string;
+        type: "timer";
+        cron: string;
     } | {
         port?: number | undefined;
         type: "webhook";
         method: string;
     } | {
-        readonly type: "websocket";
-        readonly url: string;
-        readonly init?: {
+        type: "websocket";
+        url: string;
+        init?: {
             readonly [x: string]: any;
         } | undefined;
     };
 } & {
     id: string;
 }>;
+/**
+ * Function trigger.
+ */
 export declare class FunctionTrigger extends FunctionTrigger_base {
 }
 /**
@@ -125,30 +131,33 @@ export declare const FunctionManifestSchema: S.struct<{
     })[] | undefined, never>;
     triggers: S.PropertySignature<"?:", ({
         function: string;
-        meta?: object | undefined;
+        enabled?: boolean | undefined;
+        meta?: {
+            [x: string]: any;
+        } | undefined;
         spec: {
-            readonly filter: readonly {
+            filter: readonly {
                 readonly type: string;
                 readonly props?: {
                     readonly [x: string]: any;
                 } | undefined;
             }[];
-            readonly type: "subscription";
-            readonly options?: {
+            type: "subscription";
+            options?: {
                 readonly deep?: boolean | undefined;
                 readonly delay?: number | undefined;
             } | undefined;
         } | {
-            readonly type: "timer";
-            readonly cron: string;
+            type: "timer";
+            cron: string;
         } | {
             port?: number | undefined;
             type: "webhook";
             method: string;
         } | {
-            readonly type: "websocket";
-            readonly url: string;
-            readonly init?: {
+            type: "websocket";
+            url: string;
+            init?: {
                 readonly [x: string]: any;
             } | undefined;
         };
@@ -161,30 +170,33 @@ export declare const FunctionManifestSchema: S.struct<{
         } | undefined;
     })[] | undefined, never, "?:", ({
         function: string;
-        meta?: object | undefined;
+        enabled?: boolean | undefined;
+        meta?: {
+            [x: string]: any;
+        } | undefined;
         spec: {
-            readonly filter: readonly {
+            filter: readonly {
                 readonly type: string;
                 readonly props?: {
                     readonly [x: string]: any;
                 } | undefined;
             }[];
-            readonly type: "subscription";
-            readonly options?: {
+            type: "subscription";
+            options?: {
                 readonly deep?: boolean | undefined;
                 readonly delay?: number | undefined;
             } | undefined;
         } | {
-            readonly type: "timer";
-            readonly cron: string;
+            type: "timer";
+            cron: string;
         } | {
             port?: number | undefined;
             type: "webhook";
             method: string;
         } | {
-            readonly type: "websocket";
-            readonly url: string;
-            readonly init?: {
+            type: "websocket";
+            url: string;
+            init?: {
                 readonly [x: string]: any;
             } | undefined;
         };
@@ -198,5 +210,6 @@ export declare const FunctionManifestSchema: S.struct<{
     })[] | undefined, never>;
 }>;
 export type FunctionManifest = S.Schema.Type<typeof FunctionManifestSchema>;
+export declare const FUNCTION_SCHEMA: (typeof FunctionDef | typeof FunctionTrigger)[];
 export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/types/src/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAa,CAAC,EAAe,MAAM,mBAAmB,CAAC;AAE9D;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,cAAc,GAAG,OAAO,GAAG,SAAS,GAAG,WAAW,CAAC;AAErF,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;EAiB7B,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAElF,QAAA,MAAM,kBAAkB;;;EAGtB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,QAAA,MAAM,oBAAoB;;;;GAOzB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAExE,QAAA,MAAM,sBAAsB;;;;;;;;EAI1B,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAS5E,MAAM,MAAM,WAAW,GAAG,YAAY,GAAG,cAAc,GAAG,gBAAgB,GAAG,mBAAmB,CAAC;;;;;;;;;AAEjG;;GAEG;AACH,qBAAa,WAAY,SAAQ,gBAS/B;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,eAAgB,SAAQ,oBAQnC;CAAG;AAEL;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAa,CAAC,EAAe,MAAM,mBAAmB,CAAC;AAE9D;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,cAAc,GAAG,OAAO,GAAG,SAAS,GAAG,WAAW,CAAC;AAErF,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;GAmB9B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAElF,QAAA,MAAM,kBAAkB;;;GAKvB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,QAAA,MAAM,oBAAoB;;;;GAOzB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAExE,QAAA,MAAM,sBAAsB;;;;;;;;GAM3B,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAS5E,MAAM,MAAM,WAAW,GAAG,YAAY,GAAG,cAAc,GAAG,gBAAgB,GAAG,mBAAmB,CAAC;;;;;;;;;AAEjG;;GAEG;AACH,qBAAa,WAAY,SAAQ,gBAQ/B;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL;;GAEG;AACH,qBAAa,eAAgB,SAAQ,oBASnC;CAAG;AAEL;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAG5E,eAAO,MAAM,eAAe,iDAAiC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/functions",
-  "version": "0.5.3-next.57eca40",
+  "version": "0.5.3-next.63cdcad",
   "description": "Functions API and runtime.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -40,23 +40,23 @@
     "express": "^4.19.2",
     "get-port-please": "^3.1.1",
     "ws": "^8.14.2",
-    "@braneframe/types": "0.5.3-next.57eca40",
-    "@dxos/client": "0.5.3-next.57eca40",
-    "@dxos/context": "0.5.3-next.57eca40",
-    "@dxos/echo-db": "0.5.3-next.57eca40",
-    "@dxos/async": "0.5.3-next.57eca40",
-    "@dxos/invariant": "0.5.3-next.57eca40",
-    "@dxos/echo-schema": "0.5.3-next.57eca40",
-    "@dxos/protocols": "0.5.3-next.57eca40",
-    "@dxos/util": "0.5.3-next.57eca40",
-    "@dxos/node-std": "0.5.3-next.57eca40",
-    "@dxos/log": "0.5.3-next.57eca40",
-    "@dxos/keys": "0.5.3-next.57eca40"
+    "@braneframe/types": "0.5.3-next.63cdcad",
+    "@dxos/async": "0.5.3-next.63cdcad",
+    "@dxos/context": "0.5.3-next.63cdcad",
+    "@dxos/client": "0.5.3-next.63cdcad",
+    "@dxos/echo-db": "0.5.3-next.63cdcad",
+    "@dxos/invariant": "0.5.3-next.63cdcad",
+    "@dxos/keys": "0.5.3-next.63cdcad",
+    "@dxos/log": "0.5.3-next.63cdcad",
+    "@dxos/node-std": "0.5.3-next.63cdcad",
+    "@dxos/echo-schema": "0.5.3-next.63cdcad",
+    "@dxos/protocols": "0.5.3-next.63cdcad",
+    "@dxos/util": "0.5.3-next.63cdcad"
   },
   "devDependencies": {
     "@types/express": "^4.17.17",
     "@types/ws": "^7.4.0",
-    "@dxos/agent": "0.5.3-next.57eca40"
+    "@dxos/agent": "0.5.3-next.63cdcad"
   },
   "publishConfig": {
     "access": "public"

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/browser/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from '../types';

package/src/function/function-registry.ts

@@ -8,10 +8,9 @@ import { create, Filter, type Space } from '@dxos/client/echo';
 import { type Context, Resource } from '@dxos/context';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { ComplexMap } from '@dxos/util';
+import { ComplexMap, diff } from '@dxos/util';
 
 import { FunctionDef, type FunctionManifest } from '../types';
-import { diff } from '../util';
 
 export type FunctionsRegisteredEvent = {
   space: Space;
@@ -46,13 +45,13 @@ export class FunctionRegistry extends Resource {
 
     // Sync definitions.
     const { objects: existing } = await space.db.query(Filter.schema(FunctionDef)).run();
-    const { added, removed } = diff(existing, functions, (a, b) => a.uri === b.uri);
-    added.forEach((def) => space.db.add(create(FunctionDef, def)));
+    const { added } = diff(existing, functions, (a, b) => a.uri === b.uri);
     // TODO(burdon): Update existing templates.
-    removed.forEach((def) => space.db.remove(def));
+    added.forEach((def) => space.db.add(create(FunctionDef, def)));
   }
 
   protected override async _open(): Promise<void> {
+    log.info('opening...');
     const spacesSubscription = this._client.spaces.subscribe(async (spaces) => {
       for (const space of spaces) {
         if (this._functionBySpaceKey.has(space.key)) {
@@ -85,6 +84,7 @@ export class FunctionRegistry extends Resource {
   }
 
   protected override async _close(_: Context): Promise<void> {
+    log.info('closing...');
     this._functionBySpaceKey.clear();
   }
 }

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

@@ -27,7 +27,7 @@ export type SchedulerOptions = {
 export class Scheduler {
   private _ctx = createContext();
 
-  private readonly _callMutex = new Mutex();
+  private readonly _functionUriToCallMutex = new Map<string, Mutex>();
 
   constructor(
     public readonly functions: FunctionRegistry,
@@ -72,23 +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) => {
-      return this._callMutex.executeSynchronized(() => {
-        return this._execFunction(definition, fnTrigger, {
-          meta: fnTrigger.meta,
+    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, 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);