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

package/src/types.ts

@@ -0,0 +1,211 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { Schema, SchemaAST } from 'effect';
+
+import { Expando, OptionsAnnotationId, TypedObject, Ref, RawObject } from '@dxos/echo-schema';
+import { DXN } from '@dxos/keys';
+
+import { FunctionType } from './schema';
+
+/**
+ * Type discriminator for TriggerType.
+ * Every spec has a type field of type TriggerKind that we can use to understand which type we're working with.
+ * https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions
+ */
+export enum TriggerKind {
+  Timer = 'timer',
+  Webhook = 'webhook',
+  Subscription = 'subscription',
+  Email = 'email',
+  Queue = 'queue',
+}
+
+const kindLiteralAnnotations = { title: 'Kind' };
+
+/**
+ * Cron timer.
+ */
+const TimerTriggerSchema = Schema.Struct({
+  kind: Schema.Literal(TriggerKind.Timer).annotations(kindLiteralAnnotations),
+  cron: Schema.String.annotations({
+    title: 'Cron',
+    [SchemaAST.ExamplesAnnotationId]: ['0 0 * * *'],
+  }),
+}).pipe(Schema.mutable);
+export type TimerTrigger = Schema.Schema.Type<typeof TimerTriggerSchema>;
+
+const EmailTriggerSchema = Schema.Struct({
+  kind: Schema.Literal(TriggerKind.Email).annotations(kindLiteralAnnotations),
+}).pipe(Schema.mutable);
+export type EmailTrigger = Schema.Schema.Type<typeof EmailTriggerSchema>;
+
+const QueueTriggerSchema = Schema.Struct({
+  kind: Schema.Literal(TriggerKind.Queue).annotations(kindLiteralAnnotations),
+  queue: DXN.Schema,
+}).pipe(Schema.mutable);
+export type QueueTrigger = Schema.Schema.Type<typeof QueueTriggerSchema>;
+
+/**
+ * Webhook.
+ */
+const WebhookTriggerSchema = Schema.Struct({
+  kind: Schema.Literal(TriggerKind.Webhook).annotations(kindLiteralAnnotations),
+  method: Schema.optional(
+    Schema.String.annotations({
+      title: 'Method',
+      [OptionsAnnotationId]: ['GET', 'POST'],
+    }),
+  ),
+  port: Schema.optional(
+    Schema.Number.annotations({
+      title: 'Port',
+    }),
+  ),
+}).pipe(Schema.mutable);
+export type WebhookTrigger = Schema.Schema.Type<typeof WebhookTriggerSchema>;
+
+// TODO(burdon): Use ECHO definition (from https://github.com/dxos/dxos/pull/8233).
+const QuerySchema = Schema.Struct({
+  type: Schema.optional(Schema.String.annotations({ title: 'Type' })),
+  props: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
+}).annotations({ title: 'Query' });
+
+/**
+ * Subscription.
+ */
+const SubscriptionTriggerSchema = Schema.Struct({
+  kind: Schema.Literal(TriggerKind.Subscription).annotations(kindLiteralAnnotations),
+  // TODO(burdon): Define query DSL (from ECHO). Reconcile with Table.Query.
+  filter: QuerySchema,
+  options: Schema.optional(
+    Schema.Struct({
+      // Watch changes to object (not just creation).
+      deep: Schema.optional(Schema.Boolean.annotations({ title: 'Nested' })),
+      // Debounce changes (delay in ms).
+      delay: Schema.optional(Schema.Number.annotations({ title: 'Delay' })),
+    }).annotations({ title: 'Options' }),
+  ),
+}).pipe(Schema.mutable);
+export type SubscriptionTrigger = Schema.Schema.Type<typeof SubscriptionTriggerSchema>;
+
+/**
+ * Trigger schema (discriminated union).
+ */
+export const TriggerSchema = Schema.Union(
+  TimerTriggerSchema,
+  WebhookTriggerSchema,
+  SubscriptionTriggerSchema,
+  EmailTriggerSchema,
+  QueueTriggerSchema,
+).annotations({
+  title: 'Trigger',
+});
+export type TriggerType = Schema.Schema.Type<typeof TriggerSchema>;
+
+export type EventType =
+  | EmailTriggerOutput
+  | WebhookTriggerOutput
+  | QueueTriggerOutput
+  | SubscriptionTriggerOutput
+  | TimerTriggerOutput;
+
+// TODO(burdon): Reuse trigger schema from @dxos/functions (TriggerType).
+export const EmailTriggerOutput = Schema.mutable(
+  Schema.Struct({
+    from: Schema.String,
+    to: Schema.String,
+    subject: Schema.String,
+    created: Schema.String,
+    body: Schema.String,
+  }),
+);
+export type EmailTriggerOutput = Schema.Schema.Type<typeof EmailTriggerOutput>;
+
+export const WebhookTriggerOutput = Schema.mutable(
+  Schema.Struct({
+    url: Schema.String,
+    method: Schema.Literal('GET', 'POST'),
+    headers: Schema.Record({ key: Schema.String, value: Schema.String }),
+    bodyText: Schema.String,
+  }),
+);
+export type WebhookTriggerOutput = Schema.Schema.Type<typeof WebhookTriggerOutput>;
+
+export const QueueTriggerOutput = Schema.mutable(
+  Schema.Struct({
+    queue: DXN.Schema,
+    item: Schema.Any,
+    cursor: Schema.String,
+  }),
+);
+export type QueueTriggerOutput = Schema.Schema.Type<typeof QueueTriggerOutput>;
+
+export const SubscriptionTriggerOutput = Schema.mutable(
+  Schema.Struct({ type: Schema.String, changedObjectId: Schema.String }),
+);
+export type SubscriptionTriggerOutput = Schema.Schema.Type<typeof SubscriptionTriggerOutput>;
+
+export const TimerTriggerOutput = Schema.mutable(Schema.Struct({ tick: Schema.Number }));
+export type TimerTriggerOutput = Schema.Schema.Type<typeof TimerTriggerOutput>;
+
+/**
+ * Function trigger.
+ * Function is invoked with the `payload` passed as input data.
+ * The event that triggers the function is available in the function context.
+ */
+export const FunctionTriggerSchema = Schema.Struct({
+  /**
+   * Function or workflow to invoke.
+   */
+  // TODO(dmaretskyi): Can be a Ref(FunctionType) or Ref(ComputeGraphType).
+  function: Schema.optional(Ref(Expando).annotations({ title: 'Function' })),
+
+  /**
+   * Only used for workflowSchema.
+   * Specifies the input node in the circuit.
+   * @deprecated Remove and enforce a single input node in all compute graphSchema.
+   */
+  inputNodeId: Schema.optional(Schema.String.annotations({ title: 'Input Node ID' })),
+
+  enabled: Schema.optional(Schema.Boolean.annotations({ title: 'Enabled' })),
+
+  spec: Schema.optional(TriggerSchema),
+
+  /**
+   * Passed as the input data to the function.
+   * Must match the function's input schema.
+   *
+   * @example
+   * {
+   *   item: '{{$.trigger.event}}',
+   *   instructions: 'Summarize and perform entity-extraction'
+   *   mailbox: { '/': 'dxn:echo:AAA:ZZZ' }
+   * }
+   */
+  input: Schema.optional(Schema.mutable(Schema.Record({ key: Schema.String, value: Schema.Any }))),
+});
+
+export type FunctionTriggerType = Schema.Schema.Type<typeof FunctionTriggerSchema>;
+
+/**
+ * Function trigger.
+ */
+export class FunctionTrigger extends TypedObject({
+  typename: 'dxos.org/type/FunctionTrigger',
+  version: '0.2.0',
+})(FunctionTriggerSchema.fields) {}
+
+// TODO(wittjosiah): Remove?
+
+/**
+ * Function manifest file.
+ */
+export const FunctionManifestSchema = Schema.Struct({
+  functions: Schema.optional(Schema.mutable(Schema.Array(RawObject(FunctionType)))),
+  triggers: Schema.optional(Schema.mutable(Schema.Array(RawObject(FunctionTrigger)))),
+});
+export type FunctionManifest = Schema.Schema.Type<typeof FunctionManifestSchema>;
+
+export const FUNCTION_TYPES = [FunctionType, FunctionTrigger];

package/src/{types/url.ts → url.ts}

@@ -29,6 +29,11 @@ export const setUserFunctionUrlInMetadata = (meta: ObjectMeta, functionUrl: stri
   }
 };
 
+/**
+ * NOTE: functionId is backend ID, not ECHO object id.
+ */
+export const makeFunctionUrl = (fn: { functionId: string }) => `/${fn.functionId}`;
+
 export const getInvocationUrl = (functionUrl: string, edgeUrl: string, options: InvocationOptions = {}) => {
   const baseUrl = new URL('functions/', edgeUrl);
 

package/dist/lib/browser/chunk-HI7YZO2K.mjs

@@ -1,482 +0,0 @@
-import "@dxos/node-std/globals";
-import {
-  FunctionDef,
-  FunctionTrigger
-} from "./chunk-RVSG6WTL.mjs";
-
-// packages/core/functions/src/function/function-registry.ts
-import { Event } from "@dxos/async";
-import { create, Filter } from "@dxos/client/echo";
-import { Resource } from "@dxos/context";
-import { PublicKey } from "@dxos/keys";
-import { log } from "@dxos/log";
-import { ComplexMap, diff } from "@dxos/util";
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/functions/src/function/function-registry.ts";
-var FunctionRegistry = class extends Resource {
-  constructor(_client) {
-    super();
-    this._client = _client;
-    this._functionBySpaceKey = new ComplexMap(PublicKey.hash);
-    this.registered = new Event();
-  }
-  getFunctions(space) {
-    return this._functionBySpaceKey.get(space.key) ?? [];
-  }
-  getUniqueByUri() {
-    const uniqueByUri = [
-      ...this._functionBySpaceKey.values()
-    ].flatMap((defs) => defs).reduce((acc, v) => {
-      acc.set(v.uri, v);
-      return acc;
-    }, /* @__PURE__ */ new Map());
-    return [
-      ...uniqueByUri.values()
-    ];
-  }
-  /**
-  * Loads function definitions from the manifest into the space.
-  * We first load all the definitions from the space to deduplicate by functionId.
-  */
-  async register(space, functions) {
-    log("register", {
-      space: space.key,
-      functions: functions?.length ?? 0
-    }, {
-      F: __dxlog_file,
-      L: 48,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    if (!functions?.length) {
-      return;
-    }
-    if (!space.db.graph.schemaRegistry.hasSchema(FunctionDef)) {
-      space.db.graph.schemaRegistry.addSchema([
-        FunctionDef
-      ]);
-    }
-    const { objects: existing } = await space.db.query(Filter.schema(FunctionDef)).run();
-    const { added } = diff(existing, functions, (a, b) => a.uri === b.uri);
-    added.forEach((def) => space.db.add(create(FunctionDef, def)));
-    if (added.length > 0) {
-      await space.db.flush({
-        indexes: true,
-        updates: true
-      });
-    }
-  }
-  async _open() {
-    log.info("opening...", void 0, {
-      F: __dxlog_file,
-      L: 68,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const spacesSubscription = this._client.spaces.subscribe(async (spaces) => {
-      for (const space of spaces) {
-        if (this._functionBySpaceKey.has(space.key)) {
-          continue;
-        }
-        const registered = [];
-        this._functionBySpaceKey.set(space.key, registered);
-        await space.waitUntilReady();
-        if (this._ctx.disposed) {
-          break;
-        }
-        this._ctx.onDispose(space.db.query(Filter.schema(FunctionDef)).subscribe(({ objects }) => {
-          const { added } = diff(registered, objects, (a, b) => a.uri === b.uri);
-          if (added.length > 0) {
-            registered.push(...added);
-            this.registered.emit({
-              space,
-              added
-            });
-          }
-        }));
-      }
-    });
-    this._ctx.onDispose(() => spacesSubscription.unsubscribe());
-  }
-  async _close(_) {
-    log.info("closing...", void 0, {
-      F: __dxlog_file,
-      L: 101,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    this._functionBySpaceKey.clear();
-  }
-};
-
-// packages/core/functions/src/trigger/type/subscription-trigger.ts
-import { debounce, UpdateScheduler } from "@dxos/async";
-import { Filter as Filter2 } from "@dxos/client/echo";
-import { createSubscription } from "@dxos/echo-db";
-import { log as log2 } from "@dxos/log";
-var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/functions/src/trigger/type/subscription-trigger.ts";
-var createSubscriptionTrigger = async (ctx, space, spec, callback) => {
-  const objectIds = /* @__PURE__ */ new Set();
-  const task = new UpdateScheduler(ctx, async () => {
-    if (objectIds.size > 0) {
-      const objects = Array.from(objectIds);
-      objectIds.clear();
-      await callback({
-        objects
-      });
-    }
-  }, {
-    maxFrequency: 4
-  });
-  const subscriptions = [];
-  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) {
-      log2.info("updated", {
-        added: added.length,
-        updated: updated.length
-      }, {
-        F: __dxlog_file2,
-        L: 46,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
-      task.trigger();
-    }
-  });
-  subscriptions.push(() => subscription.unsubscribe());
-  const { filter, options: { deep, delay } = {} } = spec;
-  const update = ({ objects }) => {
-    log2.info("update", {
-      objects: objects.length
-    }, {
-      F: __dxlog_file2,
-      L: 56,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-    subscription.update(objects);
-    if (deep) {
-    }
-  };
-  log2.info("subscription", {
-    filter
-  }, {
-    F: __dxlog_file2,
-    L: 74,
-    S: void 0,
-    C: (f, a) => f(...a)
-  });
-  if (filter.type) {
-    const query = space.db.query(Filter2.typename(filter.type, filter.props));
-    subscriptions.push(query.subscribe(delay ? debounce(update, delay) : update));
-  }
-  ctx.onDispose(() => {
-    subscriptions.forEach((unsubscribe) => unsubscribe());
-  });
-};
-
-// packages/core/functions/src/trigger/type/timer-trigger.ts
-import { parseCronExpression } from "cron-schedule";
-import { DeferredTask } from "@dxos/async";
-import { log as log3 } from "@dxos/log";
-var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/functions/src/trigger/type/timer-trigger.ts";
-var createTimerTrigger = async (ctx, space, spec, callback) => {
-  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;
-    }
-    const now = Date.now();
-    const delta = last ? now - last : 0;
-    last = now;
-    run++;
-    log3.info("tick", {
-      space: space.key.truncate(),
-      count: run,
-      delta
-    }, {
-      F: __dxlog_file3,
-      L: 39,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-    task.schedule();
-    timeout = setTimeout(runCron, getRunTimeout());
-  };
-  let timeout = setTimeout(runCron, getRunTimeout());
-  ctx.onDispose(() => clearTimeout(timeout));
-};
-
-// packages/core/functions/src/trigger/trigger-registry.ts
-import { Event as Event2 } from "@dxos/async";
-import { create as create2, Filter as Filter3, getMeta, compareForeignKeys } from "@dxos/client/echo";
-import { Context, Resource as Resource2 } from "@dxos/context";
-import { ECHO_ATTR_META, foreignKey } from "@dxos/echo-schema";
-import { invariant } from "@dxos/invariant";
-import { PublicKey as PublicKey2 } from "@dxos/keys";
-import { log as log4 } from "@dxos/log";
-import { ComplexMap as ComplexMap2, diff as diff2 } from "@dxos/util";
-var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/core/functions/src/trigger/trigger-registry.ts";
-var triggerFactory = {
-  timer: createTimerTrigger,
-  // TODO(burdon): Cannot use in browser.
-  // webhook: createWebhookTrigger,
-  subscription: createSubscriptionTrigger
-};
-var TriggerRegistry = class extends Resource2 {
-  constructor(_client, _options) {
-    super();
-    this._client = _client;
-    this._options = _options;
-    this._triggersBySpaceKey = new ComplexMap2(PublicKey2.hash);
-    this.registered = new Event2();
-    this.removed = new Event2();
-  }
-  getActiveTriggers(space) {
-    return this._getTriggers(space, (t) => t.activationCtx != null);
-  }
-  getInactiveTriggers(space) {
-    return this._getTriggers(space, (t) => t.activationCtx == null);
-  }
-  /**
-  * Set callback for trigger.
-  */
-  async activate(space, trigger, callback) {
-    log4("activate", {
-      space: space.key,
-      trigger
-    }, {
-      F: __dxlog_file4,
-      L: 75,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const activationCtx = new Context({
-      name: `FunctionTrigger-${trigger.function}`
-    }, {
-      F: __dxlog_file4,
-      L: 77
-    });
-    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}`, {
-      F: __dxlog_file4,
-      L: 80,
-      S: this,
-      A: [
-        "registeredTrigger",
-        "`Trigger is not registered: ${trigger.function}`"
-      ]
-    });
-    registeredTrigger.activationCtx = activationCtx;
-    try {
-      invariant(trigger.spec, void 0, {
-        F: __dxlog_file4,
-        L: 85,
-        S: this,
-        A: [
-          "trigger.spec",
-          ""
-        ]
-      });
-      const options = this._options?.[trigger.spec.type];
-      const createTrigger = triggerFactory[trigger.spec.type];
-      invariant(createTrigger, `Trigger factory not found: ${trigger.spec.type}`, {
-        F: __dxlog_file4,
-        L: 88,
-        S: this,
-        A: [
-          "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.
-  */
-  async register(space, manifest) {
-    log4("register", {
-      space: space.key
-    }, {
-      F: __dxlog_file4,
-      L: 100,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    if (!manifest.triggers?.length) {
-      return;
-    }
-    if (!space.db.graph.schemaRegistry.hasSchema(FunctionTrigger)) {
-      space.db.graph.schemaRegistry.addSchema([
-        FunctionTrigger
-      ]);
-    }
-    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 create2(FunctionTrigger, trigger, {
-        keys
-      });
-    });
-    const { objects: existing } = await space.db.query(Filter3.schema(FunctionTrigger)).run();
-    const { added } = diff2(existing, manifestTriggers, compareForeignKeys);
-    added.forEach((trigger) => {
-      space.db.add(trigger);
-      log4.info("added", {
-        meta: getMeta(trigger)
-      }, {
-        F: __dxlog_file4,
-        L: 127,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    });
-    if (added.length > 0) {
-      await space.db.flush();
-    }
-  }
-  async _open() {
-    log4.info("open...", void 0, {
-      F: __dxlog_file4,
-      L: 136,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const spaceListSubscription = this._client.spaces.subscribe(async (spaces) => {
-      for (const space of spaces) {
-        if (this._triggersBySpaceKey.has(space.key)) {
-          continue;
-        }
-        const registered = [];
-        this._triggersBySpaceKey.set(space.key, registered);
-        await space.waitUntilReady();
-        if (this._ctx.disposed) {
-          break;
-        }
-        this._ctx.onDispose(space.db.query(Filter3.schema(FunctionTrigger)).subscribe(async ({ objects: current }) => {
-          log4.info("update", {
-            space: space.key,
-            registered: registered.length,
-            current: current.length
-          }, {
-            F: __dxlog_file4,
-            L: 153,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          await this._handleRemovedTriggers(space, current, registered);
-          this._handleNewTriggers(space, current, registered);
-        }));
-      }
-    });
-    this._ctx.onDispose(() => spaceListSubscription.unsubscribe());
-    log4.info("opened", void 0, {
-      F: __dxlog_file4,
-      L: 162,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  }
-  async _close(_) {
-    log4.info("close...", void 0, {
-      F: __dxlog_file4,
-      L: 166,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    this._triggersBySpaceKey.clear();
-    log4.info("closed", void 0, {
-      F: __dxlog_file4,
-      L: 168,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  }
-  _handleNewTriggers(space, current, registered) {
-    const added = current.filter((candidate) => {
-      return candidate.enabled && registered.find((reg) => reg.trigger.id === candidate.id) == null;
-    });
-    if (added.length > 0) {
-      const newRegisteredTriggers = added.map((trigger) => ({
-        trigger
-      }));
-      registered.push(...newRegisteredTriggers);
-      log4.info("added", () => ({
-        spaceKey: space.key,
-        triggers: added.map((trigger) => trigger.function)
-      }), {
-        F: __dxlog_file4,
-        L: 179,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      this.registered.emit({
-        space,
-        triggers: added
-      });
-    }
-  }
-  async _handleRemovedTriggers(space, current, registered) {
-    const removed = [];
-    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) {
-      log4.info("removed", () => ({
-        spaceKey: space.key,
-        triggers: removed.map((trigger) => trigger.function)
-      }), {
-        F: __dxlog_file4,
-        L: 205,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      this.removed.emit({
-        space,
-        triggers: removed
-      });
-    }
-  }
-  _getTriggers(space, predicate) {
-    const allSpaceTriggers = this._triggersBySpaceKey.get(space.key) ?? [];
-    return allSpaceTriggers.filter(predicate).map((trigger) => trigger.trigger);
-  }
-};
-
-export {
-  FunctionRegistry,
-  createSubscriptionTrigger,
-  createTimerTrigger,
-  TriggerRegistry
-};
-//# sourceMappingURL=chunk-HI7YZO2K.mjs.map