@dxos/functions 0.8.2-main.12df754 → 0.8.2-main.30e4dbb

package/src/runtime/scheduler.ts

@@ -1,170 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import path from 'node:path';
-
-import { Mutex } from '@dxos/async';
-import { loadObjectReferences, type Space } from '@dxos/client/echo';
-import { Context } from '@dxos/context';
-import { Reference } from '@dxos/echo-protocol';
-import { log } from '@dxos/log';
-
-import { type FunctionRegistry } from '../function';
-import { type FunctionEventMeta } from '../handler';
-import { type TriggerCallback, type TriggerRegistry } from '../trigger';
-import { type FunctionDef, type FunctionManifest, type FunctionTrigger } from '../types';
-
-export type Callback = (data: any) => Promise<void | number>;
-
-export type SchedulerOptions = {
-  endpoint?: string;
-  callback?: Callback;
-};
-
-/**
- * The scheduler triggers function execution based on various trigger configurations.
- * Functions are scheduled within the context of a specific space.
- */
-export class Scheduler {
-  private _ctx = createContext();
-
-  private readonly _functionUriToCallMutex = new Map<string, Mutex>();
-
-  constructor(
-    public readonly functions: FunctionRegistry,
-    public readonly triggers: TriggerRegistry,
-    private readonly _options: SchedulerOptions = {},
-  ) {
-    this.functions.registered.on(async ({ space, added }) => {
-      await this._safeActivateTriggers(space, this.triggers.getInactiveTriggers(space), added);
-    });
-    this.triggers.registered.on(async ({ space, triggers }) => {
-      await this._safeActivateTriggers(space, triggers, this.functions.getFunctions(space));
-    });
-  }
-
-  async start() {
-    await this._ctx.dispose();
-    this._ctx = createContext();
-    await this.functions.open(this._ctx);
-    await this.triggers.open(this._ctx);
-  }
-
-  async stop() {
-    await this._ctx.dispose();
-    await this.functions.close();
-    await this.triggers.close();
-  }
-
-  // TODO(burdon): Remove and update registries directly?
-  public async register(space: Space, manifest: FunctionManifest) {
-    await this.functions.register(space, manifest.functions);
-    await this.triggers.register(space, manifest);
-  }
-
-  private async _safeActivateTriggers(
-    space: Space,
-    triggers: FunctionTrigger[],
-    functions: FunctionDef[],
-  ): Promise<void> {
-    const mountTasks = triggers.map((trigger) => {
-      return this.activate(space, functions, trigger);
-    });
-
-    await Promise.all(mountTasks).catch(log.catch);
-  }
-
-  /**
-   * Activate trigger.
-   */
-  // TODO(burdon): How are triggers deactivated?
-  private async activate(space: Space, functions: FunctionDef[], trigger: FunctionTrigger) {
-    const definition = functions.find((def) => def.uri === trigger.function);
-    if (!definition) {
-      log.info('function is not found for trigger', { trigger });
-      return;
-    }
-
-    const execFunction: TriggerCallback = async (args) => {
-      const mutex = this._functionUriToCallMutex.get(definition.uri) ?? new Mutex();
-      this._functionUriToCallMutex.set(definition.uri, mutex);
-
-      log.info('function triggered, waiting for mutex', { uri: definition.uri });
-      return mutex.executeSynchronized(async () => {
-        log.info('mutex acquired', { uri: definition.uri });
-
-        // Load potential references in meta properties to serialize.
-        await loadObjectReferences(trigger, (t) => Object.values(t.meta ?? {}));
-        const meta: FunctionTrigger['meta'] = {};
-        for (const [key, value] of Object.entries(trigger.meta ?? {})) {
-          if (value instanceof Reference) {
-            const object = await space.db.query({ id: value.objectId }).first();
-            if (object) {
-              meta[key] = object;
-            }
-          } else {
-            meta[key] = value;
-          }
-        }
-
-        return this._execFunction(definition, trigger, {
-          meta,
-          data: { ...args, spaceKey: space.key },
-        });
-      });
-    };
-
-    await this.triggers.activate(space, trigger, execFunction);
-    log('activated trigger', { space: space.key, trigger });
-  }
-
-  /**
-   * Invoke function RPC.
-   */
-  private async _execFunction<TData, TMeta>(
-    def: FunctionDef,
-    trigger: FunctionTrigger,
-    { meta, data }: { meta?: TMeta; data: TData },
-  ): Promise<number> {
-    let status = 0;
-    try {
-      // TODO(burdon): Pass in Space key (common context)?
-      const payload = Object.assign({}, meta && ({ meta } satisfies FunctionEventMeta<TMeta>), data);
-
-      const { endpoint, callback } = this._options;
-      if (endpoint) {
-        // TODO(burdon): Move out of scheduler (generalize as callback).
-        const url = path.join(endpoint, def.route);
-        log.info('exec', { function: def.uri, url, triggerType: trigger.spec?.type });
-        const response = await fetch(url, {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-          },
-          body: JSON.stringify(payload),
-        });
-
-        status = response.status;
-      } else if (callback) {
-        log.info('exec', { function: def.uri });
-        status = (await callback(payload)) ?? 200;
-      }
-
-      // Check errors.
-      if (status && status >= 400) {
-        throw new Error(`Response: ${status}`);
-      }
-
-      // const result = await response.json();
-      log.info('done', { function: def.uri, status });
-    } catch (err: any) {
-      log.error('error', { function: def.uri, error: err.message });
-      status = 500;
-    }
-
-    return status;
-  }
-}
-
-const createContext = () => new Context({ name: 'FunctionScheduler' });

package/src/testing/functions-integration.test.ts

@@ -1,65 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { afterAll, beforeAll, describe, expect, test } from 'vitest';
-
-import { Trigger } from '@dxos/async';
-import { live } from '@dxos/client/echo';
-import { TestBuilder } from '@dxos/client/testing';
-
-import { initFunctionsPlugin } from './plugin-init';
-import { setTestCallHandler } from './test/handler';
-import { createInitializedClients, inviteMember, startFunctionsHost, TestType } from '../testing';
-import { FunctionDef, FunctionTrigger, TriggerKind } from '../types';
-
-// TODO(wittjosiah): Doesn't work in vitest.
-describe.skip('functions e2e', () => {
-  let testBuilder: TestBuilder;
-
-  beforeAll(async () => {
-    testBuilder = new TestBuilder();
-  });
-
-  afterAll(async () => {
-    await testBuilder.destroy();
-  });
-
-  test('a function gets triggered in response to another peer object creations', async () => {
-    // TODO(burdon): Create builder pattern.
-    const functionRuntime = await startFunctionsHost(testBuilder, initFunctionsPlugin);
-
-    const app = (await createInitializedClients(testBuilder, 1))[0];
-    const space = await app.spaces.create();
-    await inviteMember(space, functionRuntime.client);
-
-    const uri = 'example.com/function/test';
-    space.db.add(live(FunctionDef, { uri, route: '/test', handler: 'test' }));
-    const triggerMeta: FunctionTrigger['meta'] = { name: 'DXOS' };
-    space.db.add(
-      live(FunctionTrigger, {
-        function: uri,
-        enabled: true,
-        meta: triggerMeta,
-        spec: {
-          type: TriggerKind.Subscription,
-          filter: { type: TestType.typename },
-        },
-      }),
-    );
-
-    const called = new Trigger<any>();
-    setTestCallHandler(async (args) => {
-      called.wake(args.event.data);
-      return args.response.status(200);
-    });
-
-    await functionRuntime.waitForActiveTriggers(space);
-    const addedObject = space.db.add(live(TestType, { title: '42' }));
-
-    const callArgs = await called.wait();
-    expect(callArgs.meta).to.deep.eq(triggerMeta);
-    expect(callArgs.objects).to.deep.eq([addedObject.id]);
-    expect(callArgs.spaceKey).to.eq(space.key.toHex());
-  });
-});

package/src/testing/index.ts

@@ -1,8 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-export * from './setup';
-export * from './types';
-export * from './util';
-export * from './manifest';

package/src/testing/manifest.ts

@@ -1,15 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import type { FunctionManifest } from '../types';
-
-export const testFunctionManifest: FunctionManifest = {
-  functions: [
-    {
-      uri: 'example.com/function/test',
-      route: 'test',
-      handler: 'test',
-    },
-  ],
-};

package/src/testing/plugin-init.ts

@@ -1,20 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { FunctionsPlugin } from '@dxos/agent';
-import { type Client } from '@dxos/client';
-
-import { type FunctionsPluginInitializer } from './setup';
-
-/**
- * Deliberately in a non-exported file to keep @dxos/agent as a devDependency.
- */
-export const initFunctionsPlugin: FunctionsPluginInitializer = async (client: Client) => {
-  const plugin = new FunctionsPlugin();
-  await plugin.initialize({ client, clientServices: client.services });
-  await plugin.open();
-  return {
-    close: () => plugin.close(),
-  };
-};

package/src/testing/setup.ts

@@ -1,109 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { getRandomPort } from 'get-port-please';
-import path from 'node:path';
-
-import { waitForCondition } from '@dxos/async';
-import { Client, Config } from '@dxos/client';
-import { type Space } from '@dxos/client/echo';
-import { type TestBuilder } from '@dxos/client/testing';
-import { range } from '@dxos/util';
-
-import { TestType } from './types';
-import { FunctionRegistry } from '../function';
-import { DevServer, type DevServerOptions, Scheduler } from '../runtime';
-import { TriggerRegistry } from '../trigger';
-import { FunctionDef, FunctionTrigger } from '../types';
-
-export type FunctionsPluginInitializer = (client: Client) => Promise<{ close: () => Promise<void> }>;
-
-// TODO(burdon): Extend/wrap TestBuilder.
-
-export const createInitializedClients = async (testBuilder: TestBuilder, count: number = 1, config?: Config) => {
-  const clients = range(count).map(
-    () =>
-      new Client({
-        config,
-        services: testBuilder.createLocalClientServices(),
-        types: [FunctionDef, FunctionTrigger, TestType],
-      }),
-  );
-
-  testBuilder.ctx.onDispose(() => Promise.all(clients.map((client) => client.destroy())));
-  return Promise.all(
-    clients.map(async (client, index) => {
-      await client.initialize();
-      await client.halo.createIdentity({ displayName: `Peer ${index}` });
-      await client.spaces.waitUntilReady();
-      return client;
-    }),
-  );
-};
-
-export const createFunctionRuntime = async (
-  testBuilder: TestBuilder,
-  pluginInitializer: FunctionsPluginInitializer,
-): Promise<Client> => {
-  const functionsPort = await getRandomPort('127.0.0.1');
-  const config = new Config({
-    runtime: {
-      agent: {
-        plugins: [{ id: 'dxos.org/agent/plugin/functions', config: { port: functionsPort } }],
-      },
-    },
-  });
-
-  const [client] = await createInitializedClients(testBuilder, 1, config);
-  const plugin = await pluginInitializer(client);
-  testBuilder.ctx.onDispose(() => plugin.close());
-  return client;
-};
-
-export const startFunctionsHost = async (
-  testBuilder: TestBuilder,
-  pluginInitializer: FunctionsPluginInitializer,
-  options?: DevServerOptions,
-) => {
-  const functionRuntime = await createFunctionRuntime(testBuilder, pluginInitializer);
-  const functionsRegistry = new FunctionRegistry(functionRuntime);
-  const devServer = await startDevServer(testBuilder, functionRuntime, functionsRegistry, options);
-  const scheduler = await startScheduler(testBuilder, functionRuntime, devServer, functionsRegistry);
-  return {
-    scheduler,
-    client: functionRuntime,
-    waitForActiveTriggers: async (space: Space) => {
-      await waitForCondition({ condition: () => scheduler.triggers.getActiveTriggers(space).length > 0 });
-    },
-  };
-};
-
-const startScheduler = async (
-  testBuilder: TestBuilder,
-  client: Client,
-  devServer: DevServer,
-  functionRegistry: FunctionRegistry,
-) => {
-  const triggerRegistry = new TriggerRegistry(client);
-  const scheduler = new Scheduler(functionRegistry, triggerRegistry, { endpoint: devServer.endpoint });
-  await scheduler.start();
-  testBuilder.ctx.onDispose(() => scheduler.stop());
-  return scheduler;
-};
-
-const startDevServer = async (
-  testBuilder: TestBuilder,
-  client: Client,
-  functionRegistry: FunctionRegistry,
-  options?: { baseDir?: string },
-) => {
-  const server = new DevServer(client, functionRegistry, {
-    baseDir: path.join(__dirname, '../testing'),
-    port: await getRandomPort('127.0.0.1'),
-    ...options,
-  });
-  await server.start();
-  testBuilder.ctx.onDispose(() => server.stop());
-  return server;
-};

package/src/testing/test/handler.ts

@@ -1,15 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import { type FunctionHandler } from '../../handler';
-
-let callHandler: FunctionHandler<any> = async ({ response }) => response.status(200);
-
-export const setTestCallHandler = (handler: FunctionHandler<any>) => {
-  callHandler = handler;
-};
-
-export const handler: FunctionHandler<any> = async (args) => {
-  return callHandler(args);
-};

package/src/testing/test/index.ts

@@ -1,7 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import { handler } from './handler';
-
-export default handler;

package/src/testing/types.ts

@@ -1,9 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { S, TypedObject } from '@dxos/echo-schema';
-
-export class TestType extends TypedObject({ typename: 'example.com/type/Test', version: '0.1.0' })({
-  title: S.String,
-}) {}

package/src/testing/util.ts

@@ -1,26 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import type { Client } from '@dxos/client';
-import { Filter, type Space } from '@dxos/client/echo';
-import { performInvitation } from '@dxos/client/testing';
-import { invariant } from '@dxos/invariant';
-import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
-
-import { FunctionTrigger } from '../types';
-
-export const triggerWebhook = async (space: Space, uri: string) => {
-  const trigger = (
-    await space.db.query(Filter.schema(FunctionTrigger, (trigger: FunctionTrigger) => trigger.function === uri)).run()
-  ).objects[0];
-  invariant(trigger.spec?.type === 'webhook');
-  void fetch(`http://localhost:${trigger.spec.port}`);
-};
-
-export const inviteMember = async (host: Space, guest: Client) => {
-  const [{ invitation: hostInvitation }] = await Promise.all(performInvitation({ host, guest: guest.spaces }));
-  if (hostInvitation?.state !== Invitation.State.SUCCESS) {
-    throw new Error(`Expected ${hostInvitation?.state} to be ${Invitation.State.SUCCESS}.`);
-  }
-};

package/src/trigger/index.ts

@@ -1,6 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-export * from './trigger-registry';
-export * from './type';