@dxos/functions 0.8.4-main.5acf9ea → 0.8.4-main.5ad4a44

package/src/services/function-invocation-service.ts

@@ -0,0 +1,84 @@
+//
+// Copyright 2025 DXOS.org
+//
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { AiService } from '@dxos/ai';
+
+import { type FunctionDefinition } from '../handler';
+
+import { CredentialsService } from './credentials';
+import { DatabaseService } from './database';
+import {
+  FunctionImplementationResolver,
+  type InvocationServices,
+  LocalFunctionExecutionService,
+} from './local-function-execution';
+import { QueueService } from './queues';
+import { RemoteFunctionExecutionService } from './remote-function-execution-service';
+
+export class FunctionInvocationService extends Context.Tag('@dxos/functions/FunctionInvocationService')<
+  FunctionInvocationService,
+  {
+    invokeFunction<I, O>(functionDef: FunctionDefinition<I, O>, input: I): Effect.Effect<O, never, InvocationServices>;
+  }
+>() {
+  static invokeFunction = Effect.serviceFunctionEffect(FunctionInvocationService, (_) => _.invokeFunction);
+
+  static layer = Layer.effect(
+    FunctionInvocationService,
+    Effect.gen(function* () {
+      const localExecutioner = yield* LocalFunctionExecutionService;
+      const remoteExecutioner = yield* RemoteFunctionExecutionService;
+
+      return {
+        invokeFunction: <I, O>(
+          functionDef: FunctionDefinition<I, O>,
+          input: I,
+        ): Effect.Effect<O, never, InvocationServices> =>
+          Effect.gen(function* () {
+            if (functionDef.meta?.deployedFunctionId) {
+              return yield* remoteExecutioner.callFunction<I, O>(functionDef.meta.deployedFunctionId, input);
+            }
+
+            return yield* localExecutioner.invokeFunction(functionDef, input);
+          }),
+      } satisfies Context.Tag.Service<FunctionInvocationService>;
+    }),
+  );
+
+  // TODO(dmaretskyi): Don't provide `FunctionImplementationResolver`.
+  static layerTest = ({
+    functions = [],
+  }: {
+    functions?: FunctionDefinition<any, any>[];
+  } = {}): Layer.Layer<
+    FunctionInvocationService,
+    never,
+    AiService.AiService | CredentialsService | DatabaseService | QueueService
+  > =>
+    FunctionInvocationService.layer.pipe(
+      Layer.provide(LocalFunctionExecutionService.layerLive),
+      Layer.provide(FunctionImplementationResolver.layerTest({ functions })),
+      Layer.provide(RemoteFunctionExecutionService.layerMock),
+    );
+
+  // TODO(dmaretskyi): This shouldn't default to all services being not available.
+  // TODO(dmaretskyi): Don't provide `FunctionImplementationResolver`.
+  /**
+   * @deprecated Use {@link layerTest} instead.
+   */
+  static layerTestMocked = ({
+    functions,
+  }: {
+    functions: FunctionDefinition<any, any>[];
+  }): Layer.Layer<FunctionInvocationService> =>
+    FunctionInvocationService.layerTest({ functions }).pipe(
+      Layer.provide(AiService.notAvailable),
+      Layer.provide(CredentialsService.configuredLayer([])),
+      Layer.provide(DatabaseService.notAvailable),
+      Layer.provide(QueueService.notAvailable),
+    );
+}

package/src/services/index.ts

@@ -2,11 +2,12 @@
 // Copyright 2025 DXOS.org
 //
 
+export * from './credentials';
 export * from './database';
+export * from './event-logger';
+export * from './function-invocation-service';
+export * from './local-function-execution';
 export * from './queues';
 export * from './service-container';
-export * from './credentials';
 export * from './tracing';
-export * from './event-logger';
 export * from './remote-function-execution-service';
-export * from './local-function-execution';

package/src/services/local-function-execution.ts

@@ -2,47 +2,104 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context, Effect, Layer, Schema } from 'effect';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Schema from 'effect/Schema';
 
+import { AiService } from '@dxos/ai';
 import { todo } from '@dxos/debug';
+import { log } from '@dxos/log';
 
+import { FunctionError, FunctionNotFoundError } from '../errors';
 import type { FunctionContext, FunctionDefinition } from '../handler';
-import type { Services } from './service-container';
-import { FunctionError } from '../errors';
+
+import { CredentialsService } from './credentials';
+import { DatabaseService } from './database';
+import { type ComputeEventLogger } from './event-logger';
+import { QueueService } from './queues';
+import { RemoteFunctionExecutionService } from './remote-function-execution-service';
+import { type Services } from './service-container';
+import { type TracingService } from './tracing';
+
+/**
+ * Services that are provided at the function call site.
+ */
+export type InvocationServices = TracingService | ComputeEventLogger;
 
 export class LocalFunctionExecutionService extends Context.Tag('@dxos/functions/LocalFunctionExecutionService')<
   LocalFunctionExecutionService,
   {
     // TODO(dmaretskyi): This should take function id instead of the definition object.
     // TODO(dmaretskyi): Services should be satisfied from environment rather then bubbled up.
-    invokeFunction(fnDef: FunctionDefinition<any, any>, input: unknown): Effect.Effect<unknown, never, Services>;
+    invokeFunction<I, O>(functionDef: FunctionDefinition<I, O>, input: I): Effect.Effect<O, never, InvocationServices>;
   }
 >() {
-  static layer = Layer.succeed(LocalFunctionExecutionService, {
-    invokeFunction: (fnDef, input) => invokeFunction(fnDef, input),
-  });
+  static layerLive = Layer.effect(
+    LocalFunctionExecutionService,
+    Effect.gen(function* () {
+      // TODO(dmaretskyi): Use `yield* Effect.context()`;
+      const resolver = yield* FunctionImplementationResolver;
+      const ai = yield* AiService.AiService;
+      const credentials = yield* CredentialsService;
+      const database = yield* DatabaseService;
+      const queues = yield* QueueService;
+      // TODO(mykola): Delete, should not be required for local execution.
+      const functionCallService = yield* RemoteFunctionExecutionService;
+      return {
+        // TODO(dmaretskyi): Better error types.
+        invokeFunction: <I, O>(
+          functionDef: FunctionDefinition<I, O>,
+          input: I,
+        ): Effect.Effect<O, never, InvocationServices> =>
+          Effect.gen(function* () {
+            const resolved = yield* resolver.resolveFunctionImplementation(functionDef).pipe(Effect.orDie);
+            const output = yield* invokeFunction(resolved, input);
+            return output as O;
+          }).pipe(
+            Effect.provideService(AiService.AiService, ai),
+            Effect.provideService(CredentialsService, credentials),
+            Effect.provideService(DatabaseService, database),
+            Effect.provideService(QueueService, queues),
+            Effect.provideService(RemoteFunctionExecutionService, functionCallService),
+          ),
+      };
+    }),
+  );
+
+  static invokeFunction: <F extends FunctionDefinition.Any>(
+    functionDef: F,
+    input: FunctionDefinition.Input<F>,
+  ) => Effect.Effect<FunctionDefinition.Output<F>, never, Services | LocalFunctionExecutionService> =
+    Effect.serviceFunctionEffect(LocalFunctionExecutionService, (_) => _.invokeFunction as any);
 }
 
-const invokeFunction = (fnDef: FunctionDefinition<any, any>, input: any): Effect.Effect<unknown, never, Services> =>
+const invokeFunction = (
+  functionDef: FunctionDefinition<any, any>,
+  input: any,
+): Effect.Effect<unknown, never, Services> =>
   Effect.gen(function* () {
-    // Assert input matches schema
-    const assertInput = fnDef.inputSchema.pipe(Schema.asserts);
-    (assertInput as any)(input);
+    // Assert input matches schema.
+    try {
+      const assertInput = functionDef.inputSchema.pipe(Schema.asserts);
+      (assertInput as any)(input);
+    } catch (e) {
+      throw new FunctionError({ message: 'Invalid function input', context: { name: functionDef.name }, cause: e });
+    }
 
     const context: FunctionContext = {
+      space: undefined,
       getService: () => todo(),
       getSpace: async (_spaceId: any) => {
         throw new Error('Not available. Use the database service instead.');
       },
-      space: undefined,
-      get ai(): never {
-        throw new Error('Not available. Use the ai service instead.');
-      },
     };
 
+    log.info('invoking function', { name: functionDef.name, input });
+
     // TODO(dmaretskyi): This should be delegated to a function invoker service.
     const data = yield* Effect.gen(function* () {
-      const result = fnDef.handler({ context, data: input });
+      const result = functionDef.handler({ context, data: input });
       if (Effect.isEffect(result)) {
         return yield* (result as Effect.Effect<unknown, unknown, Services>).pipe(Effect.orDie);
       } else if (
@@ -58,13 +115,39 @@ const invokeFunction = (fnDef: FunctionDefinition<any, any>, input: any): Effect
     }).pipe(
       Effect.orDie,
       Effect.catchAllDefect((defect) =>
-        Effect.die(new FunctionError('Error running function', { context: { name: fnDef.name }, cause: defect })),
+        Effect.die(new FunctionError({ context: { name: functionDef.name }, cause: defect })),
       ),
     );
 
-    // Assert output matches schema
-    const assertOutput = fnDef.outputSchema?.pipe(Schema.asserts);
-    (assertOutput as any)(data);
+    log.info('completed', { function: functionDef.name, input, data });
+
+    // Assert output matches schema.
+    try {
+      const assertOutput = functionDef.outputSchema?.pipe(Schema.asserts);
+      (assertOutput as any)(data);
+    } catch (e) {
+      throw new FunctionError({ message: 'Invalid function output', context: { name: functionDef.name }, cause: e });
+    }
 
     return data;
-  }).pipe(Effect.withSpan('invokeFunction', { attributes: { name: fnDef.name } }));
+  }).pipe(Effect.withSpan('invokeFunction', { attributes: { name: functionDef.name } }));
+
+export class FunctionImplementationResolver extends Context.Tag('@dxos/functions/FunctionImplementationResolver')<
+  FunctionImplementationResolver,
+  {
+    resolveFunctionImplementation<I, O>(
+      functionDef: FunctionDefinition<I, O>,
+    ): Effect.Effect<FunctionDefinition<I, O>, FunctionNotFoundError>;
+  }
+>() {
+  static layerTest = ({ functions }: { functions: FunctionDefinition<any, any>[] }) =>
+    Layer.succeed(FunctionImplementationResolver, {
+      resolveFunctionImplementation: <I, O>(functionDef: FunctionDefinition<I, O>) => {
+        const resolved = functions.find((f) => f.key === functionDef.key);
+        if (!resolved) {
+          return Effect.fail(new FunctionNotFoundError(functionDef.name));
+        }
+        return Effect.succeed(resolved);
+      },
+    });
+}

package/src/services/queues.ts

@@ -2,9 +2,13 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context, Layer } from 'effect';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
 
+import type { Obj, Relation } from '@dxos/echo';
 import type { Queue, QueueAPI, QueueFactory } from '@dxos/echo-db';
+import type { DXN, QueueSubspaceTag } from '@dxos/keys';
 
 /**
  * Gives access to all queues.
@@ -21,30 +25,50 @@ export class QueueService extends Context.Tag('@dxos/functions/QueueService')<
      * The queue that is used to store the context of the current research.
      * @deprecated Use `ContextQueueService` instead.
      */
-    readonly contextQueue: Queue | undefined;
+    readonly queue: Queue | undefined;
   }
 >() {
   static notAvailable = Layer.succeed(QueueService, {
     queues: {
-      get(dxn) {
+      get(_dxn) {
         throw new Error('Queues not available');
       },
       create() {
         throw new Error('Queues not available');
       },
     },
-    contextQueue: undefined,
+    queue: undefined,
   });
 
-  static make = (queues: QueueFactory, contextQueue?: Queue): Context.Tag.Service<QueueService> => {
+  static make = (queues: QueueFactory, queue?: Queue): Context.Tag.Service<QueueService> => {
     return {
       queues,
-      contextQueue,
+      queue,
     };
   };
 
-  static makeLayer = (queues: QueueFactory, contextQueue?: Queue): Layer.Layer<QueueService> =>
-    Layer.succeed(QueueService, QueueService.make(queues, contextQueue));
+  static layer = (queues: QueueFactory, queue?: Queue): Layer.Layer<QueueService> =>
+    Layer.succeed(QueueService, QueueService.make(queues, queue));
+
+  /**
+   * Gets a queue by its DXN.
+   */
+  static getQueue = <T extends Obj.Any | Relation.Any = Obj.Any | Relation.Any>(
+    dxn: DXN,
+  ): Effect.Effect<Queue<T>, never, QueueService> => QueueService.pipe(Effect.map(({ queues }) => queues.get<T>(dxn)));
+
+  /**
+   * Creates a new queue.
+   */
+  static createQueue = <T extends Obj.Any | Relation.Any = Obj.Any | Relation.Any>(options?: {
+    subspaceTag?: QueueSubspaceTag;
+  }): Effect.Effect<Queue<T>, never, QueueService> =>
+    QueueService.pipe(Effect.map(({ queues }) => queues.create<T>(options)));
+
+  static append = <T extends Obj.Any | Relation.Any = Obj.Any | Relation.Any>(
+    queue: Queue<T>,
+    objects: T[],
+  ): Effect.Effect<void> => Effect.promise(() => queue.append(objects));
 }
 
 /**
@@ -53,6 +77,8 @@ export class QueueService extends Context.Tag('@dxos/functions/QueueService')<
 export class ContextQueueService extends Context.Tag('@dxos/functions/ContextQueueService')<
   ContextQueueService,
   {
-    readonly contextQueue: Queue;
+    readonly queue: Queue;
   }
->() {}
+>() {
+  static layer = (queue: Queue) => Layer.succeed(ContextQueueService, { queue });
+}

package/src/services/remote-function-execution-service.ts

@@ -2,65 +2,62 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context, Layer } from 'effect';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
 
 import type { SpaceId } from '@dxos/keys';
 
+import { FunctionError } from '../errors';
+import { getInvocationUrl } from '../url';
+
 /**
  * Allows calling into other functions.
  */
 export class RemoteFunctionExecutionService extends Context.Tag('@dxos/functions/RemoteFunctionExecutionService')<
   RemoteFunctionExecutionService,
   {
-    callFunction(deployedFunctionId: string, input: any, spaceId?: SpaceId): Promise<any>;
+    callFunction<I, O>(deployedFunctionId: string, input: I): Effect.Effect<O>;
   }
 >() {
-  static fromClient(baseUrl: string, spaceId: SpaceId): Context.Tag.Service<RemoteFunctionExecutionService> {
-    return {
-      callFunction: async (deployedFunctionId: string, input: any) => {
-        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();
-      },
-    };
+  /**
+   * @param baseUrl URL of the EDGE server.
+   * @param spaceId - The space ID to invoke the function in. If not provided, the function will be without space context.
+   * @returns
+   */
+  static fromClient(baseUrl: string, spaceId?: SpaceId): Layer.Layer<RemoteFunctionExecutionService> {
+    return Layer.succeed(RemoteFunctionExecutionService, {
+      callFunction: <I, O>(deployedFunctionId: string, input: I): Effect.Effect<O> =>
+        Effect.gen(function* () {
+          const url = getInvocationUrl(deployedFunctionId, baseUrl, { spaceId });
+          const result = yield* Effect.promise(() =>
+            fetch(url, {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify(input),
+            }),
+          );
+          if (result.status >= 300 || result.status < 200) {
+            const text = yield* Effect.promise(() => result.text());
+            return yield* Effect.die(
+              new FunctionError({
+                message: 'Failed to invoke function',
+                cause: new Error(`HTTP error: ${text}`),
+              }),
+            );
+          }
+          const data = (yield* Effect.promise(() => result.json())) as O;
+          return data;
+        }),
+    });
   }
 
   static mock = (): Context.Tag.Service<RemoteFunctionExecutionService> => {
     return {
-      callFunction: async (deployedFunctionId: string, input: any) => {
-        return input;
-      },
+      callFunction: <I, O>(deployedFunctionId: string, input: I): Effect.Effect<O> =>
+        Effect.succeed(input as unknown as O),
     };
   };
 
-  static mockLayer = Layer.succeed(RemoteFunctionExecutionService, RemoteFunctionExecutionService.mock());
+  static layerMock = Layer.succeed(RemoteFunctionExecutionService, RemoteFunctionExecutionService.mock());
 }
-
-// TODO(dmaretskyi): Reconcile with `getInvocationUrl` in `@dxos/functions/edge`.
-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();
-};
-
-const isSecure = (protocol: string) => {
-  return protocol === 'https:' || protocol === 'wss:';
-};
-
-type InvocationOptions = {
-  spaceId?: SpaceId;
-  subjectId?: string;
-};

package/src/services/service-container.ts

@@ -2,7 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Context, Layer } from 'effect';
+import type * as Context from 'effect/Context';
+import * as Layer from 'effect/Layer';
 
 import { AiService } from '@dxos/ai';
 import { entries } from '@dxos/util';
@@ -20,7 +21,7 @@ import { TracingService } from './tracing';
  * List of all services.
  */
 const SERVICES = {
-  ai: AiService,
+  ai: AiService.AiService,
   credentials: CredentialsService,
   database: DatabaseService,
   eventLogger: ComputeEventLogger,
@@ -88,9 +89,10 @@ export class 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.
+  // 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 ai =
+      this._services.ai != null ? Layer.succeed(AiService.AiService, this._services.ai) : AiService.notAvailable;
     const credentials = Layer.succeed(
       CredentialsService,
       this._services.credentials ?? new ConfiguredCredentialsService(),

package/src/services/service-registry.test.ts

@@ -3,7 +3,10 @@
 //
 
 import { describe, it } from '@effect/vitest';
-import { Context, Effect, Layer, Option } from 'effect';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Option from 'effect/Option';
 
 import { ServiceRegistry } from './service-registry';
 

package/src/services/service-registry.ts

@@ -2,7 +2,10 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context, Effect, flow, type Option } from 'effect';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Function from 'effect/Function';
+import type * as Option from 'effect/Option';
 
 import { ServiceNotAvailableError } from '../errors';
 
@@ -40,7 +43,8 @@ export class ServiceRegistry extends Context.Tag('@dxos/functions/ServiceRegistr
       E | ServiceNotAvailableError,
       Exclude<R, { [K in keyof Tags]: Context.Tag.Identifier<Tags[K]> }[number]> | ServiceRegistry
     >;
-  } = (...tags) => (flow as any)(...tags.map((tag) => Effect.provideServiceEffect(tag, ServiceRegistry.resolve(tag))));
+  } = (...tags) =>
+    (Function.flow as any)(...tags.map((tag) => Effect.provideServiceEffect(tag, ServiceRegistry.resolve(tag))));
 
   static provideOrDie: {
     <Tags extends [Context.Tag<any, any>, ...Context.Tag<any, any>[]]>(
@@ -53,7 +57,7 @@ export class ServiceRegistry extends Context.Tag('@dxos/functions/ServiceRegistr
       Exclude<R, { [K in keyof Tags]: Context.Tag.Identifier<Tags[K]> }[number]> | ServiceRegistry
     >;
   } = (...tags) =>
-    (flow as any)(
+    (Function.flow as any)(
       ...tags.map((tag) => Effect.provideServiceEffect(tag, ServiceRegistry.resolve(tag).pipe(Effect.orDie))),
     );
 }