@dxos/functions 0.8.2-staging.7ac8446 → 0.8.2

package/dist/lib/node-esm/index.mjs

@@ -1,48 +1,9 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import {
-  incrementSemverPatch,
-  publicKeyToDid,
-  uploadWorkerFunction
-} from "./chunk-O2SXVYU5.mjs";
-import {
-  FunctionRegistry,
-  TriggerRegistry,
-  createSubscriptionTrigger,
-  createTimerTrigger
-} from "./chunk-SQSJO5HI.mjs";
-import {
-  FUNCTIONS_PRESET_META_KEY,
-  FUNCTION_TYPES,
-  FunctionDef,
-  FunctionManifestSchema,
-  FunctionTrigger,
-  FunctionTriggerSchema,
-  FunctionType,
-  InvocationOutcome,
-  InvocationTraceEndEvent,
-  InvocationTraceEventType,
-  InvocationTraceStartEvent,
-  ScriptType,
-  TraceEvent,
-  TraceEventException,
-  TraceEventLog,
-  TriggerKind,
-  TriggerSchema,
-  createInvocationSpans,
-  getInvocationUrl,
-  getUserFunctionUrlInMetadata,
-  setUserFunctionUrlInMetadata
-} from "./chunk-HBD2FZXO.mjs";
-import "./chunk-DHGBFXSZ.mjs";
 
 // packages/core/functions/src/handler.ts
-import { Schema as S } from "effect";
-import { PublicKey } from "@dxos/client";
-import { log } from "@dxos/log";
-import { isNonNullable } from "@dxos/util";
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/functions/src/handler.ts";
+import { Schema } from "effect";
 var defineFunction = (params) => {
-  if (!S.isSchema(params.inputSchema)) {
+  if (!Schema.isSchema(params.inputSchema)) {
     throw new Error("Input schema must be a valid schema");
   }
   if (typeof params.handler !== "function") {
@@ -51,75 +12,528 @@ var defineFunction = (params) => {
   return {
     description: params.description,
     inputSchema: params.inputSchema,
-    outputSchema: params.outputSchema ?? S.Any,
+    outputSchema: params.outputSchema ?? Schema.Any,
     handler: params.handler
   };
 };
-var subscriptionHandler = (handler, types) => {
-  return async ({ event: { data }, context, response, ...rest }) => {
-    const { client } = context;
-    const space = data.spaceKey ? client.spaces.get(PublicKey.from(data.spaceKey)) : void 0;
-    if (!space) {
-      log.error("Invalid space", void 0, {
-        F: __dxlog_file,
-        L: 180,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
-      return response.status(500);
+
+// packages/core/functions/src/schema.ts
+import { Schema as Schema2 } from "effect";
+import { EchoObject, JsonSchemaType, LabelAnnotation, Ref, TypedObject } from "@dxos/echo-schema";
+import { DataType } from "@dxos/schema";
+var ScriptType = Schema2.Struct({
+  name: Schema2.optional(Schema2.String),
+  description: Schema2.optional(Schema2.String),
+  // TODO(burdon): Change to hash of deployed content.
+  // Whether source has changed since last deploy.
+  changed: Schema2.optional(Schema2.Boolean),
+  source: Ref(DataType.Text)
+}).pipe(EchoObject({
+  typename: "dxos.org/type/Script",
+  version: "0.1.0"
+}), LabelAnnotation.set([
+  "name"
+]));
+var FunctionType = class extends TypedObject({
+  typename: "dxos.org/type/Function",
+  version: "0.1.0"
+})({
+  // TODO(burdon): Rename to id/uri?
+  name: Schema2.NonEmptyString,
+  version: Schema2.String,
+  description: Schema2.optional(Schema2.String),
+  // Reference to a source script if it exists within ECHO.
+  // TODO(burdon): Don't ref ScriptType directly (core).
+  source: Schema2.optional(Ref(ScriptType)),
+  inputSchema: Schema2.optional(JsonSchemaType),
+  outputSchema: Schema2.optional(JsonSchemaType),
+  // Local binding to a function name.
+  binding: Schema2.optional(Schema2.String)
+}) {
+};
+
+// packages/core/functions/src/trace.ts
+import { Schema as Schema4 } from "effect";
+import { Queue } from "@dxos/echo-db";
+import { EchoObject as EchoObject2, Expando as Expando2, ObjectId, Ref as Ref3 } from "@dxos/echo-schema";
+import { log } from "@dxos/log";
+
+// packages/core/functions/src/types.ts
+import { Schema as Schema3, SchemaAST } from "effect";
+import { Expando, OptionsAnnotationId, TypedObject as TypedObject2, Ref as Ref2, RawObject } from "@dxos/echo-schema";
+import { DXN } from "@dxos/keys";
+var TriggerKind = /* @__PURE__ */ function(TriggerKind2) {
+  TriggerKind2["Timer"] = "timer";
+  TriggerKind2["Webhook"] = "webhook";
+  TriggerKind2["Subscription"] = "subscription";
+  TriggerKind2["Email"] = "email";
+  TriggerKind2["Queue"] = "queue";
+  return TriggerKind2;
+}({});
+var kindLiteralAnnotations = {
+  title: "Kind"
+};
+var TimerTriggerSchema = Schema3.Struct({
+  kind: Schema3.Literal("timer").annotations(kindLiteralAnnotations),
+  cron: Schema3.String.annotations({
+    title: "Cron",
+    [SchemaAST.ExamplesAnnotationId]: [
+      "0 0 * * *"
+    ]
+  })
+}).pipe(Schema3.mutable);
+var EmailTriggerSchema = Schema3.Struct({
+  kind: Schema3.Literal("email").annotations(kindLiteralAnnotations)
+}).pipe(Schema3.mutable);
+var QueueTriggerSchema = Schema3.Struct({
+  kind: Schema3.Literal("queue").annotations(kindLiteralAnnotations),
+  queue: DXN.Schema
+}).pipe(Schema3.mutable);
+var WebhookTriggerSchema = Schema3.Struct({
+  kind: Schema3.Literal("webhook").annotations(kindLiteralAnnotations),
+  method: Schema3.optional(Schema3.String.annotations({
+    title: "Method",
+    [OptionsAnnotationId]: [
+      "GET",
+      "POST"
+    ]
+  })),
+  port: Schema3.optional(Schema3.Number.annotations({
+    title: "Port"
+  }))
+}).pipe(Schema3.mutable);
+var QuerySchema = Schema3.Struct({
+  type: Schema3.optional(Schema3.String.annotations({
+    title: "Type"
+  })),
+  props: Schema3.optional(Schema3.Record({
+    key: Schema3.String,
+    value: Schema3.Any
+  }))
+}).annotations({
+  title: "Query"
+});
+var SubscriptionTriggerSchema = Schema3.Struct({
+  kind: Schema3.Literal("subscription").annotations(kindLiteralAnnotations),
+  // TODO(burdon): Define query DSL (from ECHO). Reconcile with Table.Query.
+  filter: QuerySchema,
+  options: Schema3.optional(Schema3.Struct({
+    // Watch changes to object (not just creation).
+    deep: Schema3.optional(Schema3.Boolean.annotations({
+      title: "Nested"
+    })),
+    // Debounce changes (delay in ms).
+    delay: Schema3.optional(Schema3.Number.annotations({
+      title: "Delay"
+    }))
+  }).annotations({
+    title: "Options"
+  }))
+}).pipe(Schema3.mutable);
+var TriggerSchema = Schema3.Union(TimerTriggerSchema, WebhookTriggerSchema, SubscriptionTriggerSchema, EmailTriggerSchema, QueueTriggerSchema).annotations({
+  title: "Trigger"
+});
+var EmailTriggerOutput = Schema3.mutable(Schema3.Struct({
+  from: Schema3.String,
+  to: Schema3.String,
+  subject: Schema3.String,
+  created: Schema3.String,
+  body: Schema3.String
+}));
+var WebhookTriggerOutput = Schema3.mutable(Schema3.Struct({
+  url: Schema3.String,
+  method: Schema3.Literal("GET", "POST"),
+  headers: Schema3.Record({
+    key: Schema3.String,
+    value: Schema3.String
+  }),
+  bodyText: Schema3.String
+}));
+var QueueTriggerOutput = Schema3.mutable(Schema3.Struct({
+  queue: DXN.Schema,
+  item: Schema3.Any,
+  cursor: Schema3.String
+}));
+var SubscriptionTriggerOutput = Schema3.mutable(Schema3.Struct({
+  type: Schema3.String,
+  changedObjectId: Schema3.String
+}));
+var TimerTriggerOutput = Schema3.mutable(Schema3.Struct({
+  tick: Schema3.Number
+}));
+var FunctionTriggerSchema = Schema3.Struct({
+  /**
+  * Function or workflow to invoke.
+  */
+  // TODO(dmaretskyi): Can be a Ref(FunctionType) or Ref(ComputeGraphType).
+  function: Schema3.optional(Ref2(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: Schema3.optional(Schema3.String.annotations({
+    title: "Input Node ID"
+  })),
+  enabled: Schema3.optional(Schema3.Boolean.annotations({
+    title: "Enabled"
+  })),
+  spec: Schema3.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: Schema3.optional(Schema3.mutable(Schema3.Record({
+    key: Schema3.String,
+    value: Schema3.Any
+  })))
+});
+var FunctionTrigger = class extends TypedObject2({
+  typename: "dxos.org/type/FunctionTrigger",
+  version: "0.2.0"
+})(FunctionTriggerSchema.fields) {
+};
+var FunctionManifestSchema = Schema3.Struct({
+  functions: Schema3.optional(Schema3.mutable(Schema3.Array(RawObject(FunctionType)))),
+  triggers: Schema3.optional(Schema3.mutable(Schema3.Array(RawObject(FunctionTrigger))))
+});
+var FUNCTION_TYPES = [
+  FunctionType,
+  FunctionTrigger
+];
+
+// packages/core/functions/src/trace.ts
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/functions/src/trace.ts";
+var InvocationOutcome = /* @__PURE__ */ function(InvocationOutcome2) {
+  InvocationOutcome2["SUCCESS"] = "success";
+  InvocationOutcome2["FAILURE"] = "failure";
+  InvocationOutcome2["PENDING"] = "pending";
+  return InvocationOutcome2;
+}({});
+var InvocationTraceEventType = /* @__PURE__ */ function(InvocationTraceEventType2) {
+  InvocationTraceEventType2["START"] = "start";
+  InvocationTraceEventType2["END"] = "end";
+  return InvocationTraceEventType2;
+}({});
+var TraceEventException = Schema4.Struct({
+  timestampMs: Schema4.Number,
+  message: Schema4.String,
+  name: Schema4.String,
+  stack: Schema4.optional(Schema4.String)
+});
+var InvocationTraceStartEvent = Schema4.Struct({
+  /**
+  * Queue message id.
+  */
+  id: ObjectId,
+  type: Schema4.Literal("start"),
+  /**
+  * Invocation id, the same for invocation start and end events.
+  */
+  invocationId: ObjectId,
+  /**
+  * Event generation time.
+  */
+  timestampMs: Schema4.Number,
+  /**
+  * Data passed to function / workflow as an argument.
+  */
+  // TODO(burdon): Input schema?
+  input: Schema4.Object,
+  /**
+  * Queue  for function/workflow invocation events.
+  */
+  invocationTraceQueue: Ref3(Queue),
+  /**
+  * DXN of the invoked function/workflow.
+  */
+  invocationTarget: Ref3(Expando2),
+  /**
+  * Present for automatic invocations.
+  */
+  trigger: Schema4.optional(Ref3(FunctionTrigger))
+}).pipe(EchoObject2({
+  typename: "dxos.org/type/InvocationTraceStart",
+  version: "0.1.0"
+}));
+var InvocationTraceEndEvent = Schema4.Struct({
+  /**
+  * Trace event id.
+  */
+  id: ObjectId,
+  type: Schema4.Literal("end"),
+  /**
+  * Invocation id, will be the same for invocation start and end.
+  */
+  invocationId: ObjectId,
+  /**
+  * Event generation time.
+  */
+  // TODO(burdon): Remove ms suffix.
+  timestampMs: Schema4.Number,
+  outcome: Schema4.Enums(InvocationOutcome),
+  exception: Schema4.optional(TraceEventException)
+}).pipe(EchoObject2({
+  typename: "dxos.org/type/InvocationTraceEnd",
+  version: "0.1.0"
+}));
+var TraceEventLog = Schema4.Struct({
+  timestampMs: Schema4.Number,
+  level: Schema4.String,
+  message: Schema4.String,
+  context: Schema4.optional(Schema4.Object)
+});
+var TraceEvent = Schema4.Struct({
+  id: ObjectId,
+  // TODO(burdon): Need enum/numeric result (not string).
+  outcome: Schema4.String,
+  truncated: Schema4.Boolean,
+  /**
+  * Time when the event was persisted.
+  */
+  ingestionTimestampMs: Schema4.Number,
+  logs: Schema4.Array(TraceEventLog),
+  exceptions: Schema4.Array(TraceEventException)
+}).pipe(EchoObject2({
+  typename: "dxos.org/type/TraceEvent",
+  version: "0.1.0"
+}));
+var createInvocationSpans = (items) => {
+  if (!items) {
+    return [];
+  }
+  const eventsByInvocationId = /* @__PURE__ */ new Map();
+  for (const event of items) {
+    if (!("invocationId" in event)) {
+      continue;
     }
-    registerTypes(space, types);
-    const objects = space ? data.objects?.map((id) => space.db.getObjectById(id)).filter(isNonNullable) : [];
-    if (!!data.spaceKey && !space) {
-      log.warn("invalid space", {
-        data
-      }, {
-        F: __dxlog_file,
-        L: 192,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
-    } else {
-      log.info("handler", {
-        space: space?.key.truncate(),
-        objects: objects?.length
+    const invocationId = event.invocationId;
+    const entry = eventsByInvocationId.get(invocationId) || {
+      start: void 0,
+      end: void 0
+    };
+    if (event.type === "start") {
+      entry.start = event;
+    } else if (event.type === "end") {
+      entry.end = event;
+    }
+    eventsByInvocationId.set(invocationId, entry);
+  }
+  const now = Date.now();
+  const result = [];
+  for (const [invocationId, { start, end }] of eventsByInvocationId.entries()) {
+    if (!start) {
+      log.warn("found end event without matching start", {
+        invocationId
       }, {
         F: __dxlog_file,
-        L: 194,
+        L: 160,
         S: void 0,
         C: (f, a) => f(...a)
       });
+      continue;
+    }
+    const isInProgress = end === void 0;
+    result.push({
+      id: invocationId,
+      timestampMs: start.timestampMs,
+      durationMs: isInProgress ? now - start.timestampMs : end.timestampMs - start.timestampMs,
+      outcome: end?.outcome ?? "pending",
+      exception: end?.exception,
+      input: start.input,
+      invocationTraceQueue: start.invocationTraceQueue,
+      invocationTarget: start.invocationTarget,
+      trigger: start.trigger
+    });
+  }
+  return result;
+};
+
+// packages/core/functions/src/url.ts
+var FUNCTIONS_META_KEY = "dxos.org/service/function";
+var FUNCTIONS_PRESET_META_KEY = "dxos.org/service/function-preset";
+var isSecure = (protocol) => {
+  return protocol === "https:" || protocol === "wss:";
+};
+var getUserFunctionUrlInMetadata = (meta) => {
+  return meta.keys.find((key) => key.source === FUNCTIONS_META_KEY)?.id;
+};
+var setUserFunctionUrlInMetadata = (meta, functionUrl) => {
+  const key = meta.keys.find((key2) => key2.source === FUNCTIONS_META_KEY);
+  if (key) {
+    if (key.id !== functionUrl) {
+      throw new Error("Metadata mismatch");
+    }
+  } else {
+    meta.keys.push({
+      source: FUNCTIONS_META_KEY,
+      id: functionUrl
+    });
+  }
+};
+var makeFunctionUrl = (fn) => `/${fn.functionId}`;
+var getInvocationUrl = (functionUrl, edgeUrl, options = {}) => {
+  const baseUrl = new URL("functions/", edgeUrl);
+  const relativeUrl = functionUrl.replace(/^\//, "");
+  const url = new URL(`./${relativeUrl}`, baseUrl.toString());
+  options.spaceId && url.searchParams.set("spaceId", options.spaceId);
+  options.subjectId && url.searchParams.set("subjectId", options.subjectId);
+  url.protocol = isSecure(url.protocol) ? "https" : "http";
+  return url.toString();
+};
+
+// packages/core/functions/src/services/ai.ts
+import { Context } from "effect";
+var AiService = class extends Context.Tag("AiService")() {
+};
+
+// packages/core/functions/src/services/database.ts
+import { Context as Context2 } from "effect";
+var DatabaseService = class extends Context2.Tag("DatabaseService")() {
+};
+
+// packages/core/functions/src/services/queues.ts
+import { Context as Context3 } from "effect";
+var QueuesService = class extends Context3.Tag("QueuesService")() {
+};
+
+// packages/core/functions/src/services/credentials.ts
+import { Context as Context4 } from "effect";
+var CredentialsService = class extends Context4.Tag("CredentialsService")() {
+};
+var ConfiguredCredentialsService = class {
+  constructor(credentials = []) {
+    this.credentials = credentials;
+  }
+  addCredentials(credentials) {
+    this.credentials.push(...credentials);
+    return this;
+  }
+  async queryCredentials(query) {
+    return this.credentials.filter((credential) => credential.service === query.service);
+  }
+  async getCredential(query) {
+    const credential = this.credentials.find((credential2) => credential2.service === query.service);
+    if (!credential) {
+      throw new Error(`Credential not found for service: ${query.service}`);
     }
-    return handler({
-      event: {
-        data: {
-          ...data,
-          space,
-          objects
-        }
+    return credential;
+  }
+};
+
+// packages/core/functions/src/services/tracing.ts
+import { Context as Context5 } from "effect";
+var TracingService = class extends Context5.Tag("TracingService")() {
+  static {
+    this.noop = {
+      write: () => {
+      }
+    };
+  }
+  static {
+    this.console = {
+      write: (event) => {
+        console.log(event);
+      }
+    };
+  }
+};
+
+// packages/core/functions/src/services/service-container.ts
+var SERVICE_MAPPING = {
+  [DatabaseService.key]: "database",
+  [AiService.key]: "ai",
+  [QueuesService.key]: "queues",
+  [CredentialsService.key]: "credentials",
+  [TracingService.key]: "tracing"
+};
+var DEFAULT_SERVICES = {
+  tracing: TracingService.noop
+};
+var ServiceContainer = class _ServiceContainer {
+  constructor() {
+    this._services = {
+      ...DEFAULT_SERVICES
+    };
+  }
+  /**
+  * Set services.
+  * @param services - Services to set.
+  * @returns The container instance.
+  */
+  setServices(services) {
+    this._services = {
+      ...this._services,
+      ...services
+    };
+    return this;
+  }
+  getService(tag) {
+    const serviceKey = SERVICE_MAPPING[tag.key];
+    const service = serviceKey != null ? this._services[serviceKey] : void 0;
+    if (!service) {
+      throw new Error(`Service not available: ${tag.key}`);
+    }
+    return service;
+  }
+  clone() {
+    return new _ServiceContainer().setServices({
+      ...this._services
+    });
+  }
+};
+
+// packages/core/functions/src/executor/executor.ts
+import { Effect, Schema as Schema5 } from "effect";
+var FunctionExecutor = class {
+  constructor(_services) {
+    this._services = _services;
+  }
+  // TODO(dmaretskyi): Invocation context: queue, space, etc...
+  async invoke(fnDef, input) {
+    const assertInput = fnDef.inputSchema.pipe(Schema5.asserts);
+    assertInput(input);
+    const context = {
+      getService: this._services.getService.bind(this._services),
+      getSpace: async (_spaceId) => {
+        throw new Error("Not available. Use the database service instead.");
       },
+      space: void 0,
+      get ai() {
+        throw new Error("Not available. Use the ai service instead.");
+      }
+    };
+    const result = await fnDef.handler({
       context,
-      response,
-      ...rest
+      data: input
     });
-  };
-};
-var registerTypes = (space, types = []) => {
-  const registry = space.db.graph.schemaRegistry;
-  for (const type of types) {
-    if (!registry.hasSchema(type)) {
-      registry.addSchema([
-        type
-      ]);
+    const assertOutput = fnDef.outputSchema?.pipe(Schema5.asserts);
+    assertOutput(result);
+    if (Effect.isEffect(result)) {
+      return Effect.runPromise(result);
     }
+    return result;
   }
 };
 export {
+  AiService,
+  ConfiguredCredentialsService,
+  CredentialsService,
+  DatabaseService,
+  EmailTriggerOutput,
   FUNCTIONS_PRESET_META_KEY,
   FUNCTION_TYPES,
-  FunctionDef,
+  FunctionExecutor,
   FunctionManifestSchema,
-  FunctionRegistry,
   FunctionTrigger,
   FunctionTriggerSchema,
   FunctionType,
@@ -127,23 +541,24 @@ export {
   InvocationTraceEndEvent,
   InvocationTraceEventType,
   InvocationTraceStartEvent,
+  QueueTriggerOutput,
+  QueuesService,
   ScriptType,
+  ServiceContainer,
+  SubscriptionTriggerOutput,
+  TimerTriggerOutput,
   TraceEvent,
   TraceEventException,
   TraceEventLog,
+  TracingService,
   TriggerKind,
-  TriggerRegistry,
   TriggerSchema,
+  WebhookTriggerOutput,
   createInvocationSpans,
-  createSubscriptionTrigger,
-  createTimerTrigger,
   defineFunction,
   getInvocationUrl,
   getUserFunctionUrlInMetadata,
-  incrementSemverPatch,
-  publicKeyToDid,
-  setUserFunctionUrlInMetadata,
-  subscriptionHandler,
-  uploadWorkerFunction
+  makeFunctionUrl,
+  setUserFunctionUrlInMetadata
 };
 //# sourceMappingURL=index.mjs.map