@dxos/functions 0.8.1 → 0.8.2-main.10c050d

package/src/trigger/trigger-registry.test.ts

@@ -1,278 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import { afterEach, beforeEach, describe, expect, test } from 'vitest';
-
-import { sleep, Trigger, waitForCondition } from '@dxos/async';
-import { type Client } from '@dxos/client';
-import { type Space } from '@dxos/client/echo';
-import { TestBuilder } from '@dxos/client/testing';
-import { Context } from '@dxos/context';
-import { Filter } from '@dxos/echo-db';
-import { splitMeta } from '@dxos/echo-schema';
-import { create } from '@dxos/live-object';
-import { range } from '@dxos/util';
-
-import { TriggerRegistry } from './trigger-registry';
-import { createInitializedClients, TestType, triggerWebhook } from '../testing';
-import { type FunctionManifest, FunctionTrigger, TriggerKind } from '../types';
-
-const manifest: FunctionManifest = {
-  triggers: [
-    {
-      '@meta': {
-        keys: [
-          {
-            source: 'example.com',
-            id: 'trigger-1',
-          },
-        ],
-      },
-      function: 'example.com/function/webhook-test',
-      enabled: true,
-      spec: {
-        type: TriggerKind.Webhook,
-        method: 'GET',
-      },
-    },
-    {
-      '@meta': {
-        keys: [
-          {
-            source: 'example.com',
-            id: 'trigger-2',
-          },
-        ],
-      },
-      function: 'example.com/function/subscription-test',
-      enabled: true,
-      spec: {
-        type: TriggerKind.Subscription,
-        filter: {
-          type: TestType.typename,
-        },
-      },
-    },
-  ],
-};
-
-describe('trigger registry', () => {
-  let ctx: Context;
-  let testBuilder: TestBuilder;
-
-  beforeEach(async () => {
-    ctx = new Context();
-    testBuilder = new TestBuilder();
-  });
-
-  afterEach(async () => {
-    await ctx.dispose();
-    await testBuilder.destroy();
-  });
-
-  describe('register', () => {
-    test('creates new triggers', async () => {
-      const [client] = await createInitializedClients(testBuilder);
-      const registry = createRegistry(client);
-      const space = await client.spaces.create();
-      await registry.register(space, manifest);
-      const { objects } = await space.db.query(Filter.schema(FunctionTrigger)).run();
-      expect(objects.length).to.eq(manifest.triggers?.length);
-
-      const expected = manifest.triggers?.map((trigger) => trigger.function).sort();
-      expect(objects.map((object: FunctionTrigger) => object.function).sort()).to.deep.eq(expected);
-    });
-
-    test('set meta', () => {
-      const trigger = create(FunctionTrigger, {
-        function: 'example.com/function/webhook-test',
-        spec: {
-          type: TriggerKind.Webhook,
-          method: 'GET',
-        },
-      });
-
-      (trigger.meta ??= {}).test = 100;
-      expect(trigger.meta.test).to.eq(100);
-    });
-  });
-
-  // TODO(burdon): Server-only.
-  describe.skip('activate', () => {
-    test('invokes the provided callback', async () => {
-      const [client] = await createInitializedClients(testBuilder);
-      const space = await client.spaces.create();
-      const registry = createRegistry(client);
-      await registry.register(space, manifest);
-      await registry.open(ctx);
-      await waitForInactiveTriggers(registry, space);
-
-      const callbackInvoked = new Trigger();
-      const { objects: allTriggers } = await space.db.query(Filter.schema(FunctionTrigger)).run();
-      const webhookTrigger = allTriggers.find((trigger: FunctionTrigger) => trigger.spec?.type === 'webhook')!;
-      await registry.activate(space, webhookTrigger, async () => {
-        callbackInvoked.wake();
-        return 200;
-      });
-
-      setTimeout(() => triggerWebhook(space, webhookTrigger.function!));
-      await callbackInvoked.wait();
-    });
-
-    test('removes from inactive list', async () => {
-      const [client] = await createInitializedClients(testBuilder);
-      const space = await client.spaces.create();
-      const registry = createRegistry(client);
-      await registry.register(space, manifest);
-      await registry.open(ctx);
-      await waitForInactiveTriggers(registry, space);
-
-      const inactiveTrigger = registry.getInactiveTriggers(space)[0];
-      await registry.activate(space, inactiveTrigger, async () => 200);
-
-      const updatedInactiveList = registry.getInactiveTriggers(space);
-      expect(updatedInactiveList.find((trigger: FunctionTrigger) => trigger.function === inactiveTrigger.function)).to
-        .be.undefined;
-    });
-
-    // TODO(burdon): Test enable/disable trigger.
-  });
-
-  describe('deactivate', () => {
-    test('trigger object deletion deactivates a trigger', async () => {
-      const [client] = await createInitializedClients(testBuilder);
-      const space = await client.spaces.create();
-      const registry = createRegistry(client);
-      await registry.register(space, manifest);
-      await registry.open(ctx);
-      await waitForInactiveTriggers(registry, space);
-
-      const { objects: allTriggers } = await space.db.query(Filter.schema(FunctionTrigger)).run();
-      const echoTrigger = allTriggers.find((trigger: FunctionTrigger) => trigger.spec?.type === 'subscription')!;
-      let count = 0;
-      await registry.activate(space, echoTrigger, async () => {
-        count++;
-        return 200;
-      });
-
-      space.db.add(create(TestType, { title: '1' }));
-      await sleep(110);
-      expect(count).to.eq(1);
-
-      space.db.remove(echoTrigger);
-      await sleep(110);
-      space.db.add(create(TestType, { title: '2' }));
-      await sleep(20);
-      expect(count).to.eq(1);
-    });
-
-    test('registry closing deactivates a trigger', async () => {
-      const [client] = await createInitializedClients(testBuilder);
-      const space = await client.spaces.create();
-      const registry = createRegistry(client);
-      await registry.register(space, manifest);
-      await registry.open(ctx);
-      await waitForInactiveTriggers(registry, space);
-
-      const { objects: allTriggers } = await space.db.query(Filter.schema(FunctionTrigger)).run();
-      const echoTrigger = allTriggers.find((trigger: FunctionTrigger) => trigger.spec?.type === 'subscription')!;
-      let count = 0;
-      await registry.activate(space, echoTrigger, async () => {
-        count++;
-        return 200;
-      });
-
-      await registry.close();
-
-      space.db.add(create(TestType, { title: '1' }));
-      await sleep(20);
-      expect(count).to.eq(0);
-    });
-  });
-
-  describe('trigger events', () => {
-    test('event fired when all registered are opened', async () => {
-      const [client] = await createInitializedClients(testBuilder);
-      const registry = createRegistry(client);
-      await client.spaces.default.waitUntilReady();
-      const triggers = createTriggers(client.spaces.default, 3);
-
-      const triggersRegistered = new Trigger<FunctionTrigger[]>();
-      registry.registered.on((fn) => {
-        expect(fn.space.key.toHex()).to.eq(client.spaces.default.key.toHex());
-        triggersRegistered.wake(fn.triggers);
-      });
-
-      void registry.open(ctx);
-      const functions = await triggersRegistered.wait();
-      const expected = triggers.map((object) => object.id).sort();
-      expect(functions.map((fn) => fn.id).sort()).to.deep.eq(expected);
-    });
-
-    test('event fired when a new trigger is added', async () => {
-      const [client] = await createInitializedClients(testBuilder);
-      const registry = createRegistry(client);
-      const space = await client.spaces.create();
-      await space.waitUntilReady();
-
-      const triggerRegistered = new Trigger<FunctionTrigger>();
-      registry.registered.on((fn) => {
-        expect(fn.triggers.length).to.eq(1);
-        triggerRegistered.wake(fn.triggers[0]);
-      });
-
-      await registry.open(ctx);
-      await registry.register(space, { triggers: manifest?.triggers?.slice(0, 1) });
-      const registered = await triggerRegistered.wait();
-      expect(registered.function).to.eq(manifest.triggers![0].function);
-    });
-
-    test('event fired when a new trigger is removed', async () => {
-      const [client] = await createInitializedClients(testBuilder);
-      const registry = createRegistry(client);
-      const space = await client.spaces.create();
-      await space.waitUntilReady();
-      const triggers = createTriggers(space, 3);
-
-      const triggerLoaded = new Trigger();
-      registry.registered.on(() => {
-        triggerLoaded.wake();
-      });
-
-      const triggerRemoved = new Trigger<FunctionTrigger>();
-      registry.removed.on((fn) => {
-        expect(fn.triggers.length).to.eq(1);
-        triggerRemoved.wake(fn.triggers[0]);
-      });
-
-      await registry.register(space, manifest);
-      await registry.open(ctx);
-      await triggerLoaded.wait();
-
-      space.db.remove(triggers[0]);
-      const removedTrigger = await triggerRemoved.wait();
-      expect(removedTrigger.id).to.eq(triggers[0].id);
-    });
-  });
-
-  const createRegistry = (client: Client) => {
-    const registry = new TriggerRegistry(client);
-    ctx.onDispose(() => registry.close());
-    return registry;
-  };
-
-  const createTriggers = (space: Space, count: number) => {
-    const triggers = range(count, () => {
-      const { meta, object } = splitMeta(manifest.triggers![0]);
-      return create(FunctionTrigger, object, meta);
-    });
-
-    triggers.forEach((trigger) => space.db.add(trigger));
-    return triggers;
-  };
-
-  const waitForInactiveTriggers = async (registry: TriggerRegistry, space: Space) => {
-    await waitForCondition({ condition: () => registry.getInactiveTriggers(space).length > 0 });
-  };
-});

package/src/trigger/trigger-registry.ts

@@ -1,218 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { Event } from '@dxos/async';
-import { type Client } from '@dxos/client';
-import { create, Filter, getMeta, type Space, compareForeignKeys } from '@dxos/client/echo';
-import { Context, Resource } from '@dxos/context';
-import { ECHO_ATTR_META, foreignKey } from '@dxos/echo-schema';
-import { invariant } from '@dxos/invariant';
-import { PublicKey } from '@dxos/keys';
-import { log } from '@dxos/log';
-import { ComplexMap, diff } from '@dxos/util';
-
-import { createSubscriptionTrigger, createTimerTrigger } from './type';
-import { type FunctionManifest, FunctionTrigger, type TriggerKind, type TriggerType } from '../types';
-
-type ResponseCode = number;
-
-export type TriggerCallback = (args: object) => Promise<ResponseCode>;
-
-// TODO(burdon): Make object?
-export type TriggerFactory<Spec extends TriggerType, Options = any> = (
-  ctx: Context,
-  space: Space,
-  spec: Spec,
-  callback: TriggerCallback,
-  options?: Options,
-) => Promise<void>;
-
-export type TriggerFactoryMap = Partial<Record<TriggerKind, TriggerFactory<any>>>;
-
-const triggerFactory: TriggerFactoryMap = {
-  timer: createTimerTrigger,
-  // TODO(burdon): Cannot use in browser.
-  // webhook: createWebhookTrigger,
-  subscription: createSubscriptionTrigger,
-};
-
-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?: TriggerFactoryMap,
-  ) {
-    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);
-  }
-
-  /**
-   * Set callback for trigger.
-   */
-  public async activate(space: Space, trigger: FunctionTrigger, callback: TriggerCallback): Promise<void> {
-    log('activate', { space: space.key, trigger });
-
-    const activationCtx = new Context({ name: `FunctionTrigger-${trigger.function}` });
-    this._ctx.onDispose(() => activationCtx.dispose());
-    const registeredTrigger = this._triggersBySpaceKey.get(space.key)?.find((reg) => reg.trigger.id === trigger.id);
-    invariant(registeredTrigger, `Trigger is not registered: ${trigger.function}`);
-    registeredTrigger.activationCtx = activationCtx;
-
-    try {
-      // Create trigger.
-      invariant(trigger.spec);
-      const options = this._options?.[trigger.spec.type];
-      const createTrigger = triggerFactory[trigger.spec.type];
-      invariant(createTrigger, `Trigger factory not found: ${trigger.spec.type}`);
-      await createTrigger(activationCtx, space, 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.schemaRegistry.hasSchema(FunctionTrigger)) {
-      space.db.graph.schemaRegistry.addSchema([FunctionTrigger]);
-    }
-
-    // Create FK to enable syncing if none are set (NOTE: Possible collision).
-    const manifestTriggers = manifest.triggers.map((trigger) => {
-      let keys = trigger[ECHO_ATTR_META]?.keys;
-      delete trigger[ECHO_ATTR_META];
-      if (!keys?.length) {
-        keys = [foreignKey('manifest', [trigger.function, trigger.spec?.type].join(':'))];
-      }
-
-      return create(FunctionTrigger, trigger, { keys });
-    });
-
-    // Sync triggers.
-    const { objects: existing } = await space.db.query(Filter.schema(FunctionTrigger)).run();
-    const { added } = diff(existing, manifestTriggers, compareForeignKeys);
-
-    // TODO(burdon): Update existing.
-    added.forEach((trigger) => {
-      space.db.add(trigger);
-      log.info('added', { meta: getMeta(trigger) });
-    });
-
-    if (added.length > 0) {
-      await space.db.flush();
-    }
-  }
-
-  protected override async _open(): Promise<void> {
-    log.info('open...');
-    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;
-        }
-
-        // Subscribe to updates.
-        this._ctx.onDispose(
-          space.db.query(Filter.schema(FunctionTrigger)).subscribe(async ({ objects: current }) => {
-            log.info('update', { space: space.key, registered: registered.length, current: current.length });
-            await this._handleRemovedTriggers(space, current, registered);
-            this._handleNewTriggers(space, current, registered);
-          }),
-        );
-      }
-    });
-
-    this._ctx.onDispose(() => spaceListSubscription.unsubscribe());
-    log.info('opened');
-  }
-
-  protected override async _close(_: Context): Promise<void> {
-    log.info('close...');
-    this._triggersBySpaceKey.clear();
-    log.info('closed');
-  }
-
-  private _handleNewTriggers(space: Space, current: FunctionTrigger[], registered: RegisteredTrigger[]) {
-    const added = current.filter((candidate) => {
-      return candidate.enabled && registered.find((reg) => reg.trigger.id === candidate.id) == null;
-    });
-
-    if (added.length > 0) {
-      const newRegisteredTriggers: RegisteredTrigger[] = added.map((trigger) => ({ trigger }));
-      registered.push(...newRegisteredTriggers);
-      log.info('added', () => ({
-        spaceKey: space.key,
-        triggers: added.map((trigger) => trigger.function),
-      }));
-
-      this.registered.emit({ space, triggers: added });
-    }
-  }
-
-  private async _handleRemovedTriggers(
-    space: Space,
-    current: FunctionTrigger[],
-    registered: RegisteredTrigger[],
-  ): Promise<void> {
-    const removed: FunctionTrigger[] = [];
-    for (let i = registered.length - 1; i >= 0; i--) {
-      const wasRemoved =
-        current.filter((trigger) => trigger.enabled).find((trigger) => 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) {
-      log.info('removed', () => ({
-        spaceKey: space.key,
-        triggers: removed.map((trigger) => trigger.function),
-      }));
-
-      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,7 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-export * from './subscription-trigger';
-export * from './timer-trigger';
-// export * from './webhook-trigger';

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

@@ -1,84 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { debounce, UpdateScheduler } from '@dxos/async';
-import { Filter, type Space } from '@dxos/client/echo';
-import { type Context } from '@dxos/context';
-import { createSubscription, type Query } from '@dxos/echo-db';
-import { log } from '@dxos/log';
-
-import type { SubscriptionTrigger } from '../../types';
-import { type TriggerCallback, type TriggerFactory } from '../trigger-registry';
-
-export const createSubscriptionTrigger: TriggerFactory<SubscriptionTrigger> = async (
-  ctx: Context,
-  space: Space,
-  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): Factor out diff.
-  // 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) => {
-    log.info('update', { objects: objects.length });
-    subscription.update(objects);
-
-    // TODO(burdon): Hack to monitor changes to Document's text object.
-    if (deep) {
-      // TODO(dmaretskyi): Removed to not have dependency on markdown-plugin.
-      // for (const object of objects) {
-      //   const content = object.content;
-      //   if (content instanceof TextType) {
-      //     subscriptions.push(getObjectCore(content).updates.on(debounce(() => subscription.update([object]), 1_000)));
-      //   }
-      // }
-    }
-  };
-
-  // TODO(burdon): OR not working.
-  // TODO(burdon): [Bug]: all callbacks are fired on the first mutation.
-  // TODO(burdon): [Bug]: not updated when document is deleted (either top or hierarchically).
-  log.info('subscription', { filter });
-  // const query = triggerCtx.space.db.query(Filter.or(filter.map(({ type, props }) => Filter.typename(type, props))));
-  if (filter.type) {
-    const query = space.db.query(Filter.typename(filter.type, filter.props));
-    subscriptions.push(query.subscribe(delay ? debounce(update, delay) : update));
-  }
-
-  ctx.onDispose(() => {
-    subscriptions.forEach((unsubscribe) => unsubscribe());
-  });
-};

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

@@ -1,48 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { parseCronExpression } from 'cron-schedule';
-
-import { DeferredTask } from '@dxos/async';
-import { type Space } from '@dxos/client/echo';
-import { type Context } from '@dxos/context';
-import { log } from '@dxos/log';
-
-import type { TimerTrigger } from '../../types';
-import { type TriggerCallback, type TriggerFactory } from '../trigger-registry';
-
-export const createTimerTrigger: TriggerFactory<TimerTrigger> = async (
-  ctx: Context,
-  space: Space,
-  spec: TimerTrigger,
-  callback: TriggerCallback,
-) => {
-  const task = new DeferredTask(ctx, async () => {
-    await callback({});
-  });
-
-  let last = 0;
-  let run = 0;
-  const schedule = parseCronExpression(spec.cron);
-  const getRunTimeout = () => Date.now() - schedule.getNextDate().getTime();
-  const runCron = () => {
-    if (ctx.disposed) {
-      return;
-    }
-    // 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: space.key.truncate(), count: run, delta });
-    task.schedule();
-
-    timeout = setTimeout(runCron, getRunTimeout());
-  };
-
-  let timeout = setTimeout(runCron, getRunTimeout());
-
-  ctx.onDispose(() => clearTimeout(timeout));
-};

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

@@ -1,48 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { getPort } from 'get-port-please';
-import http from 'node:http';
-
-import { type Space } from '@dxos/client/echo';
-import { type Context } from '@dxos/context';
-import { log } from '@dxos/log';
-
-import type { WebhookTrigger } from '../../types';
-import { type TriggerCallback, type TriggerFactory } from '../trigger-registry';
-
-export const createWebhookTrigger: TriggerFactory<WebhookTrigger> = async (
-  ctx: Context,
-  space: Space,
-  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/types/index.ts

@@ -1,8 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-export * from './schema';
-export * from './types';
-export * from './trace';
-export * from './url';