@dxos/functions 0.5.3-main.8b66fe2 → 0.5.3-main.8ffbbae

package/src/trigger/trigger-registry.ts

@@ -1,189 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { Event } from '@dxos/async';
-import { type Client } from '@dxos/client';
-import { create, Filter, getMeta, type Space } from '@dxos/client/echo';
-import { Context, Resource } from '@dxos/context';
-import { ECHO_ATTR_META, foreignKey, foreignKeyEquals, splitMeta } from '@dxos/echo-schema';
-import { invariant } from '@dxos/invariant';
-import { PublicKey } from '@dxos/keys';
-import { log } from '@dxos/log';
-import { ComplexMap } from '@dxos/util';
-
-import { createSubscriptionTrigger, createTimerTrigger, createWebhookTrigger, createWebsocketTrigger } from './type';
-import { type FunctionManifest, FunctionTrigger, type FunctionTriggerType, type TriggerSpec } from '../types';
-import { diff, intersection } from '../util';
-
-type ResponseCode = number;
-
-export type TriggerCallback = (args: object) => Promise<ResponseCode>;
-
-export type TriggerContext = { space: Space };
-
-// TODO(burdon): Make object?
-export type TriggerFactory<Spec extends TriggerSpec, Options = any> = (
-  ctx: Context,
-  context: TriggerContext,
-  spec: Spec,
-  callback: TriggerCallback,
-  options?: Options,
-) => Promise<void>;
-
-export type TriggerHandlerMap = { [type in FunctionTriggerType]: TriggerFactory<any> };
-
-const triggerHandlers: TriggerHandlerMap = {
-  subscription: createSubscriptionTrigger,
-  timer: createTimerTrigger,
-  webhook: createWebhookTrigger,
-  websocket: createWebsocketTrigger,
-};
-
-export type TriggerEvent = {
-  space: Space;
-  triggers: FunctionTrigger[];
-};
-
-type RegisteredTrigger = {
-  activationCtx?: Context;
-  trigger: FunctionTrigger;
-};
-
-export class TriggerRegistry extends Resource {
-  private readonly _triggersBySpaceKey = new ComplexMap<PublicKey, RegisteredTrigger[]>(PublicKey.hash);
-
-  public readonly registered = new Event<TriggerEvent>();
-  public readonly removed = new Event<TriggerEvent>();
-
-  constructor(
-    private readonly _client: Client,
-    private readonly _options?: TriggerHandlerMap,
-  ) {
-    super();
-  }
-
-  public getActiveTriggers(space: Space): FunctionTrigger[] {
-    return this._getTriggers(space, (t) => t.activationCtx != null);
-  }
-
-  public getInactiveTriggers(space: Space): FunctionTrigger[] {
-    return this._getTriggers(space, (t) => t.activationCtx == null);
-  }
-
-  async activate(triggerCtx: TriggerContext, trigger: FunctionTrigger, callback: TriggerCallback): Promise<void> {
-    log('activate', { space: triggerCtx.space.key, trigger });
-    const activationCtx = new Context({ name: `trigger_${trigger.function}` });
-    this._ctx.onDispose(() => activationCtx.dispose());
-    const registeredTrigger = this._triggersBySpaceKey
-      .get(triggerCtx.space.key)
-      ?.find((reg) => reg.trigger.id === trigger.id);
-    invariant(registeredTrigger, `Trigger is not registered: ${trigger.function}`);
-    registeredTrigger.activationCtx = activationCtx;
-
-    try {
-      const options = this._options?.[trigger.spec.type];
-      await triggerHandlers[trigger.spec.type](activationCtx, triggerCtx, trigger.spec, callback, options);
-    } catch (err) {
-      delete registeredTrigger.activationCtx;
-      throw err;
-    }
-  }
-
-  /**
-   * Loads triggers from the manifest into the space.
-   */
-  public async register(space: Space, manifest: FunctionManifest): Promise<void> {
-    log('register', { space: space.key });
-    if (!manifest.triggers?.length) {
-      return;
-    }
-    if (!space.db.graph.runtimeSchemaRegistry.hasSchema(FunctionTrigger)) {
-      space.db.graph.runtimeSchemaRegistry.registerSchema(FunctionTrigger);
-    }
-
-    // Sync triggers.
-    const { objects: existing } = await space.db.query(Filter.schema(FunctionTrigger)).run();
-    const { added, removed } = diff(existing, manifest.triggers, (a, b) => {
-      // Create FK to enable syncing if none are set.
-      // TODO(burdon): Warn if not unique.
-      const keys = b[ECHO_ATTR_META]?.keys ?? [foreignKey('manifest', [b.function, b.spec.type].join('-'))];
-      return intersection(getMeta(a)?.keys ?? [], keys, foreignKeyEquals).length > 0;
-    });
-
-    added.forEach((trigger) => {
-      const { meta, object } = splitMeta(trigger);
-      space.db.add(create(FunctionTrigger, object, meta));
-    });
-    // TODO(burdon): Update existing triggers.
-    removed.forEach((trigger) => space.db.remove(trigger));
-  }
-
-  protected override async _open(): Promise<void> {
-    const spaceListSubscription = this._client.spaces.subscribe(async (spaces) => {
-      for (const space of spaces) {
-        if (this._triggersBySpaceKey.has(space.key)) {
-          continue;
-        }
-
-        const registered: RegisteredTrigger[] = [];
-        this._triggersBySpaceKey.set(space.key, registered);
-        await space.waitUntilReady();
-        if (this._ctx.disposed) {
-          break;
-        }
-        const functionsSubscription = space.db.query(Filter.schema(FunctionTrigger)).subscribe(async (triggers) => {
-          await this._handleRemovedTriggers(space, triggers.objects, registered);
-          this._handleNewTriggers(space, triggers.objects, registered);
-        });
-
-        this._ctx.onDispose(functionsSubscription);
-      }
-    });
-
-    this._ctx.onDispose(() => spaceListSubscription.unsubscribe());
-  }
-
-  protected override async _close(_: Context): Promise<void> {
-    this._triggersBySpaceKey.clear();
-  }
-
-  private _handleNewTriggers(space: Space, allTriggers: FunctionTrigger[], registered: RegisteredTrigger[]) {
-    const newTriggers = allTriggers.filter((candidate) => {
-      return registered.find((reg) => reg.trigger.id === candidate.id) == null;
-    });
-
-    if (newTriggers.length > 0) {
-      const newRegisteredTriggers: RegisteredTrigger[] = newTriggers.map((trigger) => ({ trigger }));
-      registered.push(...newRegisteredTriggers);
-      log('registered new triggers', () => ({ spaceKey: space.key, functions: newTriggers.map((t) => t.function) }));
-      this.registered.emit({ space, triggers: newTriggers });
-    }
-  }
-
-  private async _handleRemovedTriggers(
-    space: Space,
-    allTriggers: FunctionTrigger[],
-    registered: RegisteredTrigger[],
-  ): Promise<void> {
-    const removed: FunctionTrigger[] = [];
-    for (let i = registered.length - 1; i >= 0; i--) {
-      const wasRemoved =
-        allTriggers.find((trigger: FunctionTrigger) => trigger.id === registered[i].trigger.id) == null;
-      if (wasRemoved) {
-        const unregistered = registered.splice(i, 1)[0];
-        await unregistered.activationCtx?.dispose();
-        removed.push(unregistered.trigger);
-      }
-    }
-
-    if (removed.length > 0) {
-      this.removed.emit({ space, triggers: removed });
-    }
-  }
-
-  private _getTriggers(space: Space, predicate: (trigger: RegisteredTrigger) => boolean): FunctionTrigger[] {
-    const allSpaceTriggers = this._triggersBySpaceKey.get(space.key) ?? [];
-    return allSpaceTriggers.filter(predicate).map((trigger) => trigger.trigger);
-  }
-}

package/src/trigger/type/index.ts

@@ -1,8 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-export * from './subscription-trigger';
-export * from './timer-trigger';
-export * from './webhook-trigger';
-export * from './websocket-trigger';

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

@@ -1,80 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { TextV0Type } from '@braneframe/types';
-import { debounce, UpdateScheduler } from '@dxos/async';
-import { type Context } from '@dxos/context';
-import { createSubscription, Filter, getAutomergeObjectCore, type Query } from '@dxos/echo-db';
-import { log } from '@dxos/log';
-
-import type { SubscriptionTrigger } from '../../types';
-import { type TriggerCallback, type TriggerContext, type TriggerFactory } from '../trigger-registry';
-
-export const createSubscriptionTrigger: TriggerFactory<SubscriptionTrigger> = async (
-  ctx: Context,
-  triggerCtx: TriggerContext,
-  spec: SubscriptionTrigger,
-  callback: TriggerCallback,
-) => {
-  const objectIds = new Set<string>();
-  const task = new UpdateScheduler(
-    ctx,
-    async () => {
-      if (objectIds.size > 0) {
-        const objects = Array.from(objectIds);
-        objectIds.clear();
-        await callback({ objects });
-      }
-    },
-    { maxFrequency: 4 },
-  );
-
-  // TODO(burdon): Don't fire initially?
-  // TODO(burdon): Create queue. Only allow one invocation per trigger at a time?
-  const subscriptions: (() => void)[] = [];
-  const subscription = createSubscription(({ added, updated }) => {
-    const sizeBefore = objectIds.size;
-    for (const object of added) {
-      objectIds.add(object.id);
-    }
-    for (const object of updated) {
-      objectIds.add(object.id);
-    }
-    if (objectIds.size > sizeBefore) {
-      log.info('updated', { added: added.length, updated: updated.length });
-      task.trigger();
-    }
-  });
-
-  subscriptions.push(() => subscription.unsubscribe());
-
-  // TODO(burdon): Disable trigger if keeps failing.
-  const { filter, options: { deep, delay } = {} } = spec;
-  const update = ({ objects }: Query) => {
-    subscription.update(objects);
-
-    // TODO(burdon): Hack to monitor changes to Document's text object.
-    if (deep) {
-      log.info('update', { objects: objects.length });
-      for (const object of objects) {
-        const content = object.content;
-        if (content instanceof TextV0Type) {
-          subscriptions.push(
-            getAutomergeObjectCore(content).updates.on(debounce(() => subscription.update([object]), 1_000)),
-          );
-        }
-      }
-    }
-  };
-
-  // TODO(burdon): Is Filter.or implemented?
-  // TODO(burdon): [Bug]: all callbacks are fired on the first mutation.
-  // TODO(burdon): [Bug]: not updated when document is deleted (either top or hierarchically).
-  const query = triggerCtx.space.db.query(Filter.or(filter.map(({ type, props }) => Filter.typename(type, props))));
-  subscriptions.push(query.subscribe(delay ? debounce(update, delay) : update));
-
-  ctx.onDispose(() => {
-    subscriptions.forEach((unsubscribe) => unsubscribe());
-  });
-};

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

@@ -1,44 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { CronJob } from 'cron';
-
-import { DeferredTask } from '@dxos/async';
-import { type Context } from '@dxos/context';
-import { log } from '@dxos/log';
-
-import type { TimerTrigger } from '../../types';
-import { type TriggerCallback, type TriggerContext, type TriggerFactory } from '../trigger-registry';
-
-export const createTimerTrigger: TriggerFactory<TimerTrigger> = async (
-  ctx: Context,
-  triggerContext: TriggerContext,
-  spec: TimerTrigger,
-  callback: TriggerCallback,
-) => {
-  const task = new DeferredTask(ctx, async () => {
-    await callback({});
-  });
-
-  let last = 0;
-  let run = 0;
-  // https://www.npmjs.com/package/cron#constructor
-  const job = CronJob.from({
-    cronTime: spec.cron,
-    runOnInit: false,
-    onTick: () => {
-      // TODO(burdon): Check greater than 30s (use cron-parser).
-      const now = Date.now();
-      const delta = last ? now - last : 0;
-      last = now;
-
-      run++;
-      log.info('tick', { space: triggerContext.space.key.truncate(), count: run, delta });
-      task.schedule();
-    },
-  });
-
-  job.start();
-  ctx.onDispose(() => job.stop());
-};

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

@@ -1,47 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { getPort } from 'get-port-please';
-import http from 'node:http';
-
-import { type Context } from '@dxos/context';
-import { log } from '@dxos/log';
-
-import type { WebhookTrigger } from '../../types';
-import { type TriggerCallback, type TriggerContext, type TriggerFactory } from '../trigger-registry';
-
-export const createWebhookTrigger: TriggerFactory<WebhookTrigger> = async (
-  ctx: Context,
-  _: TriggerContext,
-  spec: WebhookTrigger,
-  callback: TriggerCallback,
-) => {
-  // TODO(burdon): Enable POST hook with payload.
-  const server = http.createServer(async (req, res) => {
-    if (req.method !== spec.method) {
-      res.statusCode = 405;
-      return res.end();
-    }
-    res.statusCode = await callback({});
-    res.end();
-  });
-
-  // TODO(burdon): Not used.
-  // const DEF_PORT_RANGE = { min: 7500, max: 7599 };
-  // const portRange = Object.assign({}, trigger.port, DEF_PORT_RANGE) as WebhookTrigger['port'];
-  const port = await getPort({
-    random: true,
-    // portRange: [portRange!.min, portRange!.max],
-  });
-
-  // TODO(burdon): Update trigger object with actual port.
-  server.listen(port, () => {
-    log.info('started webhook', { port });
-    spec.port = port;
-  });
-
-  ctx.onDispose(() => {
-    server.close();
-  });
-};

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

@@ -1,91 +0,0 @@
-//
-// 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/util.test.ts

@@ -1,43 +0,0 @@
-//
-// 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

@@ -1,48 +0,0 @@
-//
-// 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);