@dxos/functions 0.8.3 → 0.8.4-main.1068cf700f

package/src/services/service-container.ts

@@ -1,109 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Layer, type Context } from 'effect';
-
-import { AiService } from './ai';
-import { ConfiguredCredentialsService, CredentialsService } from './credentials';
-import { DatabaseService } from './database';
-import { EventLogger } from './event-logger';
-import { FunctionCallService } from './function-call-service';
-import { QueueService } from './queues';
-import { TracingService } from './tracing';
-
-/**
- * List of all service tags and their names.
- */
-export interface ServiceTagRecord {
-  ai: AiService;
-  credentials: CredentialsService;
-  database: DatabaseService;
-  eventLogger: EventLogger;
-  functionCallService: FunctionCallService;
-  tracing: TracingService;
-  queues: QueueService;
-}
-
-/**
- * List of all services and their runtime types.
- */
-export type ServiceRecord = {
-  [K in keyof ServiceTagRecord]: Context.Tag.Service<ServiceTagRecord[K]>;
-};
-
-/**
- * Union of all services.
- */
-export type Services = ServiceTagRecord[keyof ServiceTagRecord];
-
-const SERVICE_MAPPING: Record<string, keyof ServiceRecord> = {
-  [AiService.key]: 'ai',
-  [CredentialsService.key]: 'credentials',
-  [DatabaseService.key]: 'database',
-  [EventLogger.key]: 'eventLogger',
-  [FunctionCallService.key]: 'functionCallService',
-  [QueueService.key]: 'queues',
-  [TracingService.key]: 'tracing',
-};
-
-export const SERVICE_TAGS: Context.Tag<any, any>[] = [
-  AiService,
-  CredentialsService,
-  DatabaseService,
-  EventLogger,
-  FunctionCallService,
-  TracingService,
-  QueueService,
-];
-
-const DEFAULT_SERVICES: Partial<ServiceRecord> = {
-  tracing: TracingService.noop,
-};
-
-export class ServiceContainer {
-  private _services: Partial<ServiceRecord> = { ...DEFAULT_SERVICES };
-
-  /**
-   * Set services.
-   * @param services - Services to set.
-   * @returns The container instance.
-   */
-  setServices(services: Partial<ServiceRecord>): this {
-    this._services = { ...this._services, ...services };
-    return this;
-  }
-
-  getService<T extends Context.Tag<any, any>>(tag: T): Context.Tag.Service<T> {
-    const serviceKey = SERVICE_MAPPING[tag.key];
-    const service = serviceKey != null ? this._services[serviceKey] : undefined;
-    if (!service) {
-      throw new Error(`Service not available: ${tag.key}`);
-    }
-    return service as Context.Tag.Service<T>;
-  }
-
-  clone(): ServiceContainer {
-    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(): Layer.Layer<Services> {
-    const ai = this._services.ai != null ? Layer.succeed(AiService, this._services.ai) : AiService.notAvailable;
-    const credentials = Layer.succeed(CredentialsService, new ConfiguredCredentialsService());
-    const database =
-      this._services.database != null
-        ? Layer.succeed(DatabaseService, this._services.database)
-        : DatabaseService.notAvailable;
-    const queues =
-      this._services.queues != null ? Layer.succeed(QueueService, this._services.queues) : QueueService.notAvailable;
-    const tracing = Layer.succeed(TracingService, this._services.tracing ?? TracingService.noop);
-    const eventLogger = Layer.succeed(EventLogger, this._services.eventLogger ?? EventLogger.noop);
-    const functionCallService = Layer.succeed(
-      FunctionCallService,
-      this._services.functionCallService ?? FunctionCallService.mock(),
-    );
-
-    return Layer.mergeAll(ai, credentials, database, queues, tracing, eventLogger, functionCallService);
-  }
-}

package/src/testing/index.ts

@@ -1,5 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-export * from './services';

package/src/testing/logger.ts

@@ -1,16 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Effect, type Context } from 'effect';
-
-import { LogLevel } from '@dxos/log';
-
-import { type EventLogger, createEventLogger } from '../services';
-
-export const noopLogger: Context.Tag.Service<EventLogger> = {
-  log: () => Effect.succeed(undefined),
-  nodeId: undefined,
-};
-
-export const consoleLogger: Context.Tag.Service<EventLogger> = createEventLogger(LogLevel.INFO);

package/src/testing/services.ts

@@ -1,32 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type Context } from 'effect';
-
-import type { AiServiceClient } from '@dxos/ai';
-import type { QueueFactory } from '@dxos/echo-db';
-
-import { consoleLogger, noopLogger } from './logger';
-import { AiService, QueueService, ServiceContainer } from '../services';
-import type { EventLogger } from '../services/event-logger';
-
-export type TestServiceOptions = {
-  ai?: AiServiceClient;
-  queueFactory?: QueueFactory;
-  enableLogging?: boolean;
-  logger?: Context.Tag.Service<EventLogger>;
-};
-
-export const createTestServices = ({
-  ai,
-  queueFactory,
-  enableLogging = false,
-  logger = enableLogging ? consoleLogger : noopLogger,
-}: TestServiceOptions = {}): ServiceContainer => {
-  return new ServiceContainer().setServices({
-    ai: ai != null ? AiService.make(ai) : undefined,
-    eventLogger: logger,
-    queues: queueFactory != null ? QueueService.make(queueFactory, undefined) : undefined,
-  });
-};

package/src/trace.ts

@@ -1,180 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Schema } from 'effect';
-
-import { Type, type Ref } from '@dxos/echo';
-import { Queue } from '@dxos/echo-db';
-import { ObjectId } from '@dxos/echo-schema';
-import { log } from '@dxos/log';
-
-import { FunctionTrigger, type FunctionTriggerType } from './types';
-
-export enum InvocationOutcome {
-  SUCCESS = 'success',
-  FAILURE = 'failure',
-  PENDING = 'pending',
-}
-
-// TODO(burdon): Convert to extensible discriminated union of EDGE events.
-export enum InvocationTraceEventType {
-  START = 'start',
-  END = 'end',
-}
-
-export const TraceEventException = Schema.Struct({
-  timestampMs: Schema.Number,
-  message: Schema.String,
-  name: Schema.String,
-  stack: Schema.optional(Schema.String),
-});
-export type TraceEventException = Schema.Schema.Type<typeof TraceEventException>;
-
-export const InvocationTraceStartEvent = Schema.Struct({
-  /**
-   * Queue message id.
-   */
-  id: ObjectId,
-  type: Schema.Literal(InvocationTraceEventType.START),
-  /**
-   * Invocation id, the same for invocation start and end events.
-   */
-  invocationId: ObjectId,
-  /**
-   * Event generation time.
-   */
-  timestampMs: Schema.Number,
-  /**
-   * Data passed to function / workflow as an argument.
-   */
-  // TODO(burdon): Input schema?
-  input: Schema.Object,
-  /**
-   * Queue  for function/workflow invocation events.
-   */
-  invocationTraceQueue: Type.Ref(Queue),
-  /**
-   * DXN of the invoked function/workflow.
-   */
-  invocationTarget: Type.Ref(Type.Expando),
-  /**
-   * Present for automatic invocations.
-   */
-  trigger: Schema.optional(Type.Ref(FunctionTrigger)),
-}).pipe(Type.Obj({ typename: 'dxos.org/type/InvocationTraceStart', version: '0.1.0' }));
-
-export type InvocationTraceStartEvent = Schema.Schema.Type<typeof InvocationTraceStartEvent>;
-
-export const InvocationTraceEndEvent = Schema.Struct({
-  /**
-   * Trace event id.
-   */
-  id: ObjectId,
-  type: Schema.Literal(InvocationTraceEventType.END),
-  /**
-   * Invocation id, will be the same for invocation start and end.
-   */
-  invocationId: ObjectId,
-  /**
-   * Event generation time.
-   */
-  // TODO(burdon): Remove ms suffix.
-  timestampMs: Schema.Number,
-  outcome: Schema.Enums(InvocationOutcome),
-  exception: Schema.optional(TraceEventException),
-}).pipe(Type.Obj({ typename: 'dxos.org/type/InvocationTraceEnd', version: '0.1.0' }));
-
-export type InvocationTraceEndEvent = Schema.Schema.Type<typeof InvocationTraceEndEvent>;
-
-export type InvocationTraceEvent = InvocationTraceStartEvent | InvocationTraceEndEvent;
-
-export const TraceEventLog = Schema.Struct({
-  timestampMs: Schema.Number,
-  level: Schema.String,
-  message: Schema.String,
-  context: Schema.optional(Schema.Object),
-});
-
-export const TraceEvent = Schema.Struct({
-  id: ObjectId,
-  // TODO(burdon): Need enum/numeric result (not string).
-  outcome: Schema.String,
-  truncated: Schema.Boolean,
-  /**
-   * Time when the event was persisted.
-   */
-  ingestionTimestampMs: Schema.Number,
-  logs: Schema.Array(TraceEventLog),
-  exceptions: Schema.Array(TraceEventException),
-}).pipe(Type.Obj({ typename: 'dxos.org/type/TraceEvent', version: '0.1.0' }));
-
-export type TraceEvent = Schema.Schema.Type<typeof TraceEvent>;
-
-/**
- * InvocationTrace event format.
- * This is the combined format of InvocationTraceStartEvent and InvocationTraceEndEvents for UI consumption.
- */
-export type InvocationSpan = {
-  id: string;
-  timestampMs: number;
-  outcome: InvocationOutcome;
-  input: object;
-  durationMs: number;
-  invocationTraceQueue: Ref.Ref<Queue>;
-  invocationTarget: Ref.Ref<Type.Expando>;
-  trigger?: Ref.Ref<FunctionTriggerType>;
-  exception?: TraceEventException;
-};
-
-export const createInvocationSpans = (items?: InvocationTraceEvent[]): InvocationSpan[] => {
-  if (!items) {
-    return [];
-  }
-
-  const eventsByInvocationId = new Map<string, { start?: InvocationTraceStartEvent; end?: InvocationTraceEndEvent }>();
-  for (const event of items) {
-    if (!('invocationId' in event)) {
-      // Skip legacy format entries.
-      continue;
-    }
-
-    const invocationId = event.invocationId;
-    const entry = eventsByInvocationId.get(invocationId) || { start: undefined, end: undefined };
-    if (event.type === InvocationTraceEventType.START) {
-      entry.start = event as InvocationTraceStartEvent;
-    } else if (event.type === InvocationTraceEventType.END) {
-      entry.end = event as InvocationTraceEndEvent;
-    }
-
-    eventsByInvocationId.set(invocationId, entry);
-  }
-
-  const now = Date.now();
-  const result: InvocationSpan[] = [];
-
-  // Create spans for each invocation
-  for (const [invocationId, { start, end }] of eventsByInvocationId.entries()) {
-    if (!start) {
-      // No start event, can't create a meaningful span
-      log.warn('found end event without matching start', { invocationId });
-      continue;
-    }
-
-    const isInProgress = end === undefined;
-
-    result.push({
-      id: invocationId,
-      timestampMs: start.timestampMs,
-      durationMs: isInProgress ? now - start.timestampMs : end!.timestampMs - start.timestampMs,
-      outcome: end?.outcome ?? InvocationOutcome.PENDING,
-      exception: end?.exception,
-      input: start.input,
-      invocationTraceQueue: start.invocationTraceQueue,
-      invocationTarget: start.invocationTarget,
-      trigger: start.trigger,
-    });
-  }
-
-  return result;
-};

package/src/translations.ts

@@ -1,20 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import { Type } from '@dxos/echo';
-
-import { ScriptType } from './schema';
-
-export default [
-  {
-    'en-US': {
-      [Type.getTypename(ScriptType)]: {
-        'typename label': 'Script',
-        'typename label_zero': 'Scripts',
-        'typename label_one': 'Script',
-        'typename label_other': 'Scripts',
-      },
-    },
-  },
-];

package/src/types.ts

@@ -1,211 +0,0 @@
-//
-// 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/url.ts

@@ -1,52 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type ObjectMeta } from '@dxos/echo-schema';
-import { type SpaceId } from '@dxos/keys';
-
-// TODO: use URL scheme for source?
-const FUNCTIONS_META_KEY = 'dxos.org/service/function';
-
-export const FUNCTIONS_PRESET_META_KEY = 'dxos.org/service/function-preset';
-
-const isSecure = (protocol: string) => {
-  return protocol === 'https:' || protocol === 'wss:';
-};
-
-export const getUserFunctionUrlInMetadata = (meta: ObjectMeta) => {
-  return meta.keys.find((key) => key.source === FUNCTIONS_META_KEY)?.id;
-};
-
-export const setUserFunctionUrlInMetadata = (meta: ObjectMeta, functionUrl: string) => {
-  const key = meta.keys.find((key) => key.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 });
-  }
-};
-
-/**
- * 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);
-
-  // Leading slashes cause the URL to be treated as an absolute path.
-  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();
-};
-
-export type InvocationOptions = {
-  spaceId?: SpaceId;
-  subjectId?: string;
-};