@dxos/functions 0.5.2 → 0.5.3-main.088a2c8

package/src/runtime/dev-server.ts

@@ -7,18 +7,18 @@ 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 { 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 FunctionContext, type FunctionEvent, type FunctionHandler, type FunctionResponse } from '../handler';
+import { type FunctionDef, type FunctionManifest } from '../types';
 
 export type DevServerOptions = {
-  port?: number;
-  directory: string;
   manifest: FunctionManifest;
+  baseDir: string;
+  port?: number;
   reload?: boolean;
   dataDir?: string;
 };
@@ -32,16 +32,24 @@ export class DevServer {
 
   private _server?: http.Server;
   private _port?: number;
-  private _registrationId?: string;
+  private _functionServiceRegistration?: string;
   private _proxy?: string;
   private _seq = 0;
 
+  public readonly update = new Event<number>();
+
   // prettier-ignore
   constructor(
     private readonly _client: Client,
     private readonly _options: DevServerOptions,
   ) {}
 
+  get stats() {
+    return {
+      seq: this._seq,
+    };
+  }
+
   get endpoint() {
     invariant(this._port);
     return `http://localhost:${this._port}`;
@@ -66,19 +74,24 @@ export class DevServer {
   }
 
   async start() {
+    invariant(!this._server);
+    log.info('starting...');
+
+    // 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,95 @@ 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 })),
+        functions: this.functions.map(({ def: { id, path } }) => ({ id, path })),
       });
 
-      log.info('registered', { registrationId, endpoint });
-      this._registrationId = registrationId;
+      log.info('registered', { endpoint });
       this._proxy = endpoint;
+      this._functionServiceRegistration = registrationId;
     } 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 = false) {
+    const { id, path, handler } = def;
+    const filePath = join(this._options.baseDir, handler);
+    log.info('loading', { id, 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];
+        });
     }
 
     // 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}`);
     }
 
-    this._handlers[name] = { def, handler: module.default };
+    this._handlers[path] = { def, handler: module.default };
   }
 
   /**
-   * 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 +203,7 @@ export class DevServer {
     };
 
     let statusCode = 200;
-    const response: Response = {
+    const response: FunctionResponse = {
       status: (code: number) => {
         statusCode = code;
         return response;
@@ -175,8 +211,6 @@ export class DevServer {
     };
 
     await handler({ context, event, response });
-    log.info('res', { seq, name, statusCode, duration: Date.now() - now });
-
     return statusCode;
   }
 }

package/src/runtime/scheduler.test.ts

@@ -3,34 +3,45 @@
 //
 
 import { expect } from 'chai';
+import WebSocket from 'ws';
 
 import { Trigger } from '@dxos/async';
 import { Client } from '@dxos/client';
 import { TestBuilder } from '@dxos/client/testing';
+import { create, S, TypedObject } from '@dxos/echo-schema';
 import { describe, test } from '@dxos/test';
 
 import { Scheduler } from './scheduler';
-import { type FunctionManifest } from '../manifest';
+import { type FunctionManifest, type WebhookTrigger } from '../types';
 
+// TODO(burdon): Test we can add and remove triggers.
 describe('scheduler', () => {
-  test.only('callback', async () => {
+  let client: Client;
+  before(async () => {
     const testBuilder = new TestBuilder();
-    const client = new Client({ services: testBuilder.createLocal() });
+    client = new Client({ services: testBuilder.createLocalClientServices() });
     await client.initialize();
     await client.halo.createIdentity();
+  });
+  after(async () => {
+    await client.destroy();
+  });
 
+  test('timer', async () => {
     const manifest: FunctionManifest = {
       functions: [
         {
           id: 'example.com/function/test',
-          name: 'test',
+          path: '/test',
           handler: 'test',
         },
       ],
       triggers: [
         {
           function: 'example.com/function/test',
-          schedule: '0/1 * * * * *', // Every 1s.
+          timer: {
+            cron: '0/1 * * * * *', // Every 1s.
+          },
         },
       ],
     };
@@ -42,17 +53,160 @@ describe('scheduler', () => {
         if (++count === 3) {
           done.wake();
         }
+      },
+    });
+
+    await scheduler.start();
+    after(async () => {
+      await scheduler.stop();
+    });
+
+    await done.wait({ timeout: 5_000 });
+    expect(count).to.equal(3);
+  });
 
-        return 200;
+  test('webhook', async () => {
+    const manifest: FunctionManifest = {
+      functions: [
+        {
+          id: 'example.com/function/test',
+          path: '/test',
+          handler: 'test',
+        },
+      ],
+      triggers: [
+        {
+          function: 'example.com/function/test',
+          webhook: {
+            method: 'GET',
+          },
+        },
+      ],
+    };
+
+    const done = new Trigger();
+    const scheduler = new Scheduler(client, manifest, {
+      callback: async () => {
+        done.wake();
       },
     });
 
     await scheduler.start();
+    after(async () => {
+      await scheduler.stop();
+    });
+
+    setTimeout(() => {
+      const mount: WebhookTrigger = scheduler.mounts.find(
+        (mount) => mount.function === 'example.com/function/test',
+      )!.webhook!;
+      void fetch(`http://localhost:${mount.port}`);
+    });
 
     await done.wait();
-    expect(count).to.equal(3);
+  });
 
-    await scheduler.stop();
-    await client.destroy();
+  test('websocket', async () => {
+    const manifest: FunctionManifest = {
+      functions: [
+        {
+          id: 'example.com/function/test',
+          path: '/test',
+          handler: 'test',
+        },
+      ],
+      triggers: [
+        {
+          function: 'example.com/function/test',
+          websocket: {
+            // url: 'https://hub.dxos.network/api/mailbox/test',
+            url: 'http://localhost:8081',
+            init: {
+              type: 'sync',
+            },
+          },
+        },
+      ],
+    };
+
+    const done = new Trigger();
+    const scheduler = new Scheduler(client, manifest, {
+      callback: async (data) => {
+        done.wake();
+      },
+    });
+
+    await scheduler.start();
+    after(async () => {
+      await scheduler.stop();
+    });
+
+    // 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();
+  });
+
+  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: [
+        {
+          id: 'example.com/function/test',
+          path: '/test',
+          handler: 'test',
+        },
+      ],
+      triggers: [
+        {
+          function: 'example.com/function/test',
+          subscription: {
+            spaceKey: client.spaces.default.key.toHex(),
+            filter: [
+              {
+                type: TestType.typename,
+              },
+            ],
+          },
+        },
+      ],
+    };
+
+    let count = 0;
+    const done = new Trigger();
+    const scheduler = new Scheduler(client, manifest, {
+      callback: async () => {
+        if (++count === 2) {
+          done.wake();
+        }
+      },
+    });
+
+    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!' });
+      space.db.add(object);
+    }, 100);
+
+    await done.wait();
   });
 });