@dxos/functions 0.5.3-main.37bbd91 → 0.5.3-main.3b535c7

package/src/runtime/scheduler.test.ts

@@ -6,43 +6,40 @@ import { expect } from 'chai';
 import WebSocket from 'ws';
 
 import { Trigger } from '@dxos/async';
-import { type Client } from '@dxos/client';
+import { Client } from '@dxos/client';
 import { TestBuilder } from '@dxos/client/testing';
-import { create } from '@dxos/echo-schema';
+import { create, S, TypedObject } from '@dxos/echo-schema';
 import { describe, test } from '@dxos/test';
 
-import { Scheduler, type SchedulerOptions } from './scheduler';
-import { FunctionRegistry } from '../function';
-import { createInitializedClients, TestType, triggerWebhook } from '../testing';
-import { TriggerRegistry } from '../trigger';
+import { Scheduler } from './scheduler';
 import { type FunctionManifest } from '../types';
 
 // TODO(burdon): Test we can add and remove triggers.
 describe('scheduler', () => {
-  let testBuilder: TestBuilder;
   let client: Client;
   before(async () => {
-    testBuilder = new TestBuilder();
-    client = (await createInitializedClients(testBuilder, 1))[0];
+    const testBuilder = new TestBuilder();
+    client = new Client({ services: testBuilder.createLocal() });
+    await client.initialize();
+    await client.halo.createIdentity();
   });
   after(async () => {
-    await testBuilder.destroy();
+    await client.destroy();
   });
 
   test('timer', async () => {
     const manifest: FunctionManifest = {
       functions: [
         {
-          uri: 'example.com/function/test',
-          route: '/test',
+          id: 'example.com/function/test',
+          name: 'test',
           handler: 'test',
         },
       ],
       triggers: [
         {
           function: 'example.com/function/test',
-          spec: {
-            type: 'timer',
+          timer: {
             cron: '0/1 * * * * *', // Every 1s.
           },
         },
@@ -51,13 +48,18 @@ describe('scheduler', () => {
 
     let count = 0;
     const done = new Trigger();
-    const scheduler = createScheduler(async () => {
-      if (++count === 3) {
-        done.wake();
-      }
+    const scheduler = new Scheduler(client, manifest, {
+      callback: async () => {
+        if (++count === 3) {
+          done.wake();
+        }
+      },
     });
-    await scheduler.register(client.spaces.default, manifest);
+
     await scheduler.start();
+    after(async () => {
+      await scheduler.stop();
+    });
 
     await done.wait({ timeout: 5_000 });
     expect(count).to.equal(3);
@@ -67,49 +69,52 @@ describe('scheduler', () => {
     const manifest: FunctionManifest = {
       functions: [
         {
-          uri: 'example.com/function/test',
-          route: '/test',
+          id: 'example.com/function/test',
+          name: 'test',
           handler: 'test',
         },
       ],
       triggers: [
         {
           function: 'example.com/function/test',
-          spec: {
-            type: 'webhook',
-            method: 'GET',
+          webhook: {
+            port: 8080,
           },
         },
       ],
     };
 
     const done = new Trigger();
-    const scheduler = createScheduler(async () => {
-      done.wake();
+    const scheduler = new Scheduler(client, manifest, {
+      callback: async () => {
+        done.wake();
+      },
     });
-    const space = await client.spaces.create();
-    await scheduler.register(space, manifest);
-    await scheduler.start();
 
-    setTimeout(async () => triggerWebhook(space, manifest.functions![0].uri));
+    await scheduler.start();
+    after(async () => {
+      await scheduler.stop();
+    });
 
+    setTimeout(() => {
+      void fetch('http://localhost:8080');
+    });
     await done.wait();
   });
 
-  test('websocket', async () => {
+  test.only('websocket', async () => {
     const manifest: FunctionManifest = {
       functions: [
         {
-          uri: 'example.com/function/test',
-          route: '/test',
+          id: 'example.com/function/test',
+          name: 'test',
           handler: 'test',
         },
       ],
       triggers: [
         {
           function: 'example.com/function/test',
-          spec: {
-            type: 'websocket',
+          websocket: {
             // url: 'https://hub.dxos.network/api/mailbox/test',
             url: 'http://localhost:8081',
             init: {
@@ -121,11 +126,16 @@ describe('scheduler', () => {
     };
 
     const done = new Trigger();
-    const scheduler = createScheduler(async () => {
-      done.wake();
+    const scheduler = new Scheduler(client, manifest, {
+      callback: async (data) => {
+        done.wake();
+      },
     });
-    await scheduler.register(client.spaces.default, manifest);
+
     await scheduler.start();
+    after(async () => {
+      await scheduler.stop();
+    });
 
     // Test server.
     setTimeout(() => {
@@ -143,20 +153,29 @@ describe('scheduler', () => {
   });
 
   test('subscription', async () => {
+    class TestType extends TypedObject({ typename: 'example.com/type/Test', version: '0.1.0' })({
+      title: S.string,
+    }) {}
+    client.addSchema(TestType);
+
     const manifest: FunctionManifest = {
       functions: [
         {
-          uri: 'example.com/function/test',
-          route: '/test',
+          id: 'example.com/function/test',
+          name: 'test',
           handler: 'test',
         },
       ],
       triggers: [
         {
           function: 'example.com/function/test',
-          spec: {
-            type: 'subscription',
-            filter: [{ type: TestType.typename }],
+          subscription: {
+            spaceKey: client.spaces.default.key.toHex(),
+            filter: [
+              {
+                type: TestType.typename,
+              },
+            ],
           },
         },
       ],
@@ -164,14 +183,20 @@ describe('scheduler', () => {
 
     let count = 0;
     const done = new Trigger();
-    const scheduler = createScheduler(async () => {
-      if (++count === 2) {
-        done.wake();
-      }
+    const scheduler = new Scheduler(client, manifest, {
+      callback: async () => {
+        if (++count === 2) {
+          done.wake();
+        }
+      },
     });
-    await scheduler.register(client.spaces.default, manifest);
+
     await scheduler.start();
+    after(async () => {
+      await scheduler.stop();
+    });
 
+    // TODO(burdon): Query for Expando?
     setTimeout(() => {
       const space = client.spaces.default;
       const object = create(TestType, { title: 'Hello world!' });
@@ -180,12 +205,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

@@ -2,19 +2,31 @@
 // Copyright 2023 DXOS.org
 //
 
-import path from 'node:path';
+import { CronJob } from 'cron';
+import http from 'node:http';
+import WebSocket from 'ws';
 
-import { Mutex } from '@dxos/async';
-import { type Space } from '@dxos/client/echo';
+import { TextV0Type } from '@braneframe/types';
+import { debounce, DeferredTask, sleep, Trigger } from '@dxos/async';
+import { type Client, type PublicKey } from '@dxos/client';
+import { createSubscription, Filter, getAutomergeObjectCore, type Query, type Space } from '@dxos/client/echo';
 import { Context } from '@dxos/context';
+import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
+import { ComplexMap } from '@dxos/util';
 
-import { type FunctionRegistry } from '../function';
-import { type FunctionEventMeta } from '../handler';
-import { type TriggerRegistry } from '../trigger';
-import { type FunctionDef, type FunctionManifest, type FunctionTrigger } from '../types';
+import { type FunctionSubscriptionEvent } from '../handler';
+import {
+  type FunctionDef,
+  type FunctionManifest,
+  type FunctionTrigger,
+  type SubscriptionTrigger,
+  type TimerTrigger,
+  type WebhookTrigger,
+  type WebsocketTrigger,
+} from '../types';
 
-export type Callback = (data: any) => Promise<void | number>;
+type Callback = (data: FunctionSubscriptionEvent) => Promise<void>;
 
 export type SchedulerOptions = {
   endpoint?: string;
@@ -22,118 +34,290 @@ export type SchedulerOptions = {
 };
 
 /**
- * The scheduler triggers function execution based on various triggers.
+ * The scheduler triggers function exectuion based on various triggers.
  */
 export class Scheduler {
-  private _ctx = createContext();
-
-  private readonly _callMutex = new Mutex();
+  // Map of mounted functions.
+  private readonly _mounts = new ComplexMap<
+    { id: string; spaceKey: PublicKey },
+    { ctx: Context; trigger: FunctionTrigger }
+  >(({ id, spaceKey }) => `${spaceKey.toHex()}:${id}`);
 
   constructor(
-    public readonly functions: FunctionRegistry,
-    public readonly triggers: TriggerRegistry,
+    private readonly _client: Client,
+    private readonly _manifest: FunctionManifest,
     private readonly _options: SchedulerOptions = {},
-  ) {
-    this.functions.registered.on(async ({ space, added }) => {
-      await this._safeActivateTriggers(space, this.triggers.getInactiveTriggers(space), added);
-    });
-    this.triggers.registered.on(async ({ space, triggers }) => {
-      await this._safeActivateTriggers(space, triggers, this.functions.getFunctions(space));
-    });
-  }
+  ) {}
 
   async start() {
-    await this._ctx.dispose();
-    this._ctx = createContext();
-    await this.functions.open(this._ctx);
-    await this.triggers.open(this._ctx);
+    this._client.spaces.subscribe(async (spaces) => {
+      for (const space of spaces) {
+        await space.waitUntilReady();
+        for (const trigger of this._manifest.triggers ?? []) {
+          await this.mount(new Context(), space, trigger);
+        }
+      }
+    });
   }
 
   async stop() {
-    await this._ctx.dispose();
-    await this.functions.close();
-    await this.triggers.close();
+    for (const { id, spaceKey } of this._mounts.keys()) {
+      await this.unmount(id, spaceKey);
+    }
   }
 
-  // TODO(burdon): Remove and update registries directly.
-  public async register(space: Space, manifest: FunctionManifest) {
-    await this.functions.register(space, manifest.functions);
-    await this.triggers.register(space, manifest);
-  }
+  private async mount(ctx: Context, space: Space, trigger: FunctionTrigger) {
+    const key = { id: trigger.function, spaceKey: space.key };
+    const def = this._manifest.functions.find((config) => config.id === trigger.function);
+    invariant(def, `Function not found: ${trigger.function}`);
 
-  private async _safeActivateTriggers(
-    space: Space,
-    triggers: FunctionTrigger[],
-    functions: FunctionDef[],
-  ): Promise<void> {
-    const mountTasks = triggers.map((trigger) => {
-      return this.activate(space, functions, trigger);
-    });
-    await Promise.all(mountTasks).catch(log.catch);
-  }
+    // TODO(burdon): Currently supports only one trigger declaration per function.
+    const exists = this._mounts.get(key);
+    if (!exists) {
+      this._mounts.set(key, { ctx, trigger });
+      log('mount', { space: space.key, trigger });
+      if (ctx.disposed) {
+        return;
+      }
 
-  private async activate(space: Space, functions: FunctionDef[], fnTrigger: FunctionTrigger) {
-    const definition = functions.find((def) => def.uri === fnTrigger.function);
-    if (!definition) {
-      log.info('function is not found for trigger', { fnTrigger });
-      return;
-    }
+      //
+      // Triggers types.
+      //
 
-    await this.triggers.activate({ space }, fnTrigger, async (args) => {
-      return this._callMutex.executeSynchronized(() => {
-        return this._execFunction(definition, fnTrigger, {
-          meta: fnTrigger.meta,
-          data: { ...args, spaceKey: space.key },
-        });
-      });
-    });
+      if (trigger.timer) {
+        await this._createTimer(ctx, space, def, trigger.timer);
+      }
 
-    log('activated trigger', { space: space.key, trigger: fnTrigger });
+      if (trigger.webhook) {
+        await this._createWebhook(ctx, space, def, trigger.webhook);
+      }
+
+      if (trigger.websocket) {
+        await this._createWebsocket(ctx, space, def, trigger.websocket);
+      }
+
+      if (trigger.subscription) {
+        await this._createSubscription(ctx, space, def, trigger.subscription);
+      }
+    }
   }
 
-  private async _execFunction<TData, TMeta>(
-    def: FunctionDef,
-    trigger: FunctionTrigger,
-    { data, meta }: { data: TData; meta?: TMeta },
-  ): Promise<number> {
-    let status = 0;
-    try {
-      // TODO(burdon): Pass in Space key (common context)?
-      const payload = Object.assign({}, meta && ({ meta } satisfies FunctionEventMeta<TMeta>), data);
+  private async unmount(id: string, spaceKey: PublicKey) {
+    const key = { id, spaceKey };
+    const { ctx } = this._mounts.get(key) ?? {};
+    if (ctx) {
+      this._mounts.delete(key);
+      await ctx.dispose();
+    }
+  }
 
+  // TODO(burdon): Pass in Space key (common context).
+  private async _execFunction(def: FunctionDef, data: any) {
+    try {
+      log.info('exec', { function: def.id });
       const { endpoint, callback } = this._options;
       if (endpoint) {
         // TODO(burdon): Move out of scheduler (generalize as callback).
-        const url = path.join(endpoint, def.route);
-        log.info('exec', { function: def.uri, url, triggerType: trigger.spec.type });
-        const response = await fetch(url, {
+        await fetch(`${this._options.endpoint}/${def.name}`, {
           method: 'POST',
           headers: {
             'Content-Type': 'application/json',
           },
-          body: JSON.stringify(payload),
+          body: JSON.stringify(data),
         });
-
-        status = response.status;
       } else if (callback) {
-        log.info('exec', { function: def.uri });
-        status = (await callback(payload)) ?? 200;
-      }
-
-      // Check errors.
-      if (status && status >= 400) {
-        throw new Error(`Response: ${status}`);
+        await callback(data);
       }
 
       // const result = await response.json();
-      log.info('done', { function: def.uri, status });
+      log.info('done', { function: def.id });
     } catch (err: any) {
-      log.error('error', { function: def.uri, error: err.message });
-      status = 500;
+      log.error('error', { function: def.id, error: err.message });
+    }
+  }
+
+  //
+  // Triggers
+  //
+
+  /**
+   * Cron timer.
+   */
+  private async _createTimer(ctx: Context, space: Space, def: FunctionDef, trigger: TimerTrigger) {
+    log.info('timer', { space: space.key, trigger });
+    const { cron } = trigger;
+
+    const task = new DeferredTask(ctx, async () => {
+      await this._execFunction(def, { space: space.key });
+    });
+
+    let last = 0;
+    let run = 0;
+    // https://www.npmjs.com/package/cron#constructor
+    const job = CronJob.from({
+      cronTime: cron,
+      runOnInit: false,
+      onTick: () => {
+        // TODO(burdon): Check greater than 30s (use cron-parser).
+        const now = Date.now();
+        const delta = last ? now - last : 0;
+        last = now;
+
+        run++;
+        log.info('tick', { space: space.key.truncate(), count: run, delta });
+        task.schedule();
+      },
+    });
+
+    job.start();
+    ctx.onDispose(() => job.stop());
+  }
+
+  /**
+   * Webhook.
+   */
+  private async _createWebhook(ctx: Context, space: Space, def: FunctionDef, trigger: WebhookTrigger) {
+    log.info('webhook', { space: space.key, trigger });
+    const { port } = trigger;
+
+    // TODO(burdon): POST JSON.
+    const server = http.createServer(async (req, res) => {
+      await this._execFunction(def, { space: space.key });
+    });
+
+    server.listen(port, () => {
+      log.info('started webhook', { port });
+    });
+
+    ctx.onDispose(() => {
+      server.close();
+    });
+  }
+
+  /**
+   * Websocket.
+   */
+  private async _createWebsocket(
+    ctx: Context,
+    space: Space,
+    def: FunctionDef,
+    trigger: WebsocketTrigger,
+    options: {
+      retryDelay: number;
+      maxAttempts: number;
+    } = {
+      retryDelay: 2,
+      maxAttempts: 5,
+    },
+  ) {
+    log.info('websocket', { space: space.key, trigger });
+    const { url } = trigger;
+
+    let ws: WebSocket;
+    for (let attempt = 1; attempt <= options.maxAttempts; attempt++) {
+      const open = new Trigger<boolean>();
+
+      ws = new WebSocket(url);
+      Object.assign(ws, {
+        onopen: () => {
+          log.info('opened', { url });
+          if (trigger.init) {
+            ws.send(new TextEncoder().encode(JSON.stringify(trigger.init)));
+          }
+
+          open.wake(true);
+        },
+
+        onclose: () => {
+          log.info('closed', { url });
+          open.wake(false);
+        },
+
+        onerror: (event) => {
+          log.catch(event.error, { url });
+        },
+
+        onmessage: async (event) => {
+          try {
+            const data = JSON.parse(new TextDecoder().decode(event.data as Uint8Array));
+            await this._execFunction(def, { space: space.key, data });
+          } catch (err) {
+            log.catch(err, { url });
+          }
+        },
+      } satisfies Partial<WebSocket>);
+
+      const isOpen = await open.wait();
+      if (isOpen) {
+        break;
+      } else {
+        const wait = Math.pow(attempt, 2) * options.retryDelay;
+        if (attempt < options.maxAttempts) {
+          log.warn(`failed to connect; trying again in ${wait}s`, { attempt });
+          await sleep(wait * 1_000);
+        }
+      }
     }
 
-    return status;
+    ctx.onDispose(() => {
+      ws?.close();
+    });
   }
-}
 
-const createContext = () => new Context({ name: 'FunctionScheduler' });
+  /**
+   * ECHO subscription.
+   */
+  private async _createSubscription(ctx: Context, space: Space, def: FunctionDef, trigger: SubscriptionTrigger) {
+    log.info('subscription', { space: space.key, trigger });
+    const objectIds = new Set<string>();
+    const task = new DeferredTask(ctx, async () => {
+      await this._execFunction(def, { space: space.key, objects: Array.from(objectIds) });
+    });
+
+    // TODO(burdon): Don't fire initially.
+    // TODO(burdon): Subscription is called THREE times.
+    const subscriptions: (() => void)[] = [];
+    const subscription = createSubscription(({ added, updated }) => {
+      log.info('updated', { added: added.length, updated: updated.length });
+      for (const object of added) {
+        objectIds.add(object.id);
+      }
+      for (const object of updated) {
+        objectIds.add(object.id);
+      }
+
+      task.schedule();
+    });
+    subscriptions.push(() => subscription.unsubscribe());
+
+    // TODO(burdon): Create queue. Only allow one invocation per trigger at a time?
+    // TODO(burdon): Disable trigger if keeps failing.
+    const { filter, options: { deep, delay } = {} } = trigger;
+    const update = ({ objects }: Query) => {
+      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) {
+            subscriptions.push(
+              getAutomergeObjectCore(content).updates.on(debounce(() => subscription.update([object]), 1_000)),
+            );
+          }
+        }
+      }
+    };
+
+    // TODO(burdon): Is Filter.or implemented?
+    // 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 = space.db.query(Filter.or(filter.map(({ type, props }) => Filter.typename(type, props))));
+    subscriptions.push(query.subscribe(delay ? debounce(update, delay) : update));
+
+    ctx.onDispose(() => {
+      subscriptions.forEach((unsubscribe) => unsubscribe());
+    });
+  }
+}