@dxos/functions 0.8.1 → 0.8.2-main.10c050d

package/src/function/function-registry.test.ts

@@ -1,118 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import { afterEach, beforeEach, describe, expect, test } from 'vitest';
-
-import { Trigger } from '@dxos/async';
-import { type Client } from '@dxos/client';
-import { TestBuilder } from '@dxos/client/testing';
-import { Context } from '@dxos/context';
-import { Filter } from '@dxos/echo-db';
-import { create } from '@dxos/live-object';
-import { range } from '@dxos/util';
-
-import { FunctionRegistry } from './function-registry';
-import { createInitializedClients } from '../testing';
-import { FunctionDef, type FunctionManifest } from '../types';
-
-const testManifest: FunctionManifest = {
-  functions: [
-    {
-      uri: 'dxos.functions.test/hello',
-      route: '/hello',
-      handler: 'test',
-    },
-  ],
-};
-
-describe('function registry', () => {
-  let ctx: Context;
-  let testBuilder: TestBuilder;
-
-  beforeEach(async () => {
-    ctx = new Context();
-    testBuilder = new TestBuilder();
-  });
-
-  afterEach(async () => {
-    await ctx.dispose();
-    await testBuilder.destroy();
-  });
-
-  test('getUniqueByUri', async () => {
-    const client = (await createInitializedClients(testBuilder))[0];
-    const registry = createRegistry(client);
-    await registry.open();
-    for (let i = 0; i < 2; i++) {
-      const space = await client.spaces.create();
-      await registry.register(space, testManifest.functions);
-    }
-    const definitions = registry.getUniqueByUri();
-    expect(definitions.length).to.eq(testManifest.functions?.length);
-  });
-
-  describe('register', () => {
-    test('creates new functions', async () => {
-      const client = (await createInitializedClients(testBuilder))[0];
-      const registry = createRegistry(client);
-      const space = await client.spaces.create();
-      await registry.register(space, testManifest.functions);
-      const { objects: definitions } = await space.db.query(Filter.schema(FunctionDef)).run();
-      expect(definitions.length).to.eq(1);
-      expect(definitions[0].uri).to.eq(testManifest.functions?.[0]?.uri);
-    });
-
-    test('de-duplicates by function URI', async () => {
-      const client = (await createInitializedClients(testBuilder))[0];
-      const registry = createRegistry(client);
-      const space = await client.spaces.create();
-      const existing = space.db.add(create(FunctionDef, testManifest.functions![0]));
-      await registry.register(space, testManifest.functions);
-      const { objects: definitions } = await space.db.query(Filter.schema(FunctionDef)).run();
-      expect(definitions.length).to.eq(1);
-      expect(definitions[0].uri).to.eq(existing.uri);
-    });
-  });
-
-  describe('onFunctionsRegistered', () => {
-    test('called with all registered when opened', async () => {
-      const client = (await createInitializedClients(testBuilder))[0];
-      const registry = createRegistry(client);
-      const space = await client.spaces.create();
-      const definitions = range(3, () => create(FunctionDef, testManifest.functions![0]));
-      definitions.forEach((def) => space.db.add(def));
-
-      const functionRegistered = new Trigger<FunctionDef[]>();
-      registry.registered.on((fn) => {
-        functionRegistered.wake(fn.added);
-      });
-      void registry.open(ctx);
-      const functions = await functionRegistered.wait();
-      const expected = definitions.map((def) => def.uri).sort();
-      expect(functions.map((fn) => fn.uri).sort()).to.deep.eq(expected);
-    });
-
-    test('called when a new functions is added', async () => {
-      const client = (await createInitializedClients(testBuilder))[0];
-      const registry = createRegistry(client);
-      const space = await client.spaces.create();
-
-      const functionRegistered = new Trigger<FunctionDef>();
-      registry.registered.on((fn) => {
-        expect(fn.added.length).to.eq(1);
-        functionRegistered.wake(fn.added[0]);
-      });
-      await registry.open(ctx);
-      await registry.register(space, testManifest.functions);
-      const registered = await functionRegistered.wait();
-      expect(registered.uri).to.eq(testManifest.functions![0].uri);
-    });
-  });
-
-  const createRegistry = (client: Client) => {
-    const registry = new FunctionRegistry(client);
-    ctx.onDispose(() => registry.close());
-    return registry;
-  };
-});

package/src/function/function-registry.ts

@@ -1,104 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { Event } from '@dxos/async';
-import { type Client } from '@dxos/client';
-import { create, Filter, type Space } from '@dxos/client/echo';
-import { type Context, Resource } from '@dxos/context';
-import { PublicKey } from '@dxos/keys';
-import { log } from '@dxos/log';
-import { ComplexMap, diff } from '@dxos/util';
-
-import { FunctionDef, type FunctionManifest } from '../types';
-
-export type FunctionsRegisteredEvent = {
-  space: Space;
-  added: FunctionDef[];
-};
-
-export class FunctionRegistry extends Resource {
-  private readonly _functionBySpaceKey = new ComplexMap<PublicKey, FunctionDef[]>(PublicKey.hash);
-
-  public readonly registered = new Event<FunctionsRegisteredEvent>();
-
-  constructor(private readonly _client: Client) {
-    super();
-  }
-
-  public getFunctions(space: Space): FunctionDef[] {
-    return this._functionBySpaceKey.get(space.key) ?? [];
-  }
-
-  public getUniqueByUri(): FunctionDef[] {
-    const uniqueByUri = [...this._functionBySpaceKey.values()]
-      .flatMap((defs) => defs)
-      .reduce((acc, v) => {
-        acc.set(v.uri, v);
-        return acc;
-      }, new Map<string, FunctionDef>());
-    return [...uniqueByUri.values()];
-  }
-
-  /**
-   * Loads function definitions from the manifest into the space.
-   * We first load all the definitions from the space to deduplicate by functionId.
-   */
-  public async register(space: Space, functions: FunctionManifest['functions']): Promise<void> {
-    log('register', { space: space.key, functions: functions?.length ?? 0 });
-    if (!functions?.length) {
-      return;
-    }
-    if (!space.db.graph.schemaRegistry.hasSchema(FunctionDef)) {
-      space.db.graph.schemaRegistry.addSchema([FunctionDef]);
-    }
-
-    // Sync definitions.
-    const { objects: existing } = await space.db.query(Filter.schema(FunctionDef)).run();
-    const { added } = diff(existing, functions, (a, b) => a.uri === b.uri);
-    // TODO(burdon): Update existing templates.
-    added.forEach((def) => space.db.add(create(FunctionDef, def)));
-
-    if (added.length > 0) {
-      await space.db.flush({ indexes: true, updates: true });
-    }
-  }
-
-  protected override async _open(): Promise<void> {
-    log.info('opening...');
-    const spacesSubscription = this._client.spaces.subscribe(async (spaces) => {
-      for (const space of spaces) {
-        if (this._functionBySpaceKey.has(space.key)) {
-          continue;
-        }
-
-        const registered: FunctionDef[] = [];
-        this._functionBySpaceKey.set(space.key, registered);
-        await space.waitUntilReady();
-        if (this._ctx.disposed) {
-          break;
-        }
-
-        // Subscribe to updates.
-        this._ctx.onDispose(
-          space.db.query(Filter.schema(FunctionDef)).subscribe(({ objects }) => {
-            const { added } = diff(registered, objects, (a, b) => a.uri === b.uri);
-            // TODO(burdon): Update and remove.
-            if (added.length > 0) {
-              registered.push(...added);
-              this.registered.emit({ space, added });
-            }
-          }),
-        );
-      }
-    });
-
-    // TODO(burdon): API: Normalize unsubscribe methods.
-    this._ctx.onDispose(() => spacesSubscription.unsubscribe());
-  }
-
-  protected override async _close(_: Context): Promise<void> {
-    log.info('closing...');
-    this._functionBySpaceKey.clear();
-  }
-}

package/src/function/index.ts

@@ -1,5 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-export * from './function-registry';

package/src/runtime/dev-server.test.ts

@@ -1,79 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import { getRandomPort } from 'get-port-please';
-import path from 'node:path';
-import { afterAll, beforeAll, describe, expect, test } from 'vitest';
-
-import { sleep, waitForCondition } from '@dxos/async';
-import { type Client } from '@dxos/client';
-import { TestBuilder } from '@dxos/client/testing';
-
-import { DevServer } from './dev-server';
-import { FunctionRegistry } from '../function';
-import { createFunctionRuntime, testFunctionManifest } from '../testing';
-import { initFunctionsPlugin } from '../testing/plugin-init';
-
-// TODO(wittjosiah): Doesn't work in vitest.
-describe.skip('dev server', () => {
-  let client: Client;
-  let testBuilder: TestBuilder;
-
-  beforeAll(async () => {
-    testBuilder = new TestBuilder();
-    client = await createFunctionRuntime(testBuilder, initFunctionsPlugin);
-    expect(client.services.services.FunctionRegistryService).to.exist;
-  });
-
-  afterAll(async () => {
-    await testBuilder.destroy();
-  });
-
-  test('function registry open after dev server started', async () => {
-    const { space, registry, server } = await setupTest();
-    await registry.register(space, testFunctionManifest.functions);
-    await server.start();
-    await registry.open();
-    await waitForCondition({ condition: () => server.functions.length > 0 });
-    await expectTestFunctionInvocable(server);
-  });
-
-  test('function registry open before dev server started', async () => {
-    const { space, registry, server } = await setupTest();
-    await registry.register(space, testFunctionManifest.functions);
-    await registry.open();
-    await server.start();
-    await waitForCondition({ condition: () => server.functions.length > 0 });
-    await expectTestFunctionInvocable(server);
-  });
-
-  test('unsubscribes from functions after stopped', async () => {
-    const { space, registry, server } = await setupTest();
-    await registry.register(space, testFunctionManifest.functions);
-    await server.start();
-    await server.stop();
-    await registry.open();
-    await sleep(20);
-    expect(server.functions.length).to.eq(0);
-  });
-
-  const expectTestFunctionInvocable = async (server: DevServer) => {
-    const seq = server.stats.seq;
-    await server.invoke('test', {});
-    expect(server.stats.seq).to.eq(seq + 1);
-  };
-
-  const setupTest = async () => {
-    const registry = new FunctionRegistry(client);
-    const server = new DevServer(client, registry, {
-      baseDir: path.join(__dirname, '../testing'),
-      port: await getRandomPort('127.0.0.1'),
-    });
-    const space = await client.spaces.create();
-    // TODO(burdon): Doesn't shut down cleanly.
-    //  Error: invariant violation [this._client.services.services.FunctionRegistryService]
-    testBuilder.ctx.onDispose(() => server.stop());
-    return { registry, server, space };
-  };
-});

package/src/runtime/dev-server.ts

@@ -1,240 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import express from 'express';
-import { getPort } from 'get-port-please';
-import type http from 'http';
-import { join } from 'node:path';
-
-import { asyncTimeout, 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 FunctionRegistry } from '../function';
-import { type FunctionContext, type FunctionEvent, type FunctionHandler, type FunctionResponse } from '../handler';
-import { type FunctionDef } from '../types';
-
-const FN_TIMEOUT = 20_000;
-
-export type DevServerOptions = {
-  baseDir: string;
-  port?: number;
-  reload?: boolean;
-  dataDir?: string;
-};
-
-/**
- * Functions dev server provides a local HTTP server for loading and invoking functions.
- * Functions are executed in the context of an authenticated client.
- */
-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 _proxy?: string;
-  private _seq = 0;
-
-  public readonly update = new Event<number>();
-
-  constructor(
-    private readonly _client: Client,
-    private readonly _functionsRegistry: FunctionRegistry,
-    private readonly _options: DevServerOptions,
-  ) {}
-
-  get stats() {
-    return {
-      seq: this._seq,
-    };
-  }
-
-  get endpoint() {
-    invariant(this._port);
-    return `http://localhost:${this._port}`;
-  }
-
-  get proxy() {
-    return this._proxy;
-  }
-
-  get functions() {
-    return Object.values(this._handlers);
-  }
-
-  async start() {
-    invariant(!this._server);
-    log.info('starting...');
-    this._ctx = createContext();
-
-    // TODO(burdon): Change to hono.
-    const app = express();
-    app.use(express.json());
-
-    app.post('/:path', async (req, res) => {
-      const { path } = req.params;
-      try {
-        log.info('calling', { path });
-        if (this._options.reload) {
-          const { def } = this._handlers['/' + path];
-          await this._load(def, true);
-        }
-
-        // TODO(burdon): Get function context.
-        res.statusCode = await asyncTimeout(this.invoke('/' + path, req.body), FN_TIMEOUT);
-        res.end();
-      } catch (err: any) {
-        log.catch(err);
-        res.statusCode = 500;
-        res.end();
-      }
-    });
-
-    this._port = this._options.port ?? (await getPort({ host: 'localhost', port: 7200, portRange: [7200, 7299] }));
-    this._server = app.listen(this._port);
-
-    try {
-      // Register functions.
-      const { registrationId, endpoint } = await this._client.services.services.FunctionRegistryService!.register({
-        endpoint: this.endpoint,
-      });
-
-      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._handleNewFunctions(this._functionsRegistry.getUniqueByUri());
-      this._ctx.onDispose(this._functionsRegistry.registered.on(({ added }) => this._handleNewFunctions(added)));
-    } catch (err: any) {
-      await this.stop();
-      throw new Error('FunctionRegistryService not available (check plugin is configured).');
-    }
-
-    log.info('started', { port: this._port });
-  }
-
-  async stop() {
-    if (!this._server) {
-      return;
-    }
-
-    log.info('stopping...');
-    await this._ctx.dispose();
-
-    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;
-        }
-
-        trigger.wake();
-      } catch (err) {
-        trigger.throw(err as Error);
-      }
-    });
-
-    await trigger.wait();
-    this._port = undefined;
-    this._server = undefined;
-    log.info('stopped');
-  }
-
-  private async _handleNewFunctions(newFunctions: FunctionDef[]) {
-    newFunctions.forEach((def) => this._load(def));
-    await this._safeUpdateRegistration();
-    log('new functions loaded', { newFunctions });
-  }
-
-  /**
-   * Load function.
-   */
-  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 (force) {
-      Object.keys(require.cache)
-        .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(filePath);
-    if (typeof module.default !== 'function') {
-      throw new Error(`Handler must export default function: ${uri}`);
-    }
-
-    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 (err) {
-      log.catch(err);
-    }
-  }
-
-  /**
-   * Invoke function.
-   */
-  public async invoke(path: string, data: any): Promise<number> {
-    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}`);
-    const context: FunctionContext = {
-      client: this._client,
-      dataDir: this._options.dataDir,
-    } as any;
-
-    let statusCode = 200;
-    const response: FunctionResponse = {
-      status: (code: number) => {
-        statusCode = code;
-        return response;
-      },
-    };
-
-    await handler({ context, event, response });
-    return statusCode;
-  }
-}
-
-const createContext = () => new Context({ name: 'DevServer' });

package/src/runtime/index.ts

@@ -1,6 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-export * from './dev-server';
-export * from './scheduler';

package/src/runtime/scheduler.test.ts

@@ -1,152 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import { afterAll, beforeAll, describe, expect, test } from 'vitest';
-
-import { Trigger } from '@dxos/async';
-import { type Client } from '@dxos/client';
-import { TestBuilder } from '@dxos/client/testing';
-import { create } from '@dxos/live-object';
-
-import { Scheduler, type SchedulerOptions } from './scheduler';
-import { FunctionRegistry } from '../function';
-import { createInitializedClients, TestType, triggerWebhook } from '../testing';
-import { TriggerRegistry } from '../trigger';
-import { TriggerKind, type FunctionManifest } from '../types';
-
-// TODO(burdon): Test we can add and remove triggers.
-// Flaky: https://cloud.nx.app/runs/uqhKOBA6JQ/task/functions%3Atest
-describe.skip('scheduler', () => {
-  let testBuilder: TestBuilder;
-  let client: Client;
-
-  beforeAll(async () => {
-    testBuilder = new TestBuilder();
-    client = (await createInitializedClients(testBuilder, 1))[0];
-  });
-
-  afterAll(async () => {
-    await testBuilder.destroy();
-  });
-
-  const createScheduler = (callback: SchedulerOptions['callback']) => {
-    const scheduler = new Scheduler(new FunctionRegistry(client), new TriggerRegistry(client), { callback });
-
-    afterAll(async () => {
-      await scheduler.stop();
-    });
-
-    return scheduler;
-  };
-
-  test('timer', async () => {
-    const manifest: FunctionManifest = {
-      functions: [
-        {
-          uri: 'example.com/function/test',
-          route: '/test',
-          handler: 'test',
-        },
-      ],
-      triggers: [
-        {
-          function: 'example.com/function/test',
-          enabled: true,
-          spec: {
-            type: TriggerKind.Timer,
-            cron: '0/1 * * * * *', // Every 1s.
-          },
-        },
-      ],
-    };
-
-    let count = 0;
-    const done = new Trigger();
-    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);
-  });
-
-  // Flaky.
-  test.skip('webhook', async () => {
-    const manifest: FunctionManifest = {
-      functions: [
-        {
-          uri: 'example.com/function/test',
-          route: '/test',
-          handler: 'test',
-        },
-      ],
-      triggers: [
-        {
-          function: 'example.com/function/test',
-          enabled: true,
-          spec: {
-            type: TriggerKind.Webhook,
-            method: 'GET',
-          },
-        },
-      ],
-    };
-
-    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('subscription', async () => {
-    const manifest: FunctionManifest = {
-      functions: [
-        {
-          uri: 'example.com/function/test',
-          route: '/test',
-          handler: 'test',
-        },
-      ],
-      triggers: [
-        {
-          function: 'example.com/function/test',
-          enabled: true,
-          spec: {
-            type: TriggerKind.Subscription,
-            filter: { type: TestType.typename },
-          },
-        },
-      ],
-    };
-
-    let count = 0;
-    const done = new Trigger();
-    const scheduler = createScheduler(async () => {
-      if (++count === 1) {
-        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();
-  });
-});