@dxos/functions 0.8.2-main.12df754 → 0.8.2-main.2f9c567

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';

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

@@ -1,278 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import { afterEach, beforeEach, describe, expect, test } from 'vitest';
-
-import { sleep, Trigger, waitForCondition } from '@dxos/async';
-import { type Client } from '@dxos/client';
-import { type Space } from '@dxos/client/echo';
-import { TestBuilder } from '@dxos/client/testing';
-import { Context } from '@dxos/context';
-import { Filter } from '@dxos/echo-db';
-import { splitMeta } from '@dxos/echo-schema';
-import { live } from '@dxos/live-object';
-import { range } from '@dxos/util';
-
-import { TriggerRegistry } from './trigger-registry';
-import { createInitializedClients, TestType, triggerWebhook } from '../testing';
-import { type FunctionManifest, FunctionTrigger, TriggerKind } from '../types';
-
-const manifest: FunctionManifest = {
-  triggers: [
-    {
-      '@meta': {
-        keys: [
-          {
-            source: 'example.com',
-            id: 'trigger-1',
-          },
-        ],
-      },
-      function: 'example.com/function/webhook-test',
-      enabled: true,
-      spec: {
-        type: TriggerKind.Webhook,
-        method: 'GET',
-      },
-    },
-    {
-      '@meta': {
-        keys: [
-          {
-            source: 'example.com',
-            id: 'trigger-2',
-          },
-        ],
-      },
-      function: 'example.com/function/subscription-test',
-      enabled: true,
-      spec: {
-        type: TriggerKind.Subscription,
-        filter: {
-          type: TestType.typename,
-        },
-      },
-    },
-  ],
-};
-
-describe('trigger registry', () => {
-  let ctx: Context;
-  let testBuilder: TestBuilder;
-
-  beforeEach(async () => {
-    ctx = new Context();
-    testBuilder = new TestBuilder();
-  });
-
-  afterEach(async () => {
-    await ctx.dispose();
-    await testBuilder.destroy();
-  });
-
-  describe('register', () => {
-    test('creates new triggers', async () => {
-      const [client] = await createInitializedClients(testBuilder);
-      const registry = createRegistry(client);
-      const space = await client.spaces.create();
-      await registry.register(space, manifest);
-      const { objects } = await space.db.query(Filter.schema(FunctionTrigger)).run();
-      expect(objects.length).to.eq(manifest.triggers?.length);
-
-      const expected = manifest.triggers?.map((trigger) => trigger.function).sort();
-      expect(objects.map((object: FunctionTrigger) => object.function).sort()).to.deep.eq(expected);
-    });
-
-    test('set meta', () => {
-      const trigger = live(FunctionTrigger, {
-        function: 'example.com/function/webhook-test',
-        spec: {
-          type: TriggerKind.Webhook,
-          method: 'GET',
-        },
-      });
-
-      (trigger.meta ??= {}).test = 100;
-      expect(trigger.meta.test).to.eq(100);
-    });
-  });
-
-  // TODO(burdon): Server-only.
-  describe.skip('activate', () => {
-    test('invokes the provided callback', async () => {
-      const [client] = await createInitializedClients(testBuilder);
-      const space = await client.spaces.create();
-      const registry = createRegistry(client);
-      await registry.register(space, manifest);
-      await registry.open(ctx);
-      await waitForInactiveTriggers(registry, space);
-
-      const callbackInvoked = new Trigger();
-      const { objects: allTriggers } = await space.db.query(Filter.schema(FunctionTrigger)).run();
-      const webhookTrigger = allTriggers.find((trigger: FunctionTrigger) => trigger.spec?.type === 'webhook')!;
-      await registry.activate(space, webhookTrigger, async () => {
-        callbackInvoked.wake();
-        return 200;
-      });
-
-      setTimeout(() => triggerWebhook(space, webhookTrigger.function!));
-      await callbackInvoked.wait();
-    });
-
-    test('removes from inactive list', async () => {
-      const [client] = await createInitializedClients(testBuilder);
-      const space = await client.spaces.create();
-      const registry = createRegistry(client);
-      await registry.register(space, manifest);
-      await registry.open(ctx);
-      await waitForInactiveTriggers(registry, space);
-
-      const inactiveTrigger = registry.getInactiveTriggers(space)[0];
-      await registry.activate(space, inactiveTrigger, async () => 200);
-
-      const updatedInactiveList = registry.getInactiveTriggers(space);
-      expect(updatedInactiveList.find((trigger: FunctionTrigger) => trigger.function === inactiveTrigger.function)).to
-        .be.undefined;
-    });
-
-    // TODO(burdon): Test enable/disable trigger.
-  });
-
-  describe('deactivate', () => {
-    test('trigger object deletion deactivates a trigger', async () => {
-      const [client] = await createInitializedClients(testBuilder);
-      const space = await client.spaces.create();
-      const registry = createRegistry(client);
-      await registry.register(space, manifest);
-      await registry.open(ctx);
-      await waitForInactiveTriggers(registry, space);
-
-      const { objects: allTriggers } = await space.db.query(Filter.schema(FunctionTrigger)).run();
-      const echoTrigger = allTriggers.find((trigger: FunctionTrigger) => trigger.spec?.type === 'subscription')!;
-      let count = 0;
-      await registry.activate(space, echoTrigger, async () => {
-        count++;
-        return 200;
-      });
-
-      space.db.add(live(TestType, { title: '1' }));
-      await sleep(110);
-      expect(count).to.eq(1);
-
-      space.db.remove(echoTrigger);
-      await sleep(110);
-      space.db.add(live(TestType, { title: '2' }));
-      await sleep(20);
-      expect(count).to.eq(1);
-    });
-
-    test('registry closing deactivates a trigger', async () => {
-      const [client] = await createInitializedClients(testBuilder);
-      const space = await client.spaces.create();
-      const registry = createRegistry(client);
-      await registry.register(space, manifest);
-      await registry.open(ctx);
-      await waitForInactiveTriggers(registry, space);
-
-      const { objects: allTriggers } = await space.db.query(Filter.schema(FunctionTrigger)).run();
-      const echoTrigger = allTriggers.find((trigger: FunctionTrigger) => trigger.spec?.type === 'subscription')!;
-      let count = 0;
-      await registry.activate(space, echoTrigger, async () => {
-        count++;
-        return 200;
-      });
-
-      await registry.close();
-
-      space.db.add(live(TestType, { title: '1' }));
-      await sleep(20);
-      expect(count).to.eq(0);
-    });
-  });
-
-  describe('trigger events', () => {
-    test('event fired when all registered are opened', async () => {
-      const [client] = await createInitializedClients(testBuilder);
-      const registry = createRegistry(client);
-      await client.spaces.default.waitUntilReady();
-      const triggers = createTriggers(client.spaces.default, 3);
-
-      const triggersRegistered = new Trigger<FunctionTrigger[]>();
-      registry.registered.on((fn) => {
-        expect(fn.space.key.toHex()).to.eq(client.spaces.default.key.toHex());
-        triggersRegistered.wake(fn.triggers);
-      });
-
-      void registry.open(ctx);
-      const functions = await triggersRegistered.wait();
-      const expected = triggers.map((object) => object.id).sort();
-      expect(functions.map((fn) => fn.id).sort()).to.deep.eq(expected);
-    });
-
-    test('event fired when a new trigger is added', async () => {
-      const [client] = await createInitializedClients(testBuilder);
-      const registry = createRegistry(client);
-      const space = await client.spaces.create();
-      await space.waitUntilReady();
-
-      const triggerRegistered = new Trigger<FunctionTrigger>();
-      registry.registered.on((fn) => {
-        expect(fn.triggers.length).to.eq(1);
-        triggerRegistered.wake(fn.triggers[0]);
-      });
-
-      await registry.open(ctx);
-      await registry.register(space, { triggers: manifest?.triggers?.slice(0, 1) });
-      const registered = await triggerRegistered.wait();
-      expect(registered.function).to.eq(manifest.triggers![0].function);
-    });
-
-    test('event fired when a new trigger is removed', async () => {
-      const [client] = await createInitializedClients(testBuilder);
-      const registry = createRegistry(client);
-      const space = await client.spaces.create();
-      await space.waitUntilReady();
-      const triggers = createTriggers(space, 3);
-
-      const triggerLoaded = new Trigger();
-      registry.registered.on(() => {
-        triggerLoaded.wake();
-      });
-
-      const triggerRemoved = new Trigger<FunctionTrigger>();
-      registry.removed.on((fn) => {
-        expect(fn.triggers.length).to.eq(1);
-        triggerRemoved.wake(fn.triggers[0]);
-      });
-
-      await registry.register(space, manifest);
-      await registry.open(ctx);
-      await triggerLoaded.wait();
-
-      space.db.remove(triggers[0]);
-      const removedTrigger = await triggerRemoved.wait();
-      expect(removedTrigger.id).to.eq(triggers[0].id);
-    });
-  });
-
-  const createRegistry = (client: Client) => {
-    const registry = new TriggerRegistry(client);
-    ctx.onDispose(() => registry.close());
-    return registry;
-  };
-
-  const createTriggers = (space: Space, count: number) => {
-    const triggers = range(count, () => {
-      const { meta, object } = splitMeta(manifest.triggers![0]);
-      return live(FunctionTrigger, object, meta);
-    });
-
-    triggers.forEach((trigger) => space.db.add(trigger));
-    return triggers;
-  };
-
-  const waitForInactiveTriggers = async (registry: TriggerRegistry, space: Space) => {
-    await waitForCondition({ condition: () => registry.getInactiveTriggers(space).length > 0 });
-  };
-});