@dxos/functions 0.5.3-main.3d65399 → 0.5.3-main.423e628

package/src/runtime/dev-server.ts

@@ -7,18 +7,19 @@ import { getPort } from 'get-port-please';
 import type http from 'http';
 import { join } from 'node:path';
 
-import { Trigger } from '@dxos/async';
+import { Event, Trigger } from '@dxos/async';
 import { type Client } from '@dxos/client';
+import { Context } from '@dxos/context';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 
-import { type FunctionContext, type FunctionHandler, type Response } from '../handler';
-import { type FunctionDef, type FunctionManifest } from '../manifest';
+import { type FunctionRegistry } from '../function';
+import { type FunctionContext, type FunctionEvent, type FunctionHandler, type FunctionResponse } from '../handler';
+import { type FunctionDef } from '../types';
 
 export type DevServerOptions = {
+  baseDir: string;
   port?: number;
-  directory: string;
-  manifest: FunctionManifest;
   reload?: boolean;
   dataDir?: string;
 };
@@ -27,20 +28,36 @@ export type DevServerOptions = {
  * Functions dev server provides a local HTTP server for testing functions.
  */
 export class DevServer {
+  private _ctx = createContext();
+
   // Function handlers indexed by name (URL path).
   private readonly _handlers: Record<string, { def: FunctionDef; handler: FunctionHandler<any> }> = {};
 
   private _server?: http.Server;
   private _port?: number;
-  private _registrationId?: string;
+  private _functionServiceRegistration?: string;
   private _proxy?: string;
   private _seq = 0;
 
-  // prettier-ignore
+  public readonly update = new Event<number>();
+
   constructor(
     private readonly _client: Client,
+    private readonly _functionsRegistry: FunctionRegistry,
     private readonly _options: DevServerOptions,
-  ) {}
+  ) {
+    this._functionsRegistry.registered.on(async ({ added }) => {
+      added.forEach((def) => this._load(def));
+      await this._safeUpdateRegistration();
+      log('new functions loaded', { added });
+    });
+  }
+
+  get stats() {
+    return {
+      seq: this._seq,
+    };
+  }
 
   get endpoint() {
     invariant(this._port);
@@ -55,30 +72,26 @@ export class DevServer {
     return Object.values(this._handlers);
   }
 
-  async initialize() {
-    for (const def of this._options.manifest.functions) {
-      try {
-        await this._load(def);
-      } catch (err) {
-        log.error('parsing function (check manifest)', err);
-      }
-    }
-  }
-
   async start() {
+    invariant(!this._server);
+    log.info('starting...');
+    this._ctx = createContext();
+
+    // TODO(burdon): Move to hono.
     const app = express();
     app.use(express.json());
 
-    app.post('/:name', async (req, res) => {
-      const { name } = req.params;
+    app.post('/:path', async (req, res) => {
+      const { path } = req.params;
       try {
-        log.info('calling', { name });
+        log.info('calling', { path });
         if (this._options.reload) {
-          const { def } = this._handlers[name];
+          const { def } = this._handlers['/' + path];
           await this._load(def, true);
         }
 
-        res.statusCode = await this._invoke(name, req.body);
+        // TODO(burdon): Get function context.
+        res.statusCode = await this.invoke('/' + path, req.body);
         res.end();
       } catch (err: any) {
         log.catch(err);
@@ -94,72 +107,110 @@ export class DevServer {
       // Register functions.
       const { registrationId, endpoint } = await this._client.services.services.FunctionRegistryService!.register({
         endpoint: this.endpoint,
-        functions: this.functions.map(({ def: { name } }) => ({ name })),
       });
 
-      log.info('registered', { registrationId, endpoint });
-      this._registrationId = registrationId;
+      log.info('registered', { endpoint });
       this._proxy = endpoint;
+      this._functionServiceRegistration = registrationId;
+
+      // Open after registration, so that it can be updated with the list of function definitions.
+      await this._functionsRegistry.open(this._ctx);
     } catch (err: any) {
       await this.stop();
       throw new Error('FunctionRegistryService not available (check plugin is configured).');
     }
+
+    log.info('started', { port: this._port });
   }
 
   async stop() {
+    invariant(this._server);
+    log.info('stopping...');
+
     const trigger = new Trigger();
-    this._server?.close(async () => {
-      if (this._registrationId) {
-        await this._client.services.services.FunctionRegistryService!.unregister({
-          registrationId: this._registrationId,
-        });
+    this._server.close(async () => {
+      log.info('server stopped');
+      try {
+        if (this._functionServiceRegistration) {
+          invariant(this._client.services.services.FunctionRegistryService);
+          await this._client.services.services.FunctionRegistryService.unregister({
+            registrationId: this._functionServiceRegistration,
+          });
+
+          log.info('unregistered', { registrationId: this._functionServiceRegistration });
+          this._functionServiceRegistration = undefined;
+          this._proxy = undefined;
+        }
 
-        log.info('unregistered', { registrationId: this._registrationId });
-        this._registrationId = undefined;
-        this._proxy = undefined;
+        trigger.wake();
+      } catch (err) {
+        trigger.throw(err as Error);
       }
-
-      trigger.wake();
     });
 
     await trigger.wait();
     this._port = undefined;
     this._server = undefined;
+    log.info('stopped');
   }
 
   /**
    * Load function.
    */
-  private async _load(def: FunctionDef, flush = false) {
-    const { id, name, handler } = def;
-    const path = join(this._options.directory, handler);
-    log.info('loading', { id });
+  private async _load(def: FunctionDef, force?: boolean | undefined) {
+    const { uri, route, handler } = def;
+    const filePath = join(this._options.baseDir, handler);
+    log.info('loading', { uri, force });
 
     // Remove from cache.
-    if (flush) {
+    if (force) {
       Object.keys(require.cache)
-        .filter((key) => key.startsWith(path))
-        .forEach((key) => delete require.cache[key]);
+        .filter((key) => key.startsWith(filePath))
+        .forEach((key) => {
+          delete require.cache[key];
+        });
     }
 
+    // TODO(burdon): Import types.
     // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const module = require(path);
+    const module = require(filePath);
     if (typeof module.default !== 'function') {
-      throw new Error(`Handler must export default function: ${id}`);
+      throw new Error(`Handler must export default function: ${uri}`);
     }
 
-    this._handlers[name] = { def, handler: module.default };
+    this._handlers[route] = { def, handler: module.default };
+  }
+
+  private async _safeUpdateRegistration(): Promise<void> {
+    invariant(this._functionServiceRegistration);
+    try {
+      await this._client.services.services.FunctionRegistryService!.updateRegistration({
+        registrationId: this._functionServiceRegistration,
+        functions: this.functions.map(({ def: { id, route } }) => ({ id, route })),
+      });
+    } catch (e) {
+      log.catch(e);
+    }
   }
 
   /**
-   * Invoke function handler.
+   * Invoke function.
    */
-  private async _invoke(name: string, event: any) {
+  public async invoke(path: string, data: any): Promise<number> {
     const seq = ++this._seq;
     const now = Date.now();
 
-    log.info('req', { seq, name });
-    const { handler } = this._handlers[name];
+    log.info('req', { seq, path });
+    const statusCode = await this._invoke(path, { data });
+
+    log.info('res', { seq, path, statusCode, duration: Date.now() - now });
+    this.update.emit(statusCode);
+    return statusCode;
+  }
+
+  private async _invoke(path: string, event: FunctionEvent) {
+    const { handler } = this._handlers[path] ?? {};
+    invariant(handler, `invalid path: ${path}`);
 
     const context: FunctionContext = {
       client: this._client,
@@ -167,7 +218,7 @@ export class DevServer {
     };
 
     let statusCode = 200;
-    const response: Response = {
+    const response: FunctionResponse = {
       status: (code: number) => {
         statusCode = code;
         return response;
@@ -175,8 +226,8 @@ export class DevServer {
     };
 
     await handler({ context, event, response });
-    log.info('res', { seq, name, statusCode, duration: Date.now() - now });
-
     return statusCode;
   }
 }
+
+const createContext = () => new Context({ name: 'DevServer' });

package/src/runtime/scheduler.test.ts

@@ -3,56 +3,189 @@
 //
 
 import { expect } from 'chai';
+import WebSocket from 'ws';
 
 import { Trigger } from '@dxos/async';
-import { Client } from '@dxos/client';
+import { type Client } from '@dxos/client';
 import { TestBuilder } from '@dxos/client/testing';
+import { create } from '@dxos/echo-schema';
 import { describe, test } from '@dxos/test';
 
-import { Scheduler } from './scheduler';
-import { type FunctionManifest } from '../manifest';
+import { Scheduler, type SchedulerOptions } from './scheduler';
+import { FunctionRegistry } from '../function';
+import { createInitializedClients, TestType, triggerWebhook } from '../testing';
+import { TriggerRegistry } from '../trigger';
+import { type FunctionManifest } from '../types';
 
+// TODO(burdon): Test we can add and remove triggers.
 describe('scheduler', () => {
-  test.only('callback', async () => {
-    const testBuilder = new TestBuilder();
-    const client = new Client({ services: testBuilder.createLocal() });
-    await client.initialize();
-    await client.halo.createIdentity();
+  let testBuilder: TestBuilder;
+  let client: Client;
+  before(async () => {
+    testBuilder = new TestBuilder();
+    client = (await createInitializedClients(testBuilder, 1))[0];
+  });
+  after(async () => {
+    await testBuilder.destroy();
+  });
 
+  test('timer', async () => {
     const manifest: FunctionManifest = {
       functions: [
         {
-          id: 'example.com/function/test',
-          name: 'test',
+          uri: 'example.com/function/test',
+          route: '/test',
           handler: 'test',
         },
       ],
       triggers: [
         {
           function: 'example.com/function/test',
-          schedule: '0/1 * * * * *', // Every 1s.
+          spec: {
+            type: 'timer',
+            cron: '0/1 * * * * *', // Every 1s.
+          },
         },
       ],
     };
 
     let count = 0;
     const done = new Trigger();
-    const scheduler = new Scheduler(client, manifest, {
-      callback: async () => {
-        if (++count === 3) {
-          done.wake();
-        }
+    const scheduler = createScheduler(async () => {
+      if (++count === 3) {
+        done.wake();
+      }
+    });
+    await scheduler.register(client.spaces.default, manifest);
+    await scheduler.start();
+
+    await done.wait({ timeout: 5_000 });
+    expect(count).to.equal(3);
+  });
+
+  test('webhook', async () => {
+    const manifest: FunctionManifest = {
+      functions: [
+        {
+          uri: 'example.com/function/test',
+          route: '/test',
+          handler: 'test',
+        },
+      ],
+      triggers: [
+        {
+          function: 'example.com/function/test',
+          spec: {
+            type: 'webhook',
+            method: 'GET',
+          },
+        },
+      ],
+    };
 
-        return 200;
-      },
+    const done = new Trigger();
+    const scheduler = createScheduler(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 done.wait();
+  });
+
+  test('websocket', async () => {
+    const manifest: FunctionManifest = {
+      functions: [
+        {
+          uri: 'example.com/function/test',
+          route: '/test',
+          handler: 'test',
+        },
+      ],
+      triggers: [
+        {
+          function: 'example.com/function/test',
+          spec: {
+            type: 'websocket',
+            // url: 'https://hub.dxos.network/api/mailbox/test',
+            url: 'http://localhost:8081',
+            init: {
+              type: 'sync',
+            },
+          },
+        },
+      ],
+    };
 
+    const done = new Trigger();
+    const scheduler = createScheduler(async () => {
+      done.wake();
+    });
+    await scheduler.register(client.spaces.default, manifest);
     await scheduler.start();
 
+    // Test server.
+    setTimeout(() => {
+      const wss = new WebSocket.Server({ port: 8081 });
+      wss.on('connection', (ws: WebSocket) => {
+        ws.on('message', (data) => {
+          const info = JSON.parse(new TextDecoder().decode(data as ArrayBuffer));
+          expect(info.type).to.equal('sync');
+          done.wake();
+        });
+      });
+    }, 500);
+
     await done.wait();
-    expect(count).to.equal(3);
+  });
+
+  test('subscription', async () => {
+    const manifest: FunctionManifest = {
+      functions: [
+        {
+          uri: 'example.com/function/test',
+          route: '/test',
+          handler: 'test',
+        },
+      ],
+      triggers: [
+        {
+          function: 'example.com/function/test',
+          spec: {
+            type: 'subscription',
+            filter: [{ type: TestType.typename }],
+          },
+        },
+      ],
+    };
 
-    await scheduler.stop();
-    await client.destroy();
+    let count = 0;
+    const done = new Trigger();
+    const scheduler = createScheduler(async () => {
+      if (++count === 2) {
+        done.wake();
+      }
+    });
+    await scheduler.register(client.spaces.default, manifest);
+    await scheduler.start();
+
+    setTimeout(() => {
+      const space = client.spaces.default;
+      const object = create(TestType, { title: 'Hello world!' });
+      space.db.add(object);
+    }, 100);
+
+    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;
+  };
 });