@dxos/functions 0.5.3-next.57eca40 → 0.5.3-next.63cdcad

package/src/trigger/trigger-registry.ts

@@ -6,26 +6,23 @@ 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 { compareForeignKeys, 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 } from '@dxos/util';
+import { ComplexMap, diff } 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,
+  space: Space,
   spec: Spec,
   callback: TriggerCallback,
   options?: Options,
@@ -71,19 +68,18 @@ export class TriggerRegistry extends Resource {
     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}` });
+  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(triggerCtx.space.key)
-      ?.find((reg) => reg.trigger.id === trigger.id);
+    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 {
       const options = this._options?.[trigger.spec.type];
-      await triggerHandlers[trigger.spec.type](activationCtx, triggerCtx, trigger.spec, callback, options);
+      await triggerHandlers[trigger.spec.type](activationCtx, space, trigger.spec, callback, options);
     } catch (err) {
       delete registeredTrigger.activationCtx;
       throw err;
@@ -98,28 +94,39 @@ export class TriggerRegistry extends Resource {
     if (!manifest.triggers?.length) {
       return;
     }
+
     if (!space.db.graph.runtimeSchemaRegistry.hasSchema(FunctionTrigger)) {
       space.db.graph.runtimeSchemaRegistry.registerSchema(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, 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;
-    });
+    const { added } = diff(existing, manifestTriggers, compareForeignKeys);
 
+    // TODO(burdon): Update existing.
     added.forEach((trigger) => {
-      const { meta, object } = splitMeta(trigger);
-      space.db.add(create(FunctionTrigger, object, meta));
+      space.db.add(trigger);
+      log.info('added', { meta: getMeta(trigger) });
     });
-    // TODO(burdon): Update existing triggers.
-    removed.forEach((trigger) => space.db.remove(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)) {
@@ -132,44 +139,54 @@ export class TriggerRegistry extends Resource {
         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);
+        // 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, allTriggers: FunctionTrigger[], registered: RegisteredTrigger[]) {
-    const newTriggers = allTriggers.filter((candidate) => {
-      return registered.find((reg) => reg.trigger.id === candidate.id) == null;
+  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 (newTriggers.length > 0) {
-      const newRegisteredTriggers: RegisteredTrigger[] = newTriggers.map((trigger) => ({ trigger }));
+    if (added.length > 0) {
+      const newRegisteredTriggers: RegisteredTrigger[] = added.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 });
+      log.info('added', () => ({
+        spaceKey: space.key,
+        triggers: added.map((trigger) => trigger.function),
+      }));
+
+      this.registered.emit({ space, triggers: added });
     }
   }
 
   private async _handleRemovedTriggers(
     space: Space,
-    allTriggers: FunctionTrigger[],
+    current: 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;
+        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();
@@ -178,6 +195,11 @@ export class TriggerRegistry extends Resource {
     }
 
     if (removed.length > 0) {
+      log.info('removed', () => ({
+        spaceKey: space.key,
+        triggers: removed.map((trigger) => trigger.function),
+      }));
+
       this.removed.emit({ space, triggers: removed });
     }
   }

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

@@ -4,16 +4,17 @@
 
 import { TextV0Type } from '@braneframe/types';
 import { debounce, UpdateScheduler } from '@dxos/async';
+import { Filter, type Space } from '@dxos/client/echo';
 import { type Context } from '@dxos/context';
-import { createSubscription, Filter, getAutomergeObjectCore, type Query } from '@dxos/echo-db';
+import { createSubscription, 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';
+import { type TriggerCallback, type TriggerFactory } from '../trigger-registry';
 
 export const createSubscriptionTrigger: TriggerFactory<SubscriptionTrigger> = async (
   ctx: Context,
-  triggerCtx: TriggerContext,
+  space: Space,
   spec: SubscriptionTrigger,
   callback: TriggerCallback,
 ) => {
@@ -30,6 +31,7 @@ export const createSubscriptionTrigger: TriggerFactory<SubscriptionTrigger> = as
     { 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)[] = [];
@@ -52,11 +54,11 @@ export const createSubscriptionTrigger: TriggerFactory<SubscriptionTrigger> = as
   // 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) {
-      log.info('update', { objects: objects.length });
       for (const object of objects) {
         const content = object.content;
         if (content instanceof TextV0Type) {
@@ -68,11 +70,15 @@ export const createSubscriptionTrigger: TriggerFactory<SubscriptionTrigger> = as
     }
   };
 
-  // TODO(burdon): Is Filter.or implemented?
+  // 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).
-  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));
+  log.info('subscription', { filter });
+  // const query = triggerCtx.space.db.query(Filter.or(filter.map(({ type, props }) => Filter.typename(type, props))));
+  if (filter) {
+    const query = space.db.query(Filter.typename(filter[0].type, filter[0].props));
+    subscriptions.push(query.subscribe(delay ? debounce(update, delay) : update));
+  }
 
   ctx.onDispose(() => {
     subscriptions.forEach((unsubscribe) => unsubscribe());

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

@@ -5,15 +5,16 @@
 import { CronJob } from 'cron';
 
 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 TriggerContext, type TriggerFactory } from '../trigger-registry';
+import { type TriggerCallback, type TriggerFactory } from '../trigger-registry';
 
 export const createTimerTrigger: TriggerFactory<TimerTrigger> = async (
   ctx: Context,
-  triggerContext: TriggerContext,
+  space: Space,
   spec: TimerTrigger,
   callback: TriggerCallback,
 ) => {
@@ -34,7 +35,7 @@ export const createTimerTrigger: TriggerFactory<TimerTrigger> = async (
       last = now;
 
       run++;
-      log.info('tick', { space: triggerContext.space.key.truncate(), count: run, delta });
+      log.info('tick', { space: space.key.truncate(), count: run, delta });
       task.schedule();
     },
   });

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

@@ -5,15 +5,16 @@
 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 TriggerContext, type TriggerFactory } from '../trigger-registry';
+import { type TriggerCallback, type TriggerFactory } from '../trigger-registry';
 
 export const createWebhookTrigger: TriggerFactory<WebhookTrigger> = async (
   ctx: Context,
-  _: TriggerContext,
+  space: Space,
   spec: WebhookTrigger,
   callback: TriggerCallback,
 ) => {

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

@@ -5,11 +5,12 @@
 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 TriggerContext, type TriggerFactory } from '../trigger-registry';
+import { type TriggerCallback, type TriggerFactory } from '../trigger-registry';
 
 interface WebsocketTriggerOptions {
   retryDelay: number;
@@ -22,7 +23,7 @@ interface WebsocketTriggerOptions {
  */
 export const createWebsocketTrigger: TriggerFactory<WebsocketTrigger, WebsocketTriggerOptions> = async (
   ctx: Context,
-  triggerCtx: TriggerContext,
+  space: Space,
   spec: WebsocketTrigger,
   callback: TriggerCallback,
   options: WebsocketTriggerOptions = { retryDelay: 2, maxAttempts: 5 },
@@ -51,7 +52,7 @@ export const createWebsocketTrigger: TriggerFactory<WebsocketTrigger, WebsocketT
         if (event.code === 1006) {
           setTimeout(async () => {
             log.info(`reconnecting in ${options.retryDelay}s...`, { url });
-            await createWebsocketTrigger(ctx, triggerCtx, spec, callback, options);
+            await createWebsocketTrigger(ctx, space, spec, callback, options);
           }, options.retryDelay * 1_000);
         }
 

package/src/types.ts

@@ -12,31 +12,35 @@ import { RawObject, S, TypedObject } from '@dxos/echo-schema';
  */
 export type FunctionTriggerType = 'subscription' | 'timer' | 'webhook' | 'websocket';
 
-const SubscriptionTriggerSchema = 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),
-    }),
-  ),
-});
+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.struct({
-  type: S.literal('timer'),
-  cron: S.string,
-});
+const TimerTriggerSchema = S.mutable(
+  S.struct({
+    type: S.literal('timer'),
+    cron: S.string,
+  }),
+);
 
 export type TimerTrigger = S.Schema.Type<typeof TimerTriggerSchema>;
 
@@ -51,11 +55,13 @@ const WebhookTriggerSchema = S.mutable(
 
 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)),
-});
+const WebsocketTriggerSchema = S.mutable(
+  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>;
 
@@ -78,17 +84,20 @@ export class FunctionDef extends TypedObject({
   uri: S.string,
   description: S.optional(S.string),
   route: S.string,
-  // TODO(burdon): NPM/GitHub/Docker/CF URL?
   handler: S.string,
 }) {}
 
+/**
+ * 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.')),
-  // Context is merged into the event data passed to the function.
-  meta: S.optional(S.object),
+  // The `meta` property is merged into the event data passed to the function.
+  meta: S.optional(S.mutable(S.any)),
   spec: TriggerSpecSchema,
 }) {}
 
@@ -101,3 +110,6 @@ export const FunctionManifestSchema = S.struct({
 });
 
 export type FunctionManifest = S.Schema.Type<typeof FunctionManifestSchema>;
+
+// TODO(burdon): Standards?
+export const FUNCTION_SCHEMA = [FunctionDef, FunctionTrigger];

package/dist/lib/browser/chunk-366QG6IX.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/types.ts"],
-  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\nimport { RawObject, S, TypedObject } from '@dxos/echo-schema';\n\n/**\n * Type discriminator for TriggerSpec.\n * Every spec has a type field of type FunctionTriggerType that we can use to understand which\n * type we're working with.\n * https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions\n */\nexport type FunctionTriggerType = 'subscription' | 'timer' | 'webhook' | 'websocket';\n\nconst SubscriptionTriggerSchema = S.struct({\n  type: S.literal('subscription'),\n  // TODO(burdon): Define query DSL (from ECHO).\n  filter: S.array(\n    S.struct({\n      type: S.string,\n      props: S.optional(S.record(S.string, S.any)),\n    }),\n  ),\n  options: S.optional(\n    S.struct({\n      // Watch changes to object (not just creation).\n      deep: S.optional(S.boolean),\n      // Debounce changes (delay in ms).\n      delay: S.optional(S.number),\n    }),\n  ),\n});\n\nexport type SubscriptionTrigger = S.Schema.Type<typeof SubscriptionTriggerSchema>;\n\nconst TimerTriggerSchema = S.struct({\n  type: S.literal('timer'),\n  cron: S.string,\n});\n\nexport type TimerTrigger = S.Schema.Type<typeof TimerTriggerSchema>;\n\nconst WebhookTriggerSchema = S.mutable(\n  S.struct({\n    type: S.literal('webhook'),\n    method: S.string,\n    // Assigned port.\n    port: S.optional(S.number),\n  }),\n);\n\nexport type WebhookTrigger = S.Schema.Type<typeof WebhookTriggerSchema>;\n\nconst WebsocketTriggerSchema = S.struct({\n  type: S.literal('websocket'),\n  url: S.string,\n  init: S.optional(S.record(S.string, S.any)),\n});\n\nexport type WebsocketTrigger = S.Schema.Type<typeof WebsocketTriggerSchema>;\n\nconst TriggerSpecSchema = S.union(\n  TimerTriggerSchema,\n  WebhookTriggerSchema,\n  WebsocketTriggerSchema,\n  SubscriptionTriggerSchema,\n);\n\nexport type TriggerSpec = TimerTrigger | WebhookTrigger | WebsocketTrigger | SubscriptionTrigger;\n\n/**\n * Function definition.\n */\nexport class FunctionDef extends TypedObject({\n  typename: 'dxos.org/type/FunctionDef',\n  version: '0.1.0',\n})({\n  uri: S.string,\n  description: S.optional(S.string),\n  route: S.string,\n  // TODO(burdon): NPM/GitHub/Docker/CF URL?\n  handler: S.string,\n}) {}\n\nexport class FunctionTrigger extends TypedObject({\n  typename: 'dxos.org/type/FunctionTrigger',\n  version: '0.1.0',\n})({\n  function: S.string.pipe(S.description('Function URI.')),\n  // Context is merged into the event data passed to the function.\n  meta: S.optional(S.object),\n  spec: TriggerSpecSchema,\n}) {}\n\n/**\n * Function manifest file.\n */\nexport const FunctionManifestSchema = S.struct({\n  functions: S.optional(S.mutable(S.array(RawObject(FunctionDef)))),\n  triggers: S.optional(S.mutable(S.array(RawObject(FunctionTrigger)))),\n});\n\nexport type FunctionManifest = S.Schema.Type<typeof FunctionManifestSchema>;\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;AAIA,SAASA,WAAWC,GAAGC,mBAAmB;AAU1C,IAAMC,4BAA4BC,EAAEC,OAAO;EACzCC,MAAMF,EAAEG,QAAQ,cAAA;;EAEhBC,QAAQJ,EAAEK,MACRL,EAAEC,OAAO;IACPC,MAAMF,EAAEM;IACRC,OAAOP,EAAEQ,SAASR,EAAES,OAAOT,EAAEM,QAAQN,EAAEU,GAAG,CAAA;EAC5C,CAAA,CAAA;EAEFC,SAASX,EAAEQ,SACTR,EAAEC,OAAO;;IAEPW,MAAMZ,EAAEQ,SAASR,EAAEa,OAAO;;IAE1BC,OAAOd,EAAEQ,SAASR,EAAEe,MAAM;EAC5B,CAAA,CAAA;AAEJ,CAAA;AAIA,IAAMC,qBAAqBhB,EAAEC,OAAO;EAClCC,MAAMF,EAAEG,QAAQ,OAAA;EAChBc,MAAMjB,EAAEM;AACV,CAAA;AAIA,IAAMY,uBAAuBlB,EAAEmB,QAC7BnB,EAAEC,OAAO;EACPC,MAAMF,EAAEG,QAAQ,SAAA;EAChBiB,QAAQpB,EAAEM;;EAEVe,MAAMrB,EAAEQ,SAASR,EAAEe,MAAM;AAC3B,CAAA,CAAA;AAKF,IAAMO,yBAAyBtB,EAAEC,OAAO;EACtCC,MAAMF,EAAEG,QAAQ,WAAA;EAChBoB,KAAKvB,EAAEM;EACPkB,MAAMxB,EAAEQ,SAASR,EAAES,OAAOT,EAAEM,QAAQN,EAAEU,GAAG,CAAA;AAC3C,CAAA;AAIA,IAAMe,oBAAoBzB,EAAE0B,MAC1BV,oBACAE,sBACAI,wBACAvB,yBAAAA;AAQK,IAAM4B,cAAN,cAA0BC,YAAY;EAC3CC,UAAU;EACVC,SAAS;AACX,CAAA,EAAG;EACDC,KAAK/B,EAAEM;EACP0B,aAAahC,EAAEQ,SAASR,EAAEM,MAAM;EAChC2B,OAAOjC,EAAEM;;EAET4B,SAASlC,EAAEM;AACb,CAAA,EAAA;AAAI;AAEG,IAAM6B,kBAAN,cAA8BP,YAAY;EAC/CC,UAAU;EACVC,SAAS;AACX,CAAA,EAAG;EACDM,UAAUpC,EAAEM,OAAO+B,KAAKrC,EAAEgC,YAAY,eAAA,CAAA;;EAEtCM,MAAMtC,EAAEQ,SAASR,EAAEuC,MAAM;EACzBC,MAAMf;AACR,CAAA,EAAA;AAAI;AAKG,IAAMgB,yBAAyBzC,EAAEC,OAAO;EAC7CyC,WAAW1C,EAAEQ,SAASR,EAAEmB,QAAQnB,EAAEK,MAAMsC,UAAUhB,WAAAA,CAAAA,CAAAA,CAAAA;EAClDiB,UAAU5C,EAAEQ,SAASR,EAAEmB,QAAQnB,EAAEK,MAAMsC,UAAUR,eAAAA,CAAAA,CAAAA,CAAAA;AACnD,CAAA;",
-  "names": ["RawObject", "S", "TypedObject", "SubscriptionTriggerSchema", "S", "struct", "type", "literal", "filter", "array", "string", "props", "optional", "record", "any", "options", "deep", "boolean", "delay", "number", "TimerTriggerSchema", "cron", "WebhookTriggerSchema", "mutable", "method", "port", "WebsocketTriggerSchema", "url", "init", "TriggerSpecSchema", "union", "FunctionDef", "TypedObject", "typename", "version", "uri", "description", "route", "handler", "FunctionTrigger", "function", "pipe", "meta", "object", "spec", "FunctionManifestSchema", "functions", "RawObject", "triggers"]
-}

package/dist/lib/node/chunk-3VSJ57ZZ.cjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/types.ts"],
-  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\nimport { RawObject, S, TypedObject } from '@dxos/echo-schema';\n\n/**\n * Type discriminator for TriggerSpec.\n * Every spec has a type field of type FunctionTriggerType that we can use to understand which\n * type we're working with.\n * https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions\n */\nexport type FunctionTriggerType = 'subscription' | 'timer' | 'webhook' | 'websocket';\n\nconst SubscriptionTriggerSchema = S.struct({\n  type: S.literal('subscription'),\n  // TODO(burdon): Define query DSL (from ECHO).\n  filter: S.array(\n    S.struct({\n      type: S.string,\n      props: S.optional(S.record(S.string, S.any)),\n    }),\n  ),\n  options: S.optional(\n    S.struct({\n      // Watch changes to object (not just creation).\n      deep: S.optional(S.boolean),\n      // Debounce changes (delay in ms).\n      delay: S.optional(S.number),\n    }),\n  ),\n});\n\nexport type SubscriptionTrigger = S.Schema.Type<typeof SubscriptionTriggerSchema>;\n\nconst TimerTriggerSchema = S.struct({\n  type: S.literal('timer'),\n  cron: S.string,\n});\n\nexport type TimerTrigger = S.Schema.Type<typeof TimerTriggerSchema>;\n\nconst WebhookTriggerSchema = S.mutable(\n  S.struct({\n    type: S.literal('webhook'),\n    method: S.string,\n    // Assigned port.\n    port: S.optional(S.number),\n  }),\n);\n\nexport type WebhookTrigger = S.Schema.Type<typeof WebhookTriggerSchema>;\n\nconst WebsocketTriggerSchema = S.struct({\n  type: S.literal('websocket'),\n  url: S.string,\n  init: S.optional(S.record(S.string, S.any)),\n});\n\nexport type WebsocketTrigger = S.Schema.Type<typeof WebsocketTriggerSchema>;\n\nconst TriggerSpecSchema = S.union(\n  TimerTriggerSchema,\n  WebhookTriggerSchema,\n  WebsocketTriggerSchema,\n  SubscriptionTriggerSchema,\n);\n\nexport type TriggerSpec = TimerTrigger | WebhookTrigger | WebsocketTrigger | SubscriptionTrigger;\n\n/**\n * Function definition.\n */\nexport class FunctionDef extends TypedObject({\n  typename: 'dxos.org/type/FunctionDef',\n  version: '0.1.0',\n})({\n  uri: S.string,\n  description: S.optional(S.string),\n  route: S.string,\n  // TODO(burdon): NPM/GitHub/Docker/CF URL?\n  handler: S.string,\n}) {}\n\nexport class FunctionTrigger extends TypedObject({\n  typename: 'dxos.org/type/FunctionTrigger',\n  version: '0.1.0',\n})({\n  function: S.string.pipe(S.description('Function URI.')),\n  // Context is merged into the event data passed to the function.\n  meta: S.optional(S.object),\n  spec: TriggerSpecSchema,\n}) {}\n\n/**\n * Function manifest file.\n */\nexport const FunctionManifestSchema = S.struct({\n  functions: S.optional(S.mutable(S.array(RawObject(FunctionDef)))),\n  triggers: S.optional(S.mutable(S.array(RawObject(FunctionTrigger)))),\n});\n\nexport type FunctionManifest = S.Schema.Type<typeof FunctionManifestSchema>;\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,yBAA0C;;;;;;;;AAU1C,IAAMA,4BAA4BC,qBAAEC,OAAO;EACzCC,MAAMF,qBAAEG,QAAQ,cAAA;;EAEhBC,QAAQJ,qBAAEK,MACRL,qBAAEC,OAAO;IACPC,MAAMF,qBAAEM;IACRC,OAAOP,qBAAEQ,SAASR,qBAAES,OAAOT,qBAAEM,QAAQN,qBAAEU,GAAG,CAAA;EAC5C,CAAA,CAAA;EAEFC,SAASX,qBAAEQ,SACTR,qBAAEC,OAAO;;IAEPW,MAAMZ,qBAAEQ,SAASR,qBAAEa,OAAO;;IAE1BC,OAAOd,qBAAEQ,SAASR,qBAAEe,MAAM;EAC5B,CAAA,CAAA;AAEJ,CAAA;AAIA,IAAMC,qBAAqBhB,qBAAEC,OAAO;EAClCC,MAAMF,qBAAEG,QAAQ,OAAA;EAChBc,MAAMjB,qBAAEM;AACV,CAAA;AAIA,IAAMY,uBAAuBlB,qBAAEmB,QAC7BnB,qBAAEC,OAAO;EACPC,MAAMF,qBAAEG,QAAQ,SAAA;EAChBiB,QAAQpB,qBAAEM;;EAEVe,MAAMrB,qBAAEQ,SAASR,qBAAEe,MAAM;AAC3B,CAAA,CAAA;AAKF,IAAMO,yBAAyBtB,qBAAEC,OAAO;EACtCC,MAAMF,qBAAEG,QAAQ,WAAA;EAChBoB,KAAKvB,qBAAEM;EACPkB,MAAMxB,qBAAEQ,SAASR,qBAAES,OAAOT,qBAAEM,QAAQN,qBAAEU,GAAG,CAAA;AAC3C,CAAA;AAIA,IAAMe,oBAAoBzB,qBAAE0B,MAC1BV,oBACAE,sBACAI,wBACAvB,yBAAAA;AAQK,IAAM4B,cAAN,kBAA0BC,gCAAY;EAC3CC,UAAU;EACVC,SAAS;AACX,CAAA,EAAG;EACDC,KAAK/B,qBAAEM;EACP0B,aAAahC,qBAAEQ,SAASR,qBAAEM,MAAM;EAChC2B,OAAOjC,qBAAEM;;EAET4B,SAASlC,qBAAEM;AACb,CAAA,EAAA;AAAI;AAEG,IAAM6B,kBAAN,kBAA8BP,gCAAY;EAC/CC,UAAU;EACVC,SAAS;AACX,CAAA,EAAG;EACDM,UAAUpC,qBAAEM,OAAO+B,KAAKrC,qBAAEgC,YAAY,eAAA,CAAA;;EAEtCM,MAAMtC,qBAAEQ,SAASR,qBAAEuC,MAAM;EACzBC,MAAMf;AACR,CAAA,EAAA;AAAI;AAKG,IAAMgB,yBAAyBzC,qBAAEC,OAAO;EAC7CyC,WAAW1C,qBAAEQ,SAASR,qBAAEmB,QAAQnB,qBAAEK,UAAMsC,8BAAUhB,WAAAA,CAAAA,CAAAA,CAAAA;EAClDiB,UAAU5C,qBAAEQ,SAASR,qBAAEmB,QAAQnB,qBAAEK,UAAMsC,8BAAUR,eAAAA,CAAAA,CAAAA,CAAAA;AACnD,CAAA;",
-  "names": ["SubscriptionTriggerSchema", "S", "struct", "type", "literal", "filter", "array", "string", "props", "optional", "record", "any", "options", "deep", "boolean", "delay", "number", "TimerTriggerSchema", "cron", "WebhookTriggerSchema", "mutable", "method", "port", "WebsocketTriggerSchema", "url", "init", "TriggerSpecSchema", "union", "FunctionDef", "TypedObject", "typename", "version", "uri", "description", "route", "handler", "FunctionTrigger", "function", "pipe", "meta", "object", "spec", "FunctionManifestSchema", "functions", "RawObject", "triggers"]
-}

package/dist/types/src/util.d.ts

@@ -1,15 +0,0 @@
-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
- */
-export declare const diff: <A, B = A>(previous: readonly A[], next: readonly B[], comparator: Comparator<A, B>) => DiffResult<A, B>;
-export declare const intersection: <A, B = A>(a: A[], b: B[], comparator: Comparator<A, B>) => A[];
-//# sourceMappingURL=util.d.ts.map

package/dist/types/src/util.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../src/util.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;AAE3D,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI;IACjC,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,OAAO,EAAE,CAAC,EAAE,CAAC;IACb,OAAO,EAAE,CAAC,EAAE,CAAC;CACd,CAAC;AAEF;;;;;GAKG;AAEH,eAAO,MAAM,IAAI,0GAwBhB,CAAC;AAGF,eAAO,MAAM,YAAY,iEACuC,CAAC"}

package/dist/types/src/util.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=util.test.d.ts.map

package/dist/types/src/util.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"util.test.d.ts","sourceRoot":"","sources":["../../../src/util.test.ts"],"names":[],"mappings":""}

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);