@dxos/functions 0.5.3-main.f9b873d → 0.5.3-main.fffc127

package/src/trigger/trigger-registry.ts

@@ -4,12 +4,13 @@
 
 import { Event } from '@dxos/async';
 import { type Client } from '@dxos/client';
-import { create, Filter, type Space } from '@dxos/client/echo';
+import { create, Filter, getMeta, type Space } from '@dxos/client/echo';
 import { Context, Resource } from '@dxos/context';
+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 } 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';
@@ -18,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,
@@ -69,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;
@@ -96,17 +94,39 @@ export class TriggerRegistry extends Resource {
     if (!manifest.triggers?.length) {
       return;
     }
-    if (!space.db.graph.runtimeSchemaRegistry.isSchemaRegistered(FunctionTrigger)) {
+
+    if (!space.db.graph.runtimeSchemaRegistry.hasSchema(FunctionTrigger)) {
       space.db.graph.runtimeSchemaRegistry.registerSchema(FunctionTrigger);
     }
 
-    const reactiveObjects = manifest.triggers.map((template: Omit<FunctionTrigger, 'id'>) =>
-      create(FunctionTrigger, { ...template }),
-    );
-    reactiveObjects.forEach((obj) => space.db.add(obj));
+    // 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, manifestTriggers, compareForeignKeys);
+
+    // TODO(burdon): Update existing.
+    added.forEach((trigger) => {
+      space.db.add(trigger);
+      log.info('added', { meta: getMeta(trigger) });
+    });
+
+    if (added.length > 0) {
+      await space.db.flush();
+    }
   }
 
   protected override async _open(): Promise<void> {
+    log.info('open...');
     const spaceListSubscription = this._client.spaces.subscribe(async (spaces) => {
       for (const space of spaces) {
         if (this._triggersBySpaceKey.has(space.key)) {
@@ -119,44 +139,54 @@ export class TriggerRegistry extends Resource {
         if (this._ctx.disposed) {
           break;
         }
-        const functionsSubscription = space.db.query(Filter.schema(FunctionTrigger)).subscribe(async (triggers) => {
-          await this._handleRemovedTriggers(space, triggers.objects, registered);
-          this._handleNewTriggers(space, triggers.objects, registered);
-        });
 
-        this._ctx.onDispose(functionsSubscription);
+        // Subscribe to updates.
+        this._ctx.onDispose(
+          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('registered new triggers', () => ({ spaceKey: space.key, functions: newTriggers.map((t) => t.function) }));
-      this.registered.emit({ space, triggers: newTriggers });
+      log.info('added', () => ({
+        spaceKey: space.key,
+        triggers: added.map((trigger) => trigger.function),
+      }));
+
+      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) {
         const unregistered = registered.splice(i, 1)[0];
         await unregistered.activationCtx?.dispose();
@@ -165,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

@@ -3,41 +3,50 @@
 //
 
 import { TextV0Type } from '@braneframe/types';
-import { debounce, DeferredTask } from '@dxos/async';
+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,
 ) => {
   const objectIds = new Set<string>();
-  const task = new DeferredTask(ctx, async () => {
-    if (objectIds.size > 0) {
-      await callback({ objects: Array.from(objectIds) });
-      objectIds.clear();
-    }
-  });
+  const task = new UpdateScheduler(
+    ctx,
+    async () => {
+      if (objectIds.size > 0) {
+        const objects = Array.from(objectIds);
+        objectIds.clear();
+        await callback({ objects });
+      }
+    },
+    { 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)[] = [];
   const subscription = createSubscription(({ added, updated }) => {
-    log.info('updated', { added: added.length, updated: updated.length });
+    const sizeBefore = objectIds.size;
     for (const object of added) {
       objectIds.add(object.id);
     }
     for (const object of updated) {
       objectIds.add(object.id);
     }
-
-    task.schedule();
+    if (objectIds.size > sizeBefore) {
+      log.info('updated', { added: added.length, updated: updated.length });
+      task.trigger();
+    }
   });
 
   subscriptions.push(() => subscription.unsubscribe());
@@ -45,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) {
@@ -61,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);
         }
 

package/src/types.ts

@@ -2,10 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-import { AST, S, TypedObject } from '@dxos/echo-schema';
-
-// TODO(burdon): Factor out.
-const omitEchoId = <T>(schema: S.Schema<T>): S.Schema<Omit<T, 'id'>> => S.make(AST.omit(schema.ast, ['id']));
+import { RawObject, S, TypedObject } from '@dxos/echo-schema';
 
 /**
  * Type discriminator for TriggerSpec.
@@ -15,30 +12,36 @@ const omitEchoId = <T>(schema: S.Schema<T>): S.Schema<Omit<T, 'id'>> => S.make(A
  */
 export type FunctionTriggerType = 'subscription' | 'timer' | 'webhook' | 'websocket';
 
-const SubscriptionTriggerSchema = S.struct({
-  type: S.literal('subscription'),
-  // TODO(burdon): Define query DSL.
-  filter: S.array(
-    S.struct({
-      type: S.string,
-      props: S.optional(S.record(S.string, S.any)),
-    }),
-  ),
-  options: S.optional(
-    S.struct({
-      // Watch changes to object (not just creation).
-      deep: S.optional(S.boolean),
-      // Debounce changes (delay in ms).
-      delay: S.optional(S.number),
-    }),
-  ),
-});
+const SubscriptionTriggerSchema = S.mutable(
+  S.struct({
+    type: S.literal('subscription'),
+    // TODO(burdon): Define query DSL (from ECHO).
+    filter: S.array(
+      S.struct({
+        type: S.string,
+        props: S.optional(S.record(S.string, S.any)),
+      }),
+    ),
+    options: S.optional(
+      S.struct({
+        // Watch changes to object (not just creation).
+        deep: S.optional(S.boolean),
+        // Debounce changes (delay in ms).
+        delay: S.optional(S.number),
+      }),
+    ),
+  }),
+);
+
 export type SubscriptionTrigger = S.Schema.Type<typeof SubscriptionTriggerSchema>;
 
-const TimerTriggerSchema = S.struct({
-  type: S.literal('timer'),
-  cron: S.string,
-});
+const TimerTriggerSchema = S.mutable(
+  S.struct({
+    type: S.literal('timer'),
+    cron: S.string,
+  }),
+);
+
 export type TimerTrigger = S.Schema.Type<typeof TimerTriggerSchema>;
 
 const WebhookTriggerSchema = S.mutable(
@@ -49,13 +52,17 @@ const WebhookTriggerSchema = S.mutable(
     port: S.optional(S.number),
   }),
 );
+
 export type WebhookTrigger = S.Schema.Type<typeof WebhookTriggerSchema>;
 
-const WebsocketTriggerSchema = S.struct({
-  type: S.literal('websocket'),
-  url: S.string,
-  init: S.optional(S.record(S.string, S.any)),
-});
+const WebsocketTriggerSchema = S.mutable(
+  S.struct({
+    type: S.literal('websocket'),
+    url: S.string,
+    init: S.optional(S.record(S.string, S.any)),
+  }),
+);
+
 export type WebsocketTrigger = S.Schema.Type<typeof WebsocketTriggerSchema>;
 
 const TriggerSpecSchema = S.union(
@@ -64,6 +71,7 @@ const TriggerSpecSchema = S.union(
   WebsocketTriggerSchema,
   SubscriptionTriggerSchema,
 );
+
 export type TriggerSpec = TimerTrigger | WebhookTrigger | WebsocketTrigger | SubscriptionTrigger;
 
 /**
@@ -76,17 +84,20 @@ export class FunctionDef extends TypedObject({
   uri: S.string,
   description: S.optional(S.string),
   route: S.string,
-  // TODO(burdon): NPM/GitHub/Docker/CF URL?
   handler: S.string,
 }) {}
 
+/**
+ * Function trigger.
+ */
 export class FunctionTrigger extends TypedObject({
   typename: 'dxos.org/type/FunctionTrigger',
   version: '0.1.0',
 })({
-  function: S.string.pipe(S.description('Function ID/URI.')),
-  // Context passed to a function.
-  meta: S.optional(S.record(S.string, S.any)),
+  enabled: S.optional(S.boolean),
+  function: S.string.pipe(S.description('Function URI.')),
+  // The `meta` property is merged into the event data passed to the function.
+  meta: S.optional(S.mutable(S.any)),
   spec: TriggerSpecSchema,
 }) {}
 
@@ -94,8 +105,11 @@ export class FunctionTrigger extends TypedObject({
  * Function manifest file.
  */
 export const FunctionManifestSchema = S.struct({
-  functions: S.optional(S.mutable(S.array(omitEchoId(FunctionDef)))),
-  triggers: S.optional(S.mutable(S.array(omitEchoId(FunctionTrigger)))),
+  functions: S.optional(S.mutable(S.array(RawObject(FunctionDef)))),
+  triggers: S.optional(S.mutable(S.array(RawObject(FunctionTrigger)))),
 });
 
 export type FunctionManifest = S.Schema.Type<typeof FunctionManifestSchema>;
+
+// TODO(burdon): Standards?
+export const FUNCTION_SCHEMA = [FunctionDef, FunctionTrigger];

package/dist/types/src/registry/function-registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"function-registry.d.ts","sourceRoot":"","sources":["../../../../src/registry/function-registry.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAkB,KAAK,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAE,KAAK,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAIvD,OAAO,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAE9D,MAAM,MAAM,wBAAwB,GAAG;IACrC,KAAK,EAAE,KAAK,CAAC;IACb,YAAY,EAAE,WAAW,EAAE,CAAC;CAC7B,CAAC;AAEF,qBAAa,gBAAiB,SAAQ,QAAQ;IAKhC,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJpC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAA4D;IAEhG,SAAgB,qBAAqB,kCAAyC;gBAEjD,OAAO,EAAE,MAAM;IAIrC,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,WAAW,EAAE;IAIhD;;;OAGG;IAEU,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;cAcrD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;cA0BtB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;CAG3D"}

package/dist/types/src/registry/function-registry.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"function-registry.test.d.ts","sourceRoot":"","sources":["../../../../src/registry/function-registry.test.ts"],"names":[],"mappings":""}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/registry/index.ts"],"names":[],"mappings":"AAIA,cAAc,qBAAqB,CAAC"}

package/src/registry/function-registry.ts

@@ -1,84 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { Event } from '@dxos/async';
-import { type Client } from '@dxos/client';
-import { create, Filter, type Space } from '@dxos/client/echo';
-import { type Context, Resource } from '@dxos/context';
-import { PublicKey } from '@dxos/keys';
-import { ComplexMap } from '@dxos/util';
-
-import { FunctionDef, type FunctionManifest } from '../types';
-
-export type FunctionsRegisteredEvent = {
-  space: Space;
-  newFunctions: FunctionDef[];
-};
-
-export class FunctionRegistry extends Resource {
-  private readonly _functionBySpaceKey = new ComplexMap<PublicKey, FunctionDef[]>(PublicKey.hash);
-
-  public readonly onFunctionsRegistered = new Event<FunctionsRegisteredEvent>();
-
-  constructor(private readonly _client: Client) {
-    super();
-  }
-
-  public getFunctions(space: Space): FunctionDef[] {
-    return this._functionBySpaceKey.get(space.key) ?? [];
-  }
-
-  /**
-   * The method loads function definitions from the manifest into the space.
-   * We first load all the definitions from the space to deduplicate by functionId.
-   */
-  // TODO(burdon): This should not be space specific (they are static for the agent).
-  public async register(space: Space, manifest: FunctionManifest): Promise<void> {
-    if (!manifest.functions?.length) {
-      return;
-    }
-    if (!space.db.graph.runtimeSchemaRegistry.isSchemaRegistered(FunctionDef)) {
-      space.db.graph.runtimeSchemaRegistry.registerSchema(FunctionDef);
-    }
-
-    const { objects: existingDefinitions } = await space.db.query(Filter.schema(FunctionDef)).run();
-    const newDefinitions = getNewDefinitions(manifest.functions, existingDefinitions);
-    const reactiveObjects = newDefinitions.map((template) => create(FunctionDef, { ...template }));
-    reactiveObjects.forEach((obj) => space.db.add(obj));
-  }
-
-  protected override async _open(): Promise<void> {
-    const spaceListSubscription = this._client.spaces.subscribe(async (spaces) => {
-      for (const space of spaces) {
-        if (this._functionBySpaceKey.has(space.key)) {
-          continue;
-        }
-        const registered: FunctionDef[] = [];
-        this._functionBySpaceKey.set(space.key, registered);
-        await space.waitUntilReady();
-        if (this._ctx.disposed) {
-          break;
-        }
-
-        const functionsSubscription = space.db.query(Filter.schema(FunctionDef)).subscribe((definitions) => {
-          const newFunctions = getNewDefinitions(definitions.objects, registered);
-          if (newFunctions.length > 0) {
-            registered.push(...newFunctions);
-            this.onFunctionsRegistered.emit({ space, newFunctions });
-          }
-        });
-        this._ctx.onDispose(functionsSubscription);
-      }
-    });
-    this._ctx.onDispose(() => spaceListSubscription.unsubscribe());
-  }
-
-  protected override async _close(_: Context): Promise<void> {
-    this._functionBySpaceKey.clear();
-  }
-}
-
-const getNewDefinitions = <T extends { uri: string }>(candidateList: T[], existing: FunctionDef[]): T[] => {
-  return candidateList.filter((candidate) => existing.find((def) => def.uri === candidate.uri) == null);
-};