@dxos/functions 0.5.3-main.d7fe7b5 → 0.5.3-main.e76d664

package/src/handler.ts

@@ -8,61 +8,38 @@ import { type EchoReactiveObject } from '@dxos/echo-schema';
 import { log } from '@dxos/log';
 import { nonNullable } from '@dxos/util';
 
-// TODO(burdon): Model after http request. Ref Lambda/OpenFaaS.
-// https://docs.aws.amazon.com/lambda/latest/dg/typescript-handler.html
-// https://www.serverless.com/framework/docs/providers/aws/guide/serverless.yml/#functions
+// TODO(burdon): Context?
+// Lambda-like function definitions.
+// See: https://www.serverless.com/framework/docs/providers/aws/guide/serverless.yml/#functions
 // https://www.npmjs.com/package/aws-lambda
+// https://docs.aws.amazon.com/lambda/latest/dg/typescript-handler.html
 
-/**
- * Function handler.
- */
-export type FunctionHandler<TData = {}, TMeta = {}> = (params: {
-  context: FunctionContext;
-  event: FunctionEvent<TData, TMeta>;
-  response: FunctionResponse;
-}) => Promise<FunctionResponse | void>;
+// TODO(burdon): No response?
+export interface Response {
+  status(code: number): Response;
+}
 
-/**
- * Function context.
- */
+// TODO(burdon): Limit access to individual space?
 export interface FunctionContext {
-  // TODO(burdon): Limit access to individual space.
   client: Client;
-  // TODO(burdon): Replace with storage service abstraction.
   dataDir?: string;
 }
 
-/**
- * Event payload.
- */
-export type FunctionEvent<TData = {}, TMeta = {}> = {
-  data: FunctionEventMeta<TMeta> & TData;
-};
-
-/**
- * Metadata from trigger.
- */
-export type FunctionEventMeta<TMeta = {}> = {
-  meta: TMeta;
-};
-
-/**
- * Function response.
- */
-export interface FunctionResponse {
-  status(code: number): FunctionResponse;
-}
-
-//
-// Subscription utils.
-//
+// TODO(burdon): Model after http request. Ref Lambda/OpenFaaS.
+// https://docs.aws.amazon.com/lambda/latest/dg/typescript-handler.html
+export type FunctionHandler<T extends {}> = (params: {
+  event: T;
+  context: FunctionContext;
+  response: Response;
+}) => Promise<Response | void>;
 
-export type RawSubscriptionData = {
-  spaceKey?: string;
+export type FunctionSubscriptionEvent = {
+  space?: string; // TODO(burdon): Convert to PublicKey.
   objects?: string[];
 };
 
-export type SubscriptionData = {
+// TODO(burdon): ???
+export type FunctionSubscriptionEvent2 = {
   space?: Space;
   objects?: EchoReactiveObject<any>[];
 };
@@ -77,22 +54,22 @@ export type SubscriptionData = {
  *
  * NOTE: Get space key from devtools or `dx space list --json`
  */
-export const subscriptionHandler = <TMeta>(
-  handler: FunctionHandler<SubscriptionData, TMeta>,
-): FunctionHandler<RawSubscriptionData, TMeta> => {
-  return ({ event: { data }, context, ...rest }) => {
+export const subscriptionHandler = (
+  handler: FunctionHandler<FunctionSubscriptionEvent2>,
+): FunctionHandler<FunctionSubscriptionEvent> => {
+  return ({ event, context, ...rest }) => {
     const { client } = context;
-    const space = data.spaceKey ? client.spaces.get(PublicKey.from(data.spaceKey)) : undefined;
-    const objects = space
-      ? data.objects?.map<EchoReactiveObject<any> | undefined>((id) => space!.db.getObjectById(id)).filter(nonNullable)
-      : [];
+    const space = event.space ? client.spaces.get(PublicKey.from(event.space)) : undefined;
+    const objects =
+      space &&
+      event.objects?.map<EchoReactiveObject<any> | undefined>((id) => space!.db.getObjectById(id)).filter(nonNullable);
 
-    if (!!data.spaceKey && !space) {
-      log.warn('invalid space', { data });
+    if (!!event.space && !space) {
+      log.warn('invalid space', { event });
     } else {
       log.info('handler', { space: space?.key.truncate(), objects: objects?.length });
     }
 
-    return handler({ event: { data: { ...data, space, objects } }, context, ...rest });
+    return handler({ event: { space, objects }, context, ...rest });
   };
 };

package/src/index.ts

@@ -3,7 +3,5 @@
 //
 
 export * from './handler';
-export * from './registry';
 export * from './runtime';
-export * from './trigger';
 export * from './types';

package/src/runtime/dev-server.ts

@@ -7,19 +7,18 @@ import { getPort } from 'get-port-please';
 import type http from 'http';
 import { join } from 'node:path';
 
-import { Event, Trigger } from '@dxos/async';
+import { 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 FunctionEvent, type FunctionHandler, type FunctionResponse } from '../handler';
-import { type FunctionRegistry } from '../registry';
-import { type FunctionDef } from '../types';
+import { type FunctionContext, type FunctionHandler, type Response } from '../handler';
+import { type FunctionDef, type FunctionManifest } from '../types';
 
 export type DevServerOptions = {
-  baseDir: string;
   port?: number;
+  directory: string;
+  manifest: FunctionManifest;
   reload?: boolean;
   dataDir?: string;
 };
@@ -28,37 +27,20 @@ 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 _functionServiceRegistration?: string;
+  private _registrationId?: string;
   private _proxy?: string;
   private _seq = 0;
 
-  public readonly update = new Event<number>();
-
   // prettier-ignore
   constructor(
     private readonly _client: Client,
-    private readonly _functionsRegistry: FunctionRegistry,
     private readonly _options: DevServerOptions,
-  ) {
-    this._functionsRegistry.onFunctionsRegistered.on(async ({ newFunctions }) => {
-      newFunctions.forEach((def) => this._load(def));
-      await this._safeUpdateRegistration();
-      log('new functions loaded', { newFunctions });
-    });
-  }
-
-  get stats() {
-    return {
-      seq: this._seq,
-    };
-  }
+  ) {}
 
   get endpoint() {
     invariant(this._port);
@@ -73,26 +55,30 @@ export class DevServer {
     return Object.values(this._handlers);
   }
 
-  async start() {
-    invariant(!this._server);
-    log.info('starting...');
-    this._ctx = createContext();
+  async initialize() {
+    for (const def of this._options.manifest.functions) {
+      try {
+        await this._load(def);
+      } catch (err) {
+        log.error('parsing function (check manifest)', err);
+      }
+    }
+  }
 
-    // TODO(burdon): Move to hono.
+  async start() {
     const app = express();
     app.use(express.json());
 
-    app.post('/:path', async (req, res) => {
-      const { path } = req.params;
+    app.post('/:name', async (req, res) => {
+      const { name } = req.params;
       try {
-        log.info('calling', { path });
+        log.info('calling', { name });
         if (this._options.reload) {
-          const { def } = this._handlers['/' + path];
+          const { def } = this._handlers[name];
           await this._load(def, true);
         }
 
-        // TODO(burdon): Get function context.
-        res.statusCode = await this.invoke('/' + path, req.body);
+        res.statusCode = await this._invoke(name, req.body);
         res.end();
       } catch (err: any) {
         log.catch(err);
@@ -108,110 +94,72 @@ 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', { endpoint });
+      log.info('registered', { registrationId, endpoint });
+      this._registrationId = registrationId;
       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 () => {
-      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;
-        }
+    this._server?.close(async () => {
+      if (this._registrationId) {
+        await this._client.services.services.FunctionRegistryService!.unregister({
+          registrationId: this._registrationId,
+        });
 
-        trigger.wake();
-      } catch (err) {
-        trigger.throw(err as Error);
+        log.info('unregistered', { registrationId: this._registrationId });
+        this._registrationId = undefined;
+        this._proxy = undefined;
       }
+
+      trigger.wake();
     });
 
     await trigger.wait();
     this._port = undefined;
     this._server = undefined;
-    log.info('stopped');
   }
 
   /**
    * Load function.
    */
-  private async _load(def: FunctionDef, force = false) {
-    const { uri, route, handler } = def;
-    const filePath = join(this._options.baseDir, handler);
-    log.info('loading', { uri, force });
+  private async _load(def: FunctionDef, flush = false) {
+    const { id, name, handler } = def;
+    const path = join(this._options.directory, handler);
+    log.info('loading', { id });
 
     // Remove from cache.
-    if (force) {
+    if (flush) {
       Object.keys(require.cache)
-        .filter((key) => key.startsWith(filePath))
-        .forEach((key) => {
-          delete require.cache[key];
-        });
+        .filter((key) => key.startsWith(path))
+        .forEach((key) => delete require.cache[key]);
     }
 
-    // TODO(burdon): Import types.
     // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const module = require(filePath);
+    const module = require(path);
     if (typeof module.default !== 'function') {
-      throw new Error(`Handler must export default function: ${uri}`);
+      throw new Error(`Handler must export default function: ${id}`);
     }
 
-    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);
-    }
+    this._handlers[name] = { def, handler: module.default };
   }
 
   /**
-   * Invoke function.
+   * Invoke function handler.
    */
-  public async invoke(path: string, data: any): Promise<number> {
+  private async _invoke(name: string, event: any) {
     const seq = ++this._seq;
     const now = Date.now();
 
-    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}`);
+    log.info('req', { seq, name });
+    const { handler } = this._handlers[name];
 
     const context: FunctionContext = {
       client: this._client,
@@ -219,7 +167,7 @@ export class DevServer {
     };
 
     let statusCode = 200;
-    const response: FunctionResponse = {
+    const response: Response = {
       status: (code: number) => {
         statusCode = code;
         return response;
@@ -227,8 +175,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

@@ -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 '../registry';
-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;
-  };
 });