@dxos/functions 0.5.4-next.70d721e → 0.5.4

package/src/runtime/dev-server.ts

@@ -7,7 +7,7 @@ import { getPort } from 'get-port-please';
 import type http from 'http';
 import { join } from 'node:path';
 
-import { asyncTimeout, Event, Trigger } from '@dxos/async';
+import { Event, Trigger } from '@dxos/async';
 import { type Client } from '@dxos/client';
 import { Context } from '@dxos/context';
 import { invariant } from '@dxos/invariant';
@@ -45,7 +45,14 @@ export class DevServer {
     private readonly _client: Client,
     private readonly _functionsRegistry: FunctionRegistry,
     private readonly _options: DevServerOptions,
-  ) {}
+  ) {
+    // TODO(burdon): Add/remove listener in start/stop.
+    this._functionsRegistry.registered.on(async ({ added }) => {
+      added.forEach((def) => this._load(def));
+      await this._safeUpdateRegistration();
+      log('new functions loaded', { added });
+    });
+  }
 
   get stats() {
     return {
@@ -85,7 +92,7 @@ export class DevServer {
         }
 
         // TODO(burdon): Get function context.
-        res.statusCode = await asyncTimeout(this.invoke('/' + path, req.body), 20_000);
+        res.statusCode = await this.invoke('/' + path, req.body);
         res.end();
       } catch (err: any) {
         log.catch(err);
@@ -94,7 +101,7 @@ export class DevServer {
       }
     });
 
-    this._port = this._options.port ?? (await getPort({ host: 'localhost', port: 7200, portRange: [7200, 7299] }));
+    this._port = await getPort({ host: 'localhost', port: 7200, portRange: [7200, 7299] });
     this._server = app.listen(this._port);
 
     try {
@@ -108,8 +115,7 @@ export class DevServer {
       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)));
+      await this._functionsRegistry.open(this._ctx);
     } catch (err: any) {
       await this.stop();
       throw new Error('FunctionRegistryService not available (check plugin is configured).');
@@ -119,12 +125,8 @@ export class DevServer {
   }
 
   async stop() {
-    if (!this._server) {
-      return;
-    }
-
+    invariant(this._server);
     log.info('stopping...');
-    await this._ctx.dispose();
 
     const trigger = new Trigger();
     this._server.close(async () => {
@@ -153,12 +155,6 @@ export class DevServer {
     log.info('stopped');
   }
 
-  private async _handleNewFunctions(newFunctions: FunctionDef[]) {
-    newFunctions.forEach((def) => this._load(def));
-    await this._safeUpdateRegistration();
-    log('new functions loaded', { newFunctions });
-  }
-
   /**
    * Load function.
    */

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

@@ -3,15 +3,20 @@
 //
 
 import { expect } from 'chai';
+import path from 'path';
 
-import { Trigger } from '@dxos/async';
-import { create } from '@dxos/client/echo';
-import { TestBuilder } from '@dxos/client/testing';
+import { Trigger, waitForCondition } from '@dxos/async';
+import { type Client } from '@dxos/client';
+import { create, type Space } from '@dxos/client/echo';
+import { performInvitation, TestBuilder } from '@dxos/client/testing';
+import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { describe, test } from '@dxos/test';
 
-import { initFunctionsPlugin } from './plugin-init';
 import { setTestCallHandler } from './test/handler';
-import { createInitializedClients, inviteMember, startFunctionsHost, TestType } from '../testing';
+import { FunctionRegistry } from '../function';
+import { DevServer, Scheduler } from '../runtime';
+import { createFunctionRuntime, createInitializedClients, TestType } from '../testing';
+import { TriggerRegistry } from '../trigger';
 import { FunctionDef, FunctionTrigger } from '../types';
 
 describe('functions e2e', () => {
@@ -25,11 +30,13 @@ describe('functions e2e', () => {
 
   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 functionRuntime = await createFunctionRuntime(testBuilder);
+    const devServer = await startDevServer(functionRuntime);
+    const scheduler = await startScheduler(functionRuntime, devServer);
 
     const app = (await createInitializedClients(testBuilder, 1))[0];
     const space = await app.spaces.create();
-    await inviteMember(space, functionRuntime.client);
+    await inviteMember(space, functionRuntime);
 
     const uri = 'example.com/function/test';
     space.db.add(create(FunctionDef, { uri, route: '/test', handler: 'test' }));
@@ -52,7 +59,7 @@ describe('functions e2e', () => {
       return args.response.status(200);
     });
 
-    await functionRuntime.waitHasActiveTriggers(space);
+    await waitTriggersReplicated(space, scheduler);
     const addedObject = space.db.add(create(TestType, { title: '42' }));
 
     const callArgs = await called.wait();
@@ -60,4 +67,34 @@ describe('functions e2e', () => {
     expect(callArgs.objects).to.deep.eq([addedObject.id]);
     expect(callArgs.spaceKey).to.eq(space.key.toHex());
   });
+
+  const waitTriggersReplicated = async (space: Space, scheduler: Scheduler) => {
+    await waitForCondition({ condition: () => scheduler.triggers.getActiveTriggers(space).length > 0 });
+  };
+
+  // TODO(burdon): Factor out utils to builder pattern.
+
+  const startScheduler = async (client: Client, devServer: DevServer) => {
+    const functionRegistry = new FunctionRegistry(client);
+    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 (client: Client) => {
+    const functionRegistry = new FunctionRegistry(client);
+    const server = new DevServer(client, functionRegistry, {
+      baseDir: path.join(__dirname, '../testing'),
+    });
+    await server.start();
+    testBuilder.ctx.onDispose(() => server.stop());
+    return server;
+  };
+
+  const inviteMember = async (host: Space, guest: Client) => {
+    const [{ invitation: hostInvitation }] = await Promise.all(performInvitation({ host, guest: guest.spaces }));
+    expect(hostInvitation?.state).to.eq(Invitation.State.SUCCESS);
+  };
 });

package/src/testing/index.ts

@@ -5,4 +5,3 @@
 export * from './setup';
 export * from './types';
 export * from './util';
-export * from './manifest';

package/src/testing/setup.ts

@@ -2,24 +2,14 @@
 // Copyright 2024 DXOS.org
 //
 
-import path from 'node:path';
-
-import { waitForCondition } from '@dxos/async';
+import { FunctionsPlugin } from '@dxos/agent';
 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';
 
-let functionsPort = 8081;
-
-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) => {
@@ -35,66 +25,19 @@ export const createInitializedClients = async (testBuilder: TestBuilder, count:
   );
 };
 
-export const createFunctionRuntime = async (
-  testBuilder: TestBuilder,
-  pluginInitializer: FunctionsPluginInitializer,
-): Promise<Client> => {
+export const createFunctionRuntime = async (testBuilder: TestBuilder): Promise<Client> => {
   const config = new Config({
     runtime: {
       agent: {
-        plugins: [{ id: 'dxos.org/agent/plugin/functions', config: { port: functionsPort++ } }],
+        plugins: [{ id: 'dxos.org/agent/plugin/functions', config: { port: 8080 } }],
       },
     },
   });
 
   const [client] = await createInitializedClients(testBuilder, 1, config);
-  const plugin = await pluginInitializer(client);
+  const plugin = new FunctionsPlugin();
+  await plugin.initialize({ client, clientServices: client.services });
+  await plugin.open();
   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,
-    waitHasActiveTriggers: 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'),
-    ...options,
-  });
-  await server.start();
-  testBuilder.ctx.onDispose(() => server.stop());
-  return server;
-};

package/src/testing/util.ts

@@ -2,11 +2,8 @@
 // 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';
 
@@ -17,10 +14,3 @@ export const triggerWebhook = async (space: Space, uri: string) => {
   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}.`);
-  }
-};