@dxos/functions 0.5.3-main.6f2dfea → 0.5.3-main.79e0565

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

@@ -0,0 +1,91 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import WebSocket from 'ws';
+
+import { sleep, Trigger } from '@dxos/async';
+import { type Context } from '@dxos/context';
+import { log } from '@dxos/log';
+
+import { type WebsocketTrigger } from '../../types';
+import { type TriggerCallback, type TriggerContext, type TriggerFactory } from '../trigger-registry';
+
+interface WebsocketTriggerOptions {
+  retryDelay: number;
+  maxAttempts: number;
+}
+
+/**
+ * Websocket.
+ * NOTE: The port must be unique, so the same hook cannot be used for multiple spaces.
+ */
+export const createWebsocketTrigger: TriggerFactory<WebsocketTrigger, WebsocketTriggerOptions> = async (
+  ctx: Context,
+  triggerCtx: TriggerContext,
+  spec: WebsocketTrigger,
+  callback: TriggerCallback,
+  options: WebsocketTriggerOptions = { retryDelay: 2, maxAttempts: 5 },
+) => {
+  const { url, init } = spec;
+
+  let ws: WebSocket;
+  for (let attempt = 1; attempt <= options.maxAttempts; attempt++) {
+    const open = new Trigger<boolean>();
+
+    ws = new WebSocket(url);
+    Object.assign(ws, {
+      onopen: () => {
+        log.info('opened', { url });
+        if (spec.init) {
+          ws.send(new TextEncoder().encode(JSON.stringify(init)));
+        }
+
+        open.wake(true);
+      },
+
+      onclose: (event) => {
+        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) {
+          setTimeout(async () => {
+            log.info(`reconnecting in ${options.retryDelay}s...`, { url });
+            await createWebsocketTrigger(ctx, triggerCtx, spec, callback, options);
+          }, options.retryDelay * 1_000);
+        }
+
+        open.wake(false);
+      },
+
+      onerror: (event) => {
+        log.catch(event.error, { url });
+      },
+
+      onmessage: async (event) => {
+        try {
+          log.info('message');
+          const data = JSON.parse(new TextDecoder().decode(event.data as Uint8Array));
+          await callback({ data });
+        } catch (err) {
+          log.catch(err, { url });
+        }
+      },
+    } satisfies Partial<WebSocket>);
+
+    const isOpen = await open.wait();
+    if (isOpen) {
+      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);
+      }
+    }
+  }
+
+  ctx.onDispose(() => {
+    ws?.close();
+  });
+};

package/src/types.ts

@@ -2,28 +2,19 @@
 // Copyright 2023 DXOS.org
 //
 
-import * as S from '@effect/schema/Schema';
+import { RawObject, S, TypedObject } from '@dxos/echo-schema';
 
-const TimerTriggerSchema = S.struct({
-  cron: S.string,
-});
-
-const WebhookTriggerSchema = S.mutable(
-  S.struct({
-    method: S.string,
-    // Assigned port.
-    port: S.optional(S.number),
-  }),
-);
-
-const WebsocketTriggerSchema = S.struct({
-  url: S.string,
-  init: S.optional(S.record(S.string, S.any)),
-});
+/**
+ * Type discriminator for TriggerSpec.
+ * Every spec has a type field of type FunctionTriggerType that we can use to understand which
+ * type we're working with.
+ * https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions
+ */
+export type FunctionTriggerType = 'subscription' | 'timer' | 'webhook' | 'websocket';
 
 const SubscriptionTriggerSchema = S.struct({
-  spaceKey: S.optional(S.string),
-  // TODO(burdon): Define query DSL.
+  type: S.literal('subscription'),
+  // TODO(burdon): Define query DSL (from ECHO).
   filter: S.array(
     S.struct({
       type: S.string,
@@ -40,46 +31,73 @@ const SubscriptionTriggerSchema = S.struct({
   ),
 });
 
-const FunctionTriggerSchema = S.struct({
-  function: S.string.pipe(S.description('Function ID/URI.')),
-
-  // Context passed to function.
-  context: S.optional(S.record(S.string, S.any)),
+export type SubscriptionTrigger = S.Schema.Type<typeof SubscriptionTriggerSchema>;
 
-  // Triggers.
-  timer: S.optional(TimerTriggerSchema),
-  webhook: S.optional(WebhookTriggerSchema),
-  websocket: S.optional(WebsocketTriggerSchema),
-  subscription: S.optional(SubscriptionTriggerSchema),
+const TimerTriggerSchema = 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,
+    // Assigned port.
+    port: S.optional(S.number),
+  }),
+);
+
 export type WebhookTrigger = S.Schema.Type<typeof WebhookTriggerSchema>;
+
+const WebsocketTriggerSchema = 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>;
-export type SubscriptionTrigger = S.Schema.Type<typeof SubscriptionTriggerSchema>;
-export type FunctionTrigger = S.Schema.Type<typeof FunctionTriggerSchema>;
+
+const TriggerSpecSchema = S.union(
+  TimerTriggerSchema,
+  WebhookTriggerSchema,
+  WebsocketTriggerSchema,
+  SubscriptionTriggerSchema,
+);
+
+export type TriggerSpec = TimerTrigger | WebhookTrigger | WebsocketTrigger | SubscriptionTrigger;
 
 /**
  * Function definition.
  */
-// TODO(burdon): Name vs. path?
-const FunctionDefSchema = S.struct({
-  id: S.string,
-  // name: S.string,
+export class FunctionDef extends TypedObject({
+  typename: 'dxos.org/type/FunctionDef',
+  version: '0.1.0',
+})({
+  uri: S.string,
   description: S.optional(S.string),
-  path: S.string,
+  route: S.string,
   // TODO(burdon): NPM/GitHub/Docker/CF URL?
   handler: S.string,
-});
+}) {}
 
-export type FunctionDef = S.Schema.Type<typeof FunctionDefSchema>;
+export class FunctionTrigger extends TypedObject({
+  typename: 'dxos.org/type/FunctionTrigger',
+  version: '0.1.0',
+})({
+  function: S.string.pipe(S.description('Function URI.')),
+  // Context is merged into the event data passed to the function.
+  meta: S.optional(S.object),
+  spec: TriggerSpecSchema,
+}) {}
 
 /**
  * Function manifest file.
  */
 export const FunctionManifestSchema = S.struct({
-  functions: S.mutable(S.array(FunctionDefSchema)),
-  triggers: S.optional(S.mutable(S.array(FunctionTriggerSchema))),
+  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>;

package/src/util.test.ts

@@ -0,0 +1,43 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { expect } from 'chai';
+
+import { describe, test } from '@dxos/test';
+
+import { diff, intersection } from './util';
+
+describe('diff', () => {
+  test('returns the difference between two sets', () => {
+    {
+      const { added, updated, removed } = diff<number>([], [], (a, b) => a === b);
+      expect(added).to.deep.eq([]);
+      expect(updated).to.deep.eq([]);
+      expect(removed).to.deep.eq([]);
+    }
+    {
+      const previous = [1, 2, 3];
+      const next = [2, 3, 4];
+      const { added, updated, removed } = diff(previous, next, (a, b) => a === b);
+      expect(added).to.deep.eq([4]);
+      expect(updated).to.deep.eq([2, 3]);
+      expect(removed).to.deep.eq([1]);
+    }
+    {
+      const previous = [{ x: 1 }, { x: 2 }, { x: 3 }];
+      const next = [{ x: 2 }, { x: 3 }, { x: 4 }];
+      const { added, updated, removed } = diff(previous, next, (a, b) => a.x === b.x);
+      expect(added).to.deep.eq([{ x: 4 }]);
+      expect(updated).to.deep.eq([{ x: 2 }, { x: 3 }]);
+      expect(removed).to.deep.eq([{ x: 1 }]);
+    }
+  });
+
+  test('intersection', () => {
+    expect(intersection([1, 2, 3], [2, 3, 4], (a, b) => a === b)).to.deep.eq([2, 3]);
+    expect(
+      intersection([{ x: 1 }, { x: 2 }, { x: 3 }], [{ x: 2 }, { x: 3 }, { x: 4 }], (a, b) => a.x === b.x),
+    ).to.deep.eq([{ x: 2 }, { x: 3 }]);
+  });
+});

package/src/util.ts

@@ -0,0 +1,48 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export type Comparator<A, B = A> = (a: A, b: B) => boolean;
+
+export type DiffResult<A, B = A> = {
+  added: B[];
+  updated: A[];
+  removed: A[];
+};
+
+/**
+ *
+ * @param previous
+ * @param next
+ * @param comparator
+ */
+// TODO(burdon): Factor out.
+export const diff = <A, B = A>(
+  previous: readonly A[],
+  next: readonly B[],
+  comparator: Comparator<A, B>,
+): DiffResult<A, B> => {
+  const remaining = [...previous];
+  const result: DiffResult<A, B> = {
+    added: [],
+    updated: [],
+    removed: remaining,
+  };
+
+  // TODO(burdon): Mark and sweep.
+  for (const object of next) {
+    const index = remaining.findIndex((item) => comparator(item, object));
+    if (index === -1) {
+      result.added.push(object);
+    } else {
+      result.updated.push(remaining[index]);
+      remaining.splice(index, 1);
+    }
+  }
+
+  return result;
+};
+
+// TODO(burdon): Factor out.
+export const intersection = <A, B = A>(a: A[], b: B[], comparator: Comparator<A, B>): A[] =>
+  a.filter((a) => b.find((b) => comparator(a, b)) !== undefined);