@dxos/functions 0.8.4-main.84f28bd → 0.8.4-main.ae835ea

package/src/types/Trigger.ts

@@ -0,0 +1,139 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+
+import { Obj, QueryAST, Type } from '@dxos/echo';
+import { Expando, OptionsAnnotationId, Ref } from '@dxos/echo/internal';
+import { DXN } from '@dxos/keys';
+
+/**
+ * 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 const Kinds = ['email', 'queue', 'subscription', 'timer', 'webhook'] as const;
+export type Kind = (typeof Kinds)[number];
+
+const kindLiteralAnnotations = { title: 'Kind' };
+
+export const EmailSpec = Schema.Struct({
+  kind: Schema.Literal('email').annotations(kindLiteralAnnotations),
+}).pipe(Schema.mutable);
+export type EmailSpec = Schema.Schema.Type<typeof EmailSpec>;
+
+export const QueueSpec = Schema.Struct({
+  kind: Schema.Literal('queue').annotations(kindLiteralAnnotations),
+
+  // TODO(dmaretskyi): Change to a reference.
+  queue: DXN.Schema,
+}).pipe(Schema.mutable);
+export type QueueSpec = Schema.Schema.Type<typeof QueueSpec>;
+
+/**
+ * Subscription.
+ */
+export const SubscriptionSpec = Schema.Struct({
+  kind: Schema.Literal('subscription').annotations(kindLiteralAnnotations),
+  query: Schema.Struct({
+    raw: Schema.optional(Schema.String.annotations({ title: 'Query' })),
+    ast: QueryAST.Query,
+  }).pipe(Schema.mutable),
+  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 SubscriptionSpec = Schema.Schema.Type<typeof SubscriptionSpec>;
+
+/**
+ * Cron timer.
+ */
+export const TimerSpec = Schema.Struct({
+  kind: Schema.Literal('timer').annotations(kindLiteralAnnotations),
+  cron: Schema.String.annotations({
+    title: 'Cron',
+    [SchemaAST.ExamplesAnnotationId]: ['0 0 * * *'],
+  }),
+}).pipe(Schema.mutable);
+export type TimerSpec = Schema.Schema.Type<typeof TimerSpec>;
+
+/**
+ * Webhook.
+ */
+export const WebhookSpec = Schema.Struct({
+  kind: Schema.Literal('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 WebhookSpec = Schema.Schema.Type<typeof WebhookSpec>;
+
+/**
+ * Trigger schema.
+ */
+export const Spec = Schema.Union(EmailSpec, QueueSpec, SubscriptionSpec, TimerSpec, WebhookSpec).annotations({
+  title: 'Trigger',
+});
+export type Spec = Schema.Schema.Type<typeof Spec>;
+
+/**
+ * Function trigger.
+ * Function is invoked with the `payload` passed as input data.
+ * The event that triggers the function is available in the function context.
+ */
+const Trigger_ = 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(Spec),
+
+  /**
+   * 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 }))),
+}).pipe(
+  Type.Obj({
+    typename: 'dxos.org/type/Trigger',
+    version: '0.1.0',
+  }),
+);
+export interface Trigger extends Schema.Schema.Type<typeof Trigger_> {}
+export interface TriggerEncoded extends Schema.Schema.Encoded<typeof Trigger_> {}
+export const Trigger: Schema.Schema<Trigger, TriggerEncoded> = Trigger_;
+
+export const make = (props: Obj.MakeProps<typeof Trigger>) => Obj.make(Trigger, props);

package/src/types/TriggerEvent.ts

@@ -0,0 +1,62 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { DXN, Obj, Type } from '@dxos/echo';
+
+export type TriggerEvent = EmailEvent | QueueEvent | SubscriptionEvent | TimerEvent | WebhookEvent;
+
+// TODO(burdon): Reuse trigger schema from @dxos/functions (TriggerType).
+export const EmailEvent = Schema.mutable(
+  Schema.Struct({
+    from: Schema.String,
+    to: Schema.String,
+    subject: Schema.String,
+    created: Schema.String,
+    body: Schema.String,
+  }),
+);
+export type EmailEvent = Schema.Schema.Type<typeof EmailEvent>;
+
+export const QueueEvent = Schema.mutable(
+  Schema.Struct({
+    queue: DXN.Schema,
+    item: Schema.Any,
+    cursor: Schema.String,
+  }),
+);
+export type QueueEvent = Schema.Schema.Type<typeof QueueEvent>;
+
+export const SubscriptionEvent = Schema.Struct({
+  /**
+   * Type of the mutation.
+   */
+  // TODO(dmaretskyi): Specify enum.
+  type: Schema.String,
+
+  /**
+   * Reference to the object that was changed or created.
+   */
+  subject: Type.Ref(Obj.Any),
+
+  /**
+   * @deprecated
+   */
+  changedObjectId: Schema.optional(Schema.String),
+}).pipe(Schema.mutable);
+export type SubscriptionEvent = Schema.Schema.Type<typeof SubscriptionEvent>;
+
+export const TimerEvent = Schema.mutable(Schema.Struct({ tick: Schema.Number }));
+export type TimerEvent = Schema.Schema.Type<typeof TimerEvent>;
+
+export const WebhookEvent = 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 WebhookEvent = Schema.Schema.Type<typeof WebhookEvent>;

package/src/types/index.ts

@@ -0,0 +1,8 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * as Function from './Function';
+export * as Script from './Script';
+export * as Trigger from './Trigger';
+export * as TriggerEvent from './TriggerEvent';

package/src/url.ts

@@ -2,11 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type ObjectMeta } from '@dxos/echo-schema';
+import { type ObjectMeta } from '@dxos/echo/internal';
 import { type SpaceId } from '@dxos/keys';
 
 // TODO: use URL scheme for source?
-const FUNCTIONS_META_KEY = 'dxos.org/service/function';
+export const FUNCTIONS_META_KEY = 'dxos.org/service/function';
 
 export const FUNCTIONS_PRESET_META_KEY = 'dxos.org/service/function-preset';
 
@@ -14,32 +14,35 @@ const isSecure = (protocol: string) => {
   return protocol === 'https:' || protocol === 'wss:';
 };
 
-export const getUserFunctionUrlInMetadata = (meta: ObjectMeta) => {
+/**
+ * NOTE: functionId is backend ID, not ECHO object id.
+ */
+export const getUserFunctionIdInMetadata = (meta: ObjectMeta) => {
   return meta.keys.find((key) => key.source === FUNCTIONS_META_KEY)?.id;
 };
 
-export const setUserFunctionUrlInMetadata = (meta: ObjectMeta, functionUrl: string) => {
+/**
+ * NOTE: functionId is backend ID, not ECHO object id.
+ */
+export const setUserFunctionIdInMetadata = (meta: ObjectMeta, functionId: string) => {
   const key = meta.keys.find((key) => key.source === FUNCTIONS_META_KEY);
   if (key) {
-    if (key.id !== functionUrl) {
+    if (key.id !== functionId) {
       throw new Error('Metadata mismatch');
     }
   } else {
-    meta.keys.push({ source: FUNCTIONS_META_KEY, id: functionUrl });
+    meta.keys.push({ source: FUNCTIONS_META_KEY, id: functionId });
   }
 };
 
 /**
  * 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 = {}) => {
+export const getInvocationUrl = (functionId: string, edgeUrl: string, options: InvocationOptions = {}) => {
   const baseUrl = new URL('functions/', edgeUrl);
 
   // Leading slashes cause the URL to be treated as an absolute path.
-  const relativeUrl = functionUrl.replace(/^\//, '');
-  const url = new URL(`./${relativeUrl}`, baseUrl.toString());
+  const url = new URL(`./${functionId}`, 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';

package/dist/lib/browser/chunk-54U464M4.mjs

@@ -1,360 +0,0 @@
-// src/services/ai.ts
-import { Context, Layer } from "effect";
-var AiService = class _AiService extends Context.Tag("AiService")() {
-  static {
-    this.make = (client) => {
-      return {
-        get client() {
-          return client;
-        }
-      };
-    };
-  }
-  static {
-    this.makeLayer = (client) => Layer.succeed(_AiService, _AiService.make(client));
-  }
-  static {
-    this.notAvailable = Layer.succeed(_AiService, {
-      get client() {
-        throw new Error("AiService not available");
-      }
-    });
-  }
-};
-
-// src/services/database.ts
-import { Context as Context2, Effect, Layer as Layer2 } from "effect";
-var DatabaseService = class _DatabaseService extends Context2.Tag("DatabaseService")() {
-  static {
-    this.notAvailable = Layer2.succeed(_DatabaseService, {
-      get db() {
-        throw new Error("Database not available");
-      }
-    });
-  }
-  static {
-    this.make = (db) => {
-      return {
-        get db() {
-          return db;
-        }
-      };
-    };
-  }
-  static {
-    this.resolve = Effect.fn(function* (dxn) {
-      const { db } = yield* _DatabaseService;
-      return yield* Effect.tryPromise({
-        try: () => db.graph.createRefResolver({
-          context: {
-            space: db.spaceId
-          }
-        }).resolve(dxn),
-        catch: (error) => error
-      });
-    });
-  }
-  static {
-    this.loadRef = Effect.fn(function* (ref) {
-      return yield* Effect.tryPromise({
-        try: () => ref.load(),
-        catch: (error) => error
-      });
-    });
-  }
-};
-
-// src/services/queues.ts
-import { Context as Context3, Layer as Layer3 } from "effect";
-var QueueService = class _QueueService extends Context3.Tag("QueueService")() {
-  static {
-    this.notAvailable = Layer3.succeed(_QueueService, {
-      queues: {
-        get(dxn) {
-          throw new Error("Queues not available");
-        },
-        create() {
-          throw new Error("Queues not available");
-        }
-      },
-      contextQueue: void 0
-    });
-  }
-  static {
-    this.make = (queues, contextQueue) => {
-      return {
-        queues,
-        contextQueue
-      };
-    };
-  }
-};
-
-// 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 credential;
-  }
-};
-
-// src/services/event-logger.ts
-import { Effect as Effect2, Context as Context5 } from "effect";
-import { invariant } from "@dxos/invariant";
-import { log, LogLevel } from "@dxos/log";
-var __dxlog_file = "/__w/dxos/dxos/packages/core/functions/src/services/event-logger.ts";
-var EventLogger = class extends Context5.Tag("EventLogger")() {
-  static {
-    this.noop = {
-      log: () => {
-      },
-      nodeId: void 0
-    };
-  }
-};
-var logCustomEvent = (data) => Effect2.gen(function* () {
-  const logger = yield* EventLogger;
-  if (!logger.nodeId) {
-    throw new Error("logCustomEvent must be called within a node compute function");
-  }
-  logger.log({
-    type: "custom",
-    nodeId: logger.nodeId,
-    event: data
-  });
-});
-var createDefectLogger = () => Effect2.catchAll((error) => Effect2.gen(function* () {
-  log.error("unhandled effect error", {
-    error
-  }, {
-    F: __dxlog_file,
-    L: 65,
-    S: this,
-    C: (f, a) => f(...a)
-  });
-  throw error;
-}));
-var createEventLogger = (level, message = "event") => {
-  const logFunction = {
-    [LogLevel.WARN]: log.warn,
-    [LogLevel.VERBOSE]: log.verbose,
-    [LogLevel.DEBUG]: log.debug,
-    [LogLevel.INFO]: log.info,
-    [LogLevel.ERROR]: log.error
-  }[level];
-  invariant(logFunction, void 0, {
-    F: __dxlog_file,
-    L: 80,
-    S: void 0,
-    A: [
-      "logFunction",
-      ""
-    ]
-  });
-  return {
-    log: (event) => {
-      logFunction(message, event);
-    },
-    nodeId: void 0
-  };
-};
-
-// src/services/function-call-service.ts
-import { Context as Context6 } from "effect";
-var FunctionCallService = class extends Context6.Tag("FunctionCallService")() {
-  static fromClient(baseUrl, spaceId) {
-    return {
-      callFunction: async (deployedFunctionId, input) => {
-        const url = getInvocationUrl(deployedFunctionId, baseUrl, {
-          spaceId
-        });
-        const result = await fetch(url, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify(input)
-        });
-        if (result.status >= 300 || result.status < 200) {
-          throw new Error("Failed to invoke function", {
-            cause: new Error(`HTTP error: ${await result.text()}`)
-          });
-        }
-        return await result.json();
-      }
-    };
-  }
-  static {
-    this.mock = () => {
-      return {
-        callFunction: async (deployedFunctionId, input) => {
-          return input;
-        }
-      };
-    };
-  }
-};
-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();
-};
-var isSecure = (protocol) => {
-  return protocol === "https:" || protocol === "wss:";
-};
-
-// src/services/tool-resolver.ts
-import { Context as Context7 } from "effect";
-var ToolResolverService = class extends Context7.Tag("ToolResolverService")() {
-  static {
-    this.notAvailable = {
-      toolResolver: {
-        resolve: async (id) => {
-          throw new Error("Tool resolver not available");
-        }
-      }
-    };
-  }
-  static {
-    this.make = (toolResolver) => {
-      return {
-        toolResolver
-      };
-    };
-  }
-};
-
-// src/services/tracing.ts
-import { Context as Context8 } from "effect";
-var TracingService = class extends Context8.Tag("TracingService")() {
-  static {
-    this.noop = {
-      write: () => {
-      }
-    };
-  }
-  static {
-    this.console = {
-      write: (event) => {
-        console.log(event);
-      }
-    };
-  }
-};
-
-// src/services/service-container.ts
-import { Layer as Layer4 } from "effect";
-var SERVICE_MAPPING = {
-  [AiService.key]: "ai",
-  [CredentialsService.key]: "credentials",
-  [DatabaseService.key]: "database",
-  [EventLogger.key]: "eventLogger",
-  [FunctionCallService.key]: "functionCallService",
-  [QueueService.key]: "queues",
-  [TracingService.key]: "tracing",
-  [ToolResolverService.key]: "toolResolver"
-};
-var SERVICE_TAGS = [
-  AiService,
-  CredentialsService,
-  DatabaseService,
-  EventLogger,
-  FunctionCallService,
-  TracingService,
-  QueueService
-];
-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
-    });
-  }
-  // TODO(dmaretskyi): `getService` is designed to error at runtime if the service is not available, but layer forces us to provide all services and makes stubs for the ones that are not available.
-  createLayer() {
-    const ai = this._services.ai != null ? Layer4.succeed(AiService, this._services.ai) : AiService.notAvailable;
-    const credentials = Layer4.succeed(CredentialsService, new ConfiguredCredentialsService());
-    const database = this._services.database != null ? Layer4.succeed(DatabaseService, this._services.database) : DatabaseService.notAvailable;
-    const queues = this._services.queues != null ? Layer4.succeed(QueueService, this._services.queues) : QueueService.notAvailable;
-    const tracing = Layer4.succeed(TracingService, this._services.tracing ?? TracingService.noop);
-    const eventLogger = Layer4.succeed(EventLogger, this._services.eventLogger ?? EventLogger.noop);
-    const functionCallService = Layer4.succeed(FunctionCallService, this._services.functionCallService ?? FunctionCallService.mock());
-    const toolResolver = Layer4.succeed(ToolResolverService, this._services.toolResolver ?? ToolResolverService.notAvailable);
-    return Layer4.mergeAll(
-      //
-      ai,
-      credentials,
-      database,
-      queues,
-      tracing,
-      eventLogger,
-      functionCallService,
-      toolResolver
-    );
-  }
-};
-
-export {
-  AiService,
-  DatabaseService,
-  QueueService,
-  CredentialsService,
-  ConfiguredCredentialsService,
-  EventLogger,
-  logCustomEvent,
-  createDefectLogger,
-  createEventLogger,
-  FunctionCallService,
-  ToolResolverService,
-  TracingService,
-  SERVICE_TAGS,
-  ServiceContainer
-};
-//# sourceMappingURL=chunk-54U464M4.mjs.map