@dxos/functions 0.5.4 → 0.5.5-main.1aa8b60

package/src/testing/setup.ts

@@ -2,14 +2,23 @@
 // Copyright 2024 DXOS.org
 //
 
-import { FunctionsPlugin } from '@dxos/agent';
+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) => {
@@ -19,25 +28,75 @@ export const createInitializedClients = async (testBuilder: TestBuilder, count:
     clients.map(async (client, index) => {
       await client.initialize();
       await client.halo.createIdentity({ displayName: `Peer ${index}` });
+      await client.spaces.isReady;
       client.addSchema(FunctionDef, FunctionTrigger, TestType);
       return client;
     }),
   );
 };
 
-export const createFunctionRuntime = async (testBuilder: TestBuilder): Promise<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: 8080 } }],
+        plugins: [{ id: 'dxos.org/agent/plugin/functions', config: { port: functionsPort } }],
       },
     },
   });
 
   const [client] = await createInitializedClients(testBuilder, 1, config);
-  const plugin = new FunctionsPlugin();
-  await plugin.initialize({ client, clientServices: client.services });
-  await plugin.open();
+  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,
+    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'),
+    port: await getRandomPort('127.0.0.1'),
+    ...options,
+  });
+  await server.start();
+  testBuilder.ctx.onDispose(() => server.stop());
+  return server;
+};

package/src/testing/types.ts

@@ -5,5 +5,5 @@
 import { S, TypedObject } from '@dxos/echo-schema';
 
 export class TestType extends TypedObject({ typename: 'example.com/type/Test', version: '0.1.0' })({
-  title: S.string,
+  title: S.String,
 }) {}

package/src/testing/util.ts

@@ -2,8 +2,11 @@
 // 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';
 
@@ -14,3 +17,10 @@ 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}.`);
+  }
+};

package/src/trigger/type/websocket-trigger.ts

@@ -30,6 +30,7 @@ export const createWebsocketTrigger: TriggerFactory<WebsocketTrigger, WebsocketT
 ) => {
   const { url, init } = spec;
 
+  let wasOpen = false;
   let ws: WebSocket;
   for (let attempt = 1; attempt <= options.maxAttempts; attempt++) {
     const open = new Trigger<boolean>();
@@ -49,18 +50,18 @@ export const createWebsocketTrigger: TriggerFactory<WebsocketTrigger, WebsocketT
         log.info('closed', { url, code: event.code });
         // Reconnect if server closes (e.g., CF restart).
         // https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent/code
-        if (event.code === 1006) {
+        if (event.code === 1006 && wasOpen && !ctx.disposed) {
           setTimeout(async () => {
             log.info(`reconnecting in ${options.retryDelay}s...`, { url });
             await createWebsocketTrigger(ctx, space, spec, callback, options);
           }, options.retryDelay * 1_000);
         }
-
         open.wake(false);
       },
 
       onerror: (event) => {
         log.catch(event.error, { url });
+        open.wake(false);
       },
 
       onmessage: async (event) => {
@@ -75,14 +76,17 @@ export const createWebsocketTrigger: TriggerFactory<WebsocketTrigger, WebsocketT
     } satisfies Partial<WebSocket>);
 
     const isOpen = await open.wait();
+    if (ctx.disposed) {
+      break;
+    }
     if (isOpen) {
+      wasOpen = true;
       break;
-    } else {
-      const wait = Math.pow(attempt, 2) * options.retryDelay;
-      if (attempt < options.maxAttempts) {
-        log.warn(`failed to connect; trying again in ${wait}s`, { attempt });
-        await sleep(wait * 1_000);
-      }
+    }
+    const wait = Math.pow(attempt, 2) * options.retryDelay;
+    if (attempt < options.maxAttempts) {
+      log.warn(`failed to connect; trying again in ${wait}s`, { attempt });
+      await sleep(wait * 1_000);
     }
   }
 

package/src/types.ts

@@ -13,21 +13,21 @@ import { RawObject, S, TypedObject } from '@dxos/echo-schema';
 export type FunctionTriggerType = 'subscription' | 'timer' | 'webhook' | 'websocket';
 
 const SubscriptionTriggerSchema = S.mutable(
-  S.struct({
-    type: S.literal('subscription'),
+  S.Struct({
+    type: S.Literal('subscription'),
     // TODO(burdon): Define query DSL (from ECHO).
-    filter: S.array(
-      S.struct({
-        type: S.string,
-        props: S.optional(S.record(S.string, S.any)),
+    filter: S.Array(
+      S.Struct({
+        type: S.String,
+        props: S.optional(S.Record(S.String, S.Any)),
       }),
     ),
     options: S.optional(
-      S.struct({
+      S.Struct({
         // Watch changes to object (not just creation).
-        deep: S.optional(S.boolean),
+        deep: S.optional(S.Boolean),
         // Debounce changes (delay in ms).
-        delay: S.optional(S.number),
+        delay: S.optional(S.Number),
       }),
     ),
   }),
@@ -36,36 +36,36 @@ const SubscriptionTriggerSchema = S.mutable(
 export type SubscriptionTrigger = S.Schema.Type<typeof SubscriptionTriggerSchema>;
 
 const TimerTriggerSchema = S.mutable(
-  S.struct({
-    type: S.literal('timer'),
-    cron: S.string,
+  S.Struct({
+    type: S.Literal('timer'),
+    cron: S.String,
   }),
 );
 
 export type TimerTrigger = S.Schema.Type<typeof TimerTriggerSchema>;
 
 const WebhookTriggerSchema = S.mutable(
-  S.struct({
-    type: S.literal('webhook'),
-    method: S.string,
+  S.Struct({
+    type: S.Literal('webhook'),
+    method: S.String,
     // Assigned port.
-    port: S.optional(S.number),
+    port: S.optional(S.Number),
   }),
 );
 
 export type WebhookTrigger = S.Schema.Type<typeof WebhookTriggerSchema>;
 
 const WebsocketTriggerSchema = S.mutable(
-  S.struct({
-    type: S.literal('websocket'),
-    url: S.string,
-    init: S.optional(S.record(S.string, S.any)),
+  S.Struct({
+    type: S.Literal('websocket'),
+    url: S.String,
+    init: S.optional(S.Record(S.String, S.Any)),
   }),
 );
 
 export type WebsocketTrigger = S.Schema.Type<typeof WebsocketTriggerSchema>;
 
-const TriggerSpecSchema = S.union(
+const TriggerSpecSchema = S.Union(
   TimerTriggerSchema,
   WebhookTriggerSchema,
   WebsocketTriggerSchema,
@@ -81,10 +81,10 @@ export class FunctionDef extends TypedObject({
   typename: 'dxos.org/type/FunctionDef',
   version: '0.1.0',
 })({
-  uri: S.string,
-  description: S.optional(S.string),
-  route: S.string,
-  handler: S.string,
+  uri: S.String,
+  description: S.optional(S.String),
+  route: S.String,
+  handler: S.String,
 }) {}
 
 /**
@@ -94,19 +94,19 @@ export class FunctionTrigger extends TypedObject({
   typename: 'dxos.org/type/FunctionTrigger',
   version: '0.1.0',
 })({
-  enabled: S.optional(S.boolean),
-  function: S.string.pipe(S.description('Function URI.')),
+  enabled: S.optional(S.Boolean),
+  function: S.String.pipe(S.description('Function URI.')),
   // The `meta` property is merged into the event data passed to the function.
-  meta: S.optional(S.mutable(S.any)),
+  meta: S.optional(S.mutable(S.Any)),
   spec: TriggerSpecSchema,
 }) {}
 
 /**
  * Function manifest file.
  */
-export const FunctionManifestSchema = S.struct({
-  functions: S.optional(S.mutable(S.array(RawObject(FunctionDef)))),
-  triggers: S.optional(S.mutable(S.array(RawObject(FunctionTrigger)))),
+export const FunctionManifestSchema = S.Struct({
+  functions: S.optional(S.mutable(S.Array(RawObject(FunctionDef)))),
+  triggers: S.optional(S.mutable(S.Array(RawObject(FunctionTrigger)))),
 });
 
 export type FunctionManifest = S.Schema.Type<typeof FunctionManifestSchema>;