@dxos/functions 0.5.3-main.8ffbbae → 0.5.3-main.908ba4f

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

@@ -0,0 +1,92 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import WebSocket from 'ws';
+
+import { sleep, Trigger } from '@dxos/async';
+import { type Space } from '@dxos/client/echo';
+import { type Context } from '@dxos/context';
+import { log } from '@dxos/log';
+
+import { type WebsocketTrigger } from '../../types';
+import { type TriggerCallback, 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,
+  space: Space,
+  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, space, 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,86 +2,114 @@
 // 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,
-});
+/**
+ * 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.mutable(
+  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)),
+      }),
+    ),
+    options: S.optional(
+      S.struct({
+        // Watch changes to object (not just creation).
+        deep: S.optional(S.boolean),
+        // Debounce changes (delay in ms).
+        delay: S.optional(S.number),
+      }),
+    ),
+  }),
+);
+
+export type SubscriptionTrigger = S.Schema.Type<typeof SubscriptionTriggerSchema>;
+
+const TimerTriggerSchema = S.mutable(
+  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),
   }),
 );
 
-const WebsocketTriggerSchema = S.struct({
-  url: S.string,
-  init: S.optional(S.record(S.string, S.any)),
-});
-
-const SubscriptionTriggerSchema = S.struct({
-  spaceKey: S.optional(S.string),
-  // TODO(burdon): Define query DSL.
-  filter: S.array(
-    S.struct({
-      type: S.string,
-      props: S.optional(S.record(S.string, S.any)),
-    }),
-  ),
-  options: S.optional(
-    S.struct({
-      // Watch changes to object (not just creation).
-      deep: S.optional(S.boolean),
-      // Debounce changes (delay in ms).
-      delay: S.optional(S.number),
-    }),
-  ),
-});
+export type WebhookTrigger = S.Schema.Type<typeof WebhookTriggerSchema>;
 
-const FunctionTriggerSchema = S.struct({
-  function: S.string.pipe(S.description('Function ID/URI.')),
+const WebsocketTriggerSchema = S.mutable(
+  S.struct({
+    type: S.literal('websocket'),
+    url: S.string,
+    init: S.optional(S.record(S.string, S.any)),
+  }),
+);
 
-  // Context passed to function.
-  meta: S.optional(S.record(S.string, S.any)),
+export type WebsocketTrigger = S.Schema.Type<typeof WebsocketTriggerSchema>;
 
-  // Triggers.
-  timer: S.optional(TimerTriggerSchema),
-  webhook: S.optional(WebhookTriggerSchema),
-  websocket: S.optional(WebsocketTriggerSchema),
-  subscription: S.optional(SubscriptionTriggerSchema),
-});
+const TriggerSpecSchema = S.union(
+  TimerTriggerSchema,
+  WebhookTriggerSchema,
+  WebsocketTriggerSchema,
+  SubscriptionTriggerSchema,
+);
 
-export type FunctionTrigger = S.Schema.Type<typeof FunctionTriggerSchema>;
-
-export type TimerTrigger = S.Schema.Type<typeof TimerTriggerSchema>;
-export type WebhookTrigger = S.Schema.Type<typeof WebhookTriggerSchema>;
-export type WebsocketTrigger = S.Schema.Type<typeof WebsocketTriggerSchema>;
-export type SubscriptionTrigger = S.Schema.Type<typeof 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),
-  // TODO(burdon): Rename route?
-  path: S.string,
-  // TODO(burdon): NPM/GitHub/Docker/CF URL?
+  route: S.string,
   handler: S.string,
-});
+}) {}
 
-export type FunctionDef = S.Schema.Type<typeof FunctionDefSchema>;
+/**
+ * Function trigger.
+ */
+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.')),
+  // The `meta` property is merged into the event data passed to the function.
+  meta: S.optional(S.mutable(S.any)),
+  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>;
+
+// TODO(burdon): Standards?
+export const FUNCTION_SCHEMA = [FunctionDef, FunctionTrigger];