@dxos/functions 0.8.4-main.ead640a → 0.8.4-main.f466a3d56e

package/src/services/database.ts

@@ -1,175 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-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 type * as Schema from 'effect/Schema';
-
-import {
-  type Filter,
-  type Live,
-  Obj,
-  ObjectNotFoundError,
-  type Query,
-  type Ref,
-  type Relation,
-  type Type,
-} from '@dxos/echo';
-import type { EchoSchema } from '@dxos/echo/internal';
-import type { EchoDatabase, FlushOptions, OneShotQueryResult, QueryResult, SchemaRegistryQuery } from '@dxos/echo-db';
-import type { SchemaRegistryPreparedQuery } from '@dxos/echo-db';
-import { promiseWithCauseCapture } from '@dxos/effect';
-import { invariant } from '@dxos/invariant';
-import type { DXN } from '@dxos/keys';
-
-export class DatabaseService extends Context.Tag('@dxos/functions/DatabaseService')<
-  DatabaseService,
-  {
-    readonly db: EchoDatabase;
-  }
->() {
-  static notAvailable = Layer.succeed(DatabaseService, {
-    get db(): EchoDatabase {
-      throw new Error('Database not available');
-    },
-  });
-
-  static make = (db: EchoDatabase): Context.Tag.Service<DatabaseService> => {
-    return {
-      get db() {
-        return db;
-      },
-    };
-  };
-
-  static layer = (db: EchoDatabase): Layer.Layer<DatabaseService> => {
-    return Layer.succeed(DatabaseService, DatabaseService.make(db));
-  };
-
-  /**
-   * Resolves an object by its DXN.
-   */
-  static resolve: {
-    // No type check.
-    (dxn: DXN): Effect.Effect<Obj.Any | Relation.Any, never, DatabaseService>;
-    // Check matches schema.
-    <S extends Type.Obj.Any | Type.Relation.Any>(
-      dxn: DXN,
-      schema: S,
-    ): Effect.Effect<Schema.Schema.Type<S>, ObjectNotFoundError, DatabaseService>;
-  } = (<S extends Type.Obj.Any | Type.Relation.Any>(
-    dxn: DXN,
-    schema?: S,
-  ): Effect.Effect<Schema.Schema.Type<S>, ObjectNotFoundError, DatabaseService> =>
-    Effect.gen(function* () {
-      const { db } = yield* DatabaseService;
-      const object = yield* promiseWithCauseCapture(() =>
-        db.graph
-          .createRefResolver({
-            context: {
-              space: db.spaceId,
-            },
-          })
-          .resolve(dxn),
-      );
-
-      if (!object) {
-        return yield* Effect.fail(new ObjectNotFoundError(dxn));
-      }
-      invariant(!schema || Obj.instanceOf(schema, object), 'Object type mismatch.');
-      return object as any;
-    })) as any;
-
-  /**
-   * Loads an object reference.
-   */
-  static load: <T>(ref: Ref.Ref<T>) => Effect.Effect<T, ObjectNotFoundError, never> = Effect.fn(function* (ref) {
-    const object = yield* promiseWithCauseCapture(() => ref.tryLoad());
-    if (!object) {
-      return yield* Effect.fail(new ObjectNotFoundError(ref.dxn));
-    }
-    return object;
-  });
-
-  /**
-   * Loads an object reference option.
-   */
-  // TODO(burdon): Option?
-  static loadOption: <T>(ref: Ref.Ref<T>) => Effect.Effect<Option.Option<T>, never, never> = Effect.fn(function* (ref) {
-    const object = yield* DatabaseService.load(ref).pipe(
-      Effect.catchTag('OBJECT_NOT_FOUND', () => Effect.succeed(undefined)),
-    );
-    return Option.fromNullable(object);
-  });
-
-  // TODO(burdon): Can we create a proxy for the following methods on EchoDatabase? Use @inheritDoc?
-  // TODO(burdon): Figure out how to chain query().run();
-
-  /**
-   * @link EchoDatabase.add
-   */
-  static add = <T extends Obj.Any | Relation.Any>(obj: T): Effect.Effect<T, never, DatabaseService> =>
-    DatabaseService.pipe(Effect.map(({ db }) => db.add(obj)));
-
-  /**
-   * @link EchoDatabase.remove
-   */
-  static remove = <T extends Obj.Any | Relation.Any>(obj: T): Effect.Effect<void, never, DatabaseService> =>
-    DatabaseService.pipe(Effect.map(({ db }) => db.remove(obj)));
-
-  /**
-   * @link EchoDatabase.flush
-   */
-  static flush = (opts?: FlushOptions) =>
-    DatabaseService.pipe(Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.flush(opts))));
-
-  /**
-   * @link EchoDatabase.getObjectById
-   */
-  static getObjectById = <T extends Obj.Any | Relation.Any>(
-    id: string,
-  ): Effect.Effect<Live<T> | undefined, never, DatabaseService> => {
-    return DatabaseService.pipe(Effect.map(({ db }) => db.getObjectById(id)));
-  };
-
-  /**
-   * Creates a `QueryResult` object that can be subscribed to.
-   */
-  static query: {
-    <Q extends Query.Any>(query: Q): Effect.Effect<QueryResult<Live<Query.Type<Q>>>, never, DatabaseService>;
-    <F extends Filter.Any>(filter: F): Effect.Effect<QueryResult<Live<Filter.Type<F>>>, never, DatabaseService>;
-  } = (queryOrFilter: Query.Any | Filter.Any) =>
-    DatabaseService.pipe(
-      Effect.map(({ db }) => db.query(queryOrFilter as any)),
-      Effect.withSpan('DatabaseService.query'),
-    );
-
-  /**
-   * Executes the query once and returns the results.
-   */
-  static runQuery: {
-    <Q extends Query.Any>(query: Q): Effect.Effect<OneShotQueryResult<Live<Query.Type<Q>>>, never, DatabaseService>;
-    <F extends Filter.Any>(filter: F): Effect.Effect<OneShotQueryResult<Live<Filter.Type<F>>>, never, DatabaseService>;
-  } = (queryOrFilter: Query.Any | Filter.Any) =>
-    DatabaseService.query(queryOrFilter as any).pipe(
-      Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())),
-    );
-
-  static schemaQuery = <Q extends SchemaRegistryQuery>(
-    query: Q,
-  ): Effect.Effect<SchemaRegistryPreparedQuery<EchoSchema>, never, DatabaseService> =>
-    DatabaseService.pipe(
-      Effect.map(({ db }) => db.schemaRegistry.query(query)),
-      Effect.withSpan('DatabaseService.schemaQuery'),
-    );
-
-  static runSchemaQuery = <Q extends SchemaRegistryQuery>(
-    query: Q,
-  ): Effect.Effect<EchoSchema[], never, DatabaseService> =>
-    DatabaseService.schemaQuery(query).pipe(
-      Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())),
-    );
-}

package/src/services/event-logger.ts

@@ -1,121 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-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 { Obj, Type } from '@dxos/echo';
-import { invariant } from '@dxos/invariant';
-import { LogLevel, log } from '@dxos/log';
-
-import { TracingService } from './tracing';
-
-export const ComputeEventPayload = Schema.Union(
-  Schema.Struct({
-    type: Schema.Literal('begin-compute'),
-    nodeId: Schema.String,
-    inputs: Schema.Record({ key: Schema.String, value: Schema.Any }),
-  }),
-  Schema.Struct({
-    type: Schema.Literal('end-compute'),
-    nodeId: Schema.String,
-    outputs: Schema.Record({ key: Schema.String, value: Schema.Any }),
-  }),
-  Schema.Struct({
-    type: Schema.Literal('compute-input'),
-    nodeId: Schema.String,
-    property: Schema.String,
-    value: Schema.Any,
-  }),
-  Schema.Struct({
-    type: Schema.Literal('compute-output'),
-    nodeId: Schema.String,
-    property: Schema.String,
-    value: Schema.Any,
-  }),
-  Schema.Struct({
-    type: Schema.Literal('custom'),
-    nodeId: Schema.String,
-    event: Schema.Any,
-  }),
-);
-export type ComputeEventPayload = Schema.Schema.Type<typeof ComputeEventPayload>;
-
-export const ComputeEvent = Schema.Struct({
-  payload: ComputeEventPayload,
-}).pipe(Type.Obj({ typename: 'dxos.org/type/ComputeEvent', version: '0.1.0' }));
-
-/**
- * Logs event for the compute workflows.
- */
-export class ComputeEventLogger extends Context.Tag('@dxos/functions/ComputeEventLogger')<
-  ComputeEventLogger,
-  { readonly log: (event: ComputeEventPayload) => void; readonly nodeId: string | undefined }
->() {
-  static noop: Context.Tag.Service<ComputeEventLogger> = {
-    log: () => {},
-    nodeId: undefined,
-  };
-
-  /**
-   * Implements ComputeEventLogger using TracingService.
-   */
-  static layerFromTracing = Layer.effect(
-    ComputeEventLogger,
-    Effect.gen(function* () {
-      const tracing = yield* TracingService;
-      return {
-        log: (event: ComputeEventPayload) => {
-          tracing.write(Obj.make(ComputeEvent, { payload: event }));
-        },
-        nodeId: undefined,
-      };
-    }),
-  );
-}
-
-export const logCustomEvent = (data: any) =>
-  Effect.gen(function* () {
-    const logger = yield* ComputeEventLogger;
-    if (!logger.nodeId) {
-      throw new Error('logCustomEvent must be called within a node compute function');
-    }
-    logger.log({
-      type: 'custom',
-      nodeId: logger.nodeId,
-      event: data,
-    });
-  });
-
-export const createDefectLogger = <A, E, R>(): ((self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>) =>
-  Effect.catchAll((error) =>
-    Effect.gen(function* () {
-      log.error('unhandled effect error', { error });
-      throw error;
-    }),
-  );
-
-export const createEventLogger = (
-  level: LogLevel,
-  message: string = 'event',
-): Context.Tag.Service<ComputeEventLogger> => {
-  const logFunction = (
-    {
-      [LogLevel.WARN]: log.warn,
-      [LogLevel.VERBOSE]: log.verbose,
-      [LogLevel.DEBUG]: log.debug,
-      [LogLevel.INFO]: log.info,
-      [LogLevel.ERROR]: log.error,
-    } as any
-  )[level];
-  invariant(logFunction);
-  return {
-    log: (event: ComputeEventPayload) => {
-      logFunction(message, event);
-    },
-    nodeId: undefined,
-  };
-};

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

@@ -1,81 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { describe, expect, it } from '@effect/vitest';
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-import * as Schema from 'effect/Schema';
-
-import { AiService } from '@dxos/ai';
-
-import { defineFunction } from '../handler';
-import { TestDatabaseLayer } from '../testing';
-
-import { FunctionInvocationService } from './function-invocation-service';
-import { FunctionImplementationResolver } from './local-function-execution';
-
-const TestLayer = Layer.mergeAll(AiService.model('@anthropic/claude-opus-4-0')).pipe(
-  Layer.provideMerge(
-    Layer.mergeAll(
-      TestDatabaseLayer({
-        indexing: { vector: true },
-        types: [],
-      }),
-      FunctionInvocationService.layer,
-    ),
-  ),
-);
-
-describe('FunctionInvocationService', () => {
-  it(
-    'should be defined',
-    Effect.fnUntraced(function* () {
-      const service = yield* FunctionInvocationService;
-      expect(service).toBeDefined();
-    }, Effect.provide(TestLayer)),
-  );
-
-  it(
-    'routes to local when implementation is available',
-    Effect.fnUntraced(function* () {
-      const add = defineFunction({
-        key: 'example.org/function/add',
-        name: 'add',
-        inputSchema: Schema.Struct({ a: Schema.Number, b: Schema.Number }),
-        outputSchema: Schema.Number,
-        handler: ({ data }) => data.a + data.b,
-      });
-
-      const layer = TestLayer.pipe(Layer.provideMerge(FunctionImplementationResolver.layerTest({ functions: [add] })));
-
-      const result = yield* Effect.gen(function* () {
-        return yield* FunctionInvocationService.invokeFunction(add, { a: 2, b: 3 });
-      }).pipe(Effect.provide(layer));
-
-      expect(result).toEqual(5);
-    }),
-  );
-
-  it(
-    'routes to remote when no local implementation is found',
-    Effect.fnUntraced(function* () {
-      // This function is not deployed, so mock layer will be used.
-      const echo = defineFunction({
-        key: 'example.org/function/echo',
-        name: 'function-that-is-deployed',
-        inputSchema: Schema.Unknown,
-        outputSchema: Schema.Unknown,
-        handler: () => {},
-      });
-
-      // No resolver provided → resolveFunctionImplementation will fail → remote path is used.
-      const result = yield* Effect.gen(function* () {
-        return yield* FunctionInvocationService.invokeFunction(echo, { hello: 'world' });
-      }).pipe(Effect.provide(TestLayer));
-
-      // RemoteFunctionExecutionService.mock echos input back.
-      expect(result).toEqual({ hello: 'world', resolved: 'remote' });
-    }),
-  );
-});

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

@@ -1,153 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-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 { 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<I, O>(functionDef: FunctionDefinition<I, O>, input: I): Effect.Effect<O, never, InvocationServices>;
-  }
->() {
-  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 = (
-  functionDef: FunctionDefinition<any, any>,
-  input: any,
-): Effect.Effect<unknown, never, Services> =>
-  Effect.gen(function* () {
-    // 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.');
-      },
-    };
-
-    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 = functionDef.handler({ context, data: input });
-      if (Effect.isEffect(result)) {
-        return yield* (result as Effect.Effect<unknown, unknown, Services>).pipe(Effect.orDie);
-      } else if (
-        typeof result === 'object' &&
-        result !== null &&
-        'then' in result &&
-        typeof result.then === 'function'
-      ) {
-        return yield* Effect.promise(() => result);
-      } else {
-        return result;
-      }
-    }).pipe(
-      Effect.orDie,
-      Effect.catchAllDefect((defect) =>
-        Effect.die(new FunctionError({ context: { name: functionDef.name }, cause: defect })),
-      ),
-    );
-
-    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: 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/remote-function-execution-service.ts

@@ -1,63 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-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<I, O>(deployedFunctionId: string, input: I): Effect.Effect<O>;
-  }
->() {
-  /**
-   * @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: <I, O>(deployedFunctionId: string, input: I): Effect.Effect<O> =>
-        Effect.succeed(input as unknown as O),
-    };
-  };
-
-  static layerMock = Layer.succeed(RemoteFunctionExecutionService, RemoteFunctionExecutionService.mock());
-}