@dxos/functions 0.1.52 → 0.1.53-main.032dce6

package/src/runtime/dev-server.ts

@@ -0,0 +1,131 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import express from 'express';
+import http from 'http';
+import { join } from 'node:path';
+import { getPortPromise } from 'portfinder';
+
+import { Trigger } from '@dxos/async';
+import { Client } from '@dxos/client';
+import { log } from '@dxos/log';
+
+import { FunctionContext, FunctionHandler, FunctionsManifest, Response } from '../function';
+
+const DEFAULT_PORT = 7000;
+
+export type DevServerOptions = {
+  directory: string;
+  manifest: FunctionsManifest;
+};
+
+/**
+ * Functions dev server provides a local HTTP server for testing functions.
+ */
+export class DevServer {
+  private readonly _functionHandlers: Record<string, FunctionHandler> = {};
+
+  private _server?: http.Server;
+  private _port?: number;
+  private _registrationId?: string;
+
+  // prettier-ignore
+  constructor(
+    private readonly _client: Client,
+    private readonly _options: DevServerOptions
+  ) {}
+
+  get port() {
+    return this._port;
+  }
+
+  get endpoint() {
+    return this._port ? `http://localhost:${this._port}` : undefined;
+  }
+
+  get functions() {
+    return Object.keys(this._functionHandlers);
+  }
+
+  async initialize() {
+    for (const [name, _] of Object.entries(this._options.manifest.functions)) {
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const module = require(join(this._options.directory, name));
+        const handler = module.default;
+        if (typeof handler !== 'function') {
+          throw new Error(`Handler must export default function: ${name}`);
+        }
+
+        this._functionHandlers[name] = handler;
+      } catch (err) {
+        log.error('parsing function (check functions.yml manifest)', err);
+      }
+    }
+  }
+
+  async start() {
+    const app = express();
+    app.use(express.json());
+
+    app.post('/:functionName', async (req, res) => {
+      const functionName = req.params.functionName;
+      log('invoke', { function: functionName, data: req.body });
+
+      const builder: Response = {
+        status: (code: number) => {
+          res.statusCode = code;
+          return builder;
+        },
+        succeed: (result = {}) => {
+          res.end(JSON.stringify(result));
+          return builder;
+        },
+      };
+
+      const context: FunctionContext = {
+        client: this._client,
+        status: builder.status.bind(builder),
+      };
+
+      void (async () => {
+        try {
+          await this._functionHandlers[functionName](req.body, context);
+        } catch (err: any) {
+          res.statusCode = 500;
+          res.end(err.message);
+        }
+      })();
+    });
+
+    this._port = await getPortPromise({ startPort: DEFAULT_PORT });
+    this._server = app.listen(this._port);
+
+    // TODO(burdon): Check plugin is registered.
+    //  TypeError: Cannot read properties of undefined (reading 'register')
+    const { registrationId } = await this._client.services.services.FunctionRegistryService!.register({
+      endpoint: this.endpoint!,
+      functions: this.functions.map((name) => ({ name })),
+    });
+    this._registrationId = registrationId;
+  }
+
+  async stop() {
+    const trigger = new Trigger();
+    this._server?.close(async () => {
+      if (this._registrationId) {
+        await this._client.services.services.FunctionRegistryService!.unregister({
+          registrationId: this._registrationId,
+        });
+        this._registrationId = undefined;
+      }
+
+      trigger.wake();
+    });
+
+    await trigger.wait();
+    this._server = undefined;
+    this._port = undefined;
+  }
+}

package/src/runtime/index.ts

@@ -2,93 +2,5 @@
 // Copyright 2023 DXOS.org
 //
 
-import express from 'express';
-import { readdir } from 'node:fs/promises';
-import { extname, join } from 'node:path';
-import { getPortPromise } from 'portfinder';
-
-import { Client } from '@dxos/client';
-import { log } from '@dxos/log';
-
-import { FunctionContext, FunctionHandler, Reply } from '../interface';
-
-const FUNCTION_EXTENSIONS = ['.js', '.ts'];
-
-export type FunctionsRuntimeParams = {
-  client: Client;
-  functionsDirectory: string;
-};
-
-export const runFunctions = async (options: FunctionsRuntimeParams) => {
-  const files = await readdir(options.functionsDirectory);
-
-  const functionHandlers: Record<string, FunctionHandler> = {};
-
-  for (const file of files) {
-    if (!FUNCTION_EXTENSIONS.some((ext) => extname(file) === ext)) {
-      continue;
-    }
-
-    try {
-      // eslint-disable-next-line @typescript-eslint/no-var-requires
-      const module = require(join(options.functionsDirectory, file));
-      const handler = module.default;
-      if (typeof handler !== 'function') {
-        throw new Error(`Function ${file} does not export a default function`);
-      }
-
-      const functionName = file.slice(0, -extname(file).length);
-
-      functionHandlers[functionName] = handler;
-    } catch (e) {
-      console.error(e);
-    }
-  }
-
-  const port = await getPortPromise({ startPort: 7000 });
-
-  const app = express();
-  app.use(express.json());
-
-  app.post('/:functionName', async (req, res) => {
-    const functionName = req.params.functionName;
-
-    const replyBuilder: Reply = {
-      status: (code: number) => {
-        res.statusCode = code;
-        return replyBuilder;
-      },
-      succeed: (result: any) => {
-        res.end(JSON.stringify(result));
-        return replyBuilder;
-      },
-    };
-    const context: FunctionContext = {
-      client: options.client,
-      status: replyBuilder.status.bind(replyBuilder),
-    };
-
-    void (async () => {
-      try {
-        await functionHandlers[functionName](req.body, context);
-      } catch (err: any) {
-        res.statusCode = 500;
-        res.end(err.message);
-      }
-    })();
-  });
-  app.listen(port);
-
-  const functionNames = Object.keys(functionHandlers);
-  const { registrationId } = await options.client.services.services.FunctionRegistryService!.register({
-    endpoint: `http://localhost:${port}`,
-    functions: functionNames.map((name) => ({ name })),
-  });
-
-  process.on('SIGINT', async () => {
-    await options.client.services.services.FunctionRegistryService!.unregister({ registrationId });
-    process.exit();
-  });
-
-  log.info('functions runtime started', { port, functionNames, registrationId });
-};
+export * from './dev-server';
+export * from './trigger-manager';

package/src/runtime/trigger-manager.ts

@@ -0,0 +1,143 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import assert from 'node:assert';
+
+import { DeferredTask } from '@dxos/async';
+import { Client, PublicKey, Space } from '@dxos/client';
+import { Context } from '@dxos/context';
+import { createSubscription } from '@dxos/echo-schema';
+import { log } from '@dxos/log';
+import { ComplexMap } from '@dxos/util';
+
+import { FunctionTrigger } from '../function';
+
+// TODO(burdon): Rename.
+export type InvokeOptions = {
+  endpoint: string;
+  runtime: string;
+};
+
+export class TriggerManager {
+  private readonly _mounts = new ComplexMap<
+    { name: string; spaceKey: PublicKey },
+    { ctx: Context; trigger: FunctionTrigger }
+  >(({ name, spaceKey }) => `${spaceKey.toHex()}:${name}`);
+
+  constructor(
+    private readonly _client: Client,
+    private readonly _triggers: FunctionTrigger[],
+    private readonly _invokeOptions: InvokeOptions,
+  ) {}
+
+  async start() {
+    // TODO(burdon): Make runtime configurable (via CLI)?
+    this._client.spaces.subscribe(async (spaces) => {
+      for (const space of spaces) {
+        await space.waitUntilReady();
+        for (const trigger of this._triggers) {
+          // TODO(burdon): New context? Shared?
+          await this.mount(new Context(), trigger, space);
+        }
+      }
+    });
+  }
+
+  async stop() {
+    for (const { name, spaceKey } of this._mounts.keys()) {
+      await this.unmount(name, spaceKey);
+    }
+  }
+
+  private async mount(ctx: Context, trigger: FunctionTrigger, space: Space) {
+    const key = { name: trigger.function, spaceKey: space.key };
+    const exists = this._mounts.get(key);
+    if (!exists) {
+      this._mounts.set(key, { ctx, trigger });
+      if (ctx.disposed) {
+        return;
+      }
+
+      // TODO(burdon): Factor out subscription/result delta.
+
+      let count = 0;
+      const objectIds = new Set<string>();
+      const task = new DeferredTask(ctx, async () => {
+        const updatedObjects = Array.from(objectIds);
+        objectIds.clear();
+
+        await this.invokeFunction(this._invokeOptions, trigger.function, {
+          space: space.key,
+          objects: updatedObjects,
+        });
+      });
+
+      // TODO(burdon): Removed?
+      const selection = createSubscription(({ added, updated }) => {
+        for (const object of added) {
+          objectIds.add(object.id);
+        }
+        for (const object of updated) {
+          objectIds.add(object.id);
+        }
+
+        log.info('updated', {
+          space: space.key,
+          objects: objectIds.size,
+          added: added.length,
+          updated: updated.length,
+          count,
+        });
+        if (count++) {
+          task.schedule();
+        }
+      });
+
+      ctx.onDispose(() => selection.unsubscribe());
+
+      const query = space.db.query({ ...trigger.subscription.props, '@type': trigger.subscription.type });
+      const unsubscribe = query.subscribe(({ objects }) => {
+        selection.update(objects);
+      });
+
+      // Trigger first update, but don't schedule task.
+      // selection.update(query.objects);
+
+      ctx.onDispose(unsubscribe);
+
+      log.info('mounted', { space: space.key, trigger });
+    }
+  }
+
+  private async unmount(name: string, spaceKey: PublicKey) {
+    const key = { name, spaceKey };
+    const { ctx } = this._mounts.get(key) ?? {};
+    if (ctx) {
+      this._mounts.delete(key);
+      await ctx.dispose();
+    }
+  }
+
+  private async invokeFunction(options: InvokeOptions, functionName: string, data: any) {
+    const { endpoint, runtime } = options;
+    assert(endpoint, 'Missing endpoint');
+    assert(runtime, 'Missing runtime');
+
+    try {
+      log('invoke', { function: functionName });
+      const url = `${endpoint}/${runtime}/${functionName}`;
+      const res = await fetch(url, {
+        method: 'POST',
+        body: JSON.stringify(data),
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+
+      log('result', { function: functionName, result: await res.json() });
+    } catch (err: any) {
+      log.error('error', { function: functionName, error: err.message });
+    }
+  }
+}

package/dist/types/src/functions.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=functions.test.d.ts.map

package/dist/types/src/functions.test.d.ts.map

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

package/dist/types/src/interface.d.ts

@@ -1,13 +0,0 @@
-import { Client } from '@dxos/client';
-export interface FunctionContext {
-    client: Client;
-    status(code: number): Reply;
-}
-export interface Reply {
-    status(code: number): Reply;
-    succeed(data: any): Reply;
-}
-export interface FunctionHandler {
-    (event: any, context: FunctionContext): Promise<Reply>;
-}
-//# sourceMappingURL=interface.d.ts.map

package/dist/types/src/interface.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../../src/interface.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IAEf,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC;CAC7B;AAED,MAAM,WAAW,KAAK;IACpB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC;IAC5B,OAAO,CAAC,IAAI,EAAE,GAAG,GAAG,KAAK,CAAC;CAC3B;AAED,MAAM,WAAW,eAAe;IAC9B,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;CACxD"}

package/src/interface.ts

@@ -1,20 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import { Client } from '@dxos/client';
-
-export interface FunctionContext {
-  client: Client;
-
-  status(code: number): Reply;
-}
-
-export interface Reply {
-  status(code: number): Reply;
-  succeed(data: any): Reply;
-}
-
-export interface FunctionHandler {
-  (event: any, context: FunctionContext): Promise<Reply>;
-}