@dxos/functions 0.8.4-main.5ea62a8 → 0.8.4-main.72ec0f3

package/src/bundler/index.ts

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

package/src/edge/functions.ts

@@ -1,67 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { type DID } from 'iso-did/types';
-
-import { type Client } from '@dxos/client';
-import { createEdgeIdentity } from '@dxos/client/edge';
-import { EdgeHttpClient } from '@dxos/edge-client';
-import { invariant } from '@dxos/invariant';
-import { type PublicKey } from '@dxos/keys';
-import { log } from '@dxos/log';
-import { type UploadFunctionResponseBody } from '@dxos/protocols';
-
-export type UploadWorkerArgs = {
-  client: Client;
-  version: string;
-  name?: string;
-  functionId?: string;
-  ownerPublicKey: PublicKey;
-  entryPoint: string;
-  assets: Record<string, Uint8Array>;
-};
-
-export const uploadWorkerFunction = async ({
-  client,
-  version,
-  name,
-  functionId,
-  ownerPublicKey,
-  entryPoint,
-  assets,
-}: UploadWorkerArgs): Promise<UploadFunctionResponseBody> => {
-  log('uploading function', { functionId, name, version, ownerPublicKey });
-  const edgeUrl = client.config.values.runtime?.services?.edge?.url;
-  invariant(edgeUrl, 'Edge is not configured.');
-  const edgeClient = new EdgeHttpClient(edgeUrl);
-  const edgeIdentity = createEdgeIdentity(client);
-  edgeClient.setIdentity(edgeIdentity);
-  const response = await edgeClient.uploadFunction(
-    { functionId },
-    { name, version, ownerPublicKey: ownerPublicKey.toHex(), entryPoint, assets },
-  );
-
-  // TODO(burdon): Edge service log.
-  log('uploaded', {
-    identityKey: edgeIdentity.identityKey,
-    functionId,
-    name,
-    version,
-    response,
-  });
-
-  return response;
-};
-
-export const incrementSemverPatch = (version: string): string => {
-  const [major, minor, patch] = version.split('.');
-  const patchNum = Number(patch);
-  invariant(!Number.isNaN(patchNum), `Unexpected function version format: ${version}`);
-  return [major, minor, String(patchNum + 1)].join('.');
-};
-
-// TODO(burdon): Factor out.
-export const publicKeyToDid = (key: PublicKey): DID => {
-  return `did:key:${key.toHex()}`;
-};

package/src/edge/index.ts

@@ -1,9 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-// NOTE: This module is separate because it uses the edge client.
-//  This means it cannot be used on edge itself.
-// TODO(wittjosiah): Factor out.
-
-export * from './functions';

package/src/executor/executor.ts

@@ -1,54 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Effect, Schema } from 'effect';
-
-import { type SpaceId } from '@dxos/client/echo';
-import { runAndForwardErrors } from '@dxos/effect';
-
-import type { FunctionContext, FunctionDefinition } from '../handler';
-import type { ServiceContainer, Services } from '../services';
-
-export class FunctionExecutor {
-  constructor(private readonly _services: ServiceContainer) {}
-
-  /**
-   * Invoke function.
-   */
-  // TODO(dmaretskyi): Invocation context: queue, space, etc...
-  async invoke<F extends FunctionDefinition<any, any>>(
-    functionDef: F,
-    input: F extends FunctionDefinition<infer I, infer _O> ? I : never,
-  ): Promise<F extends FunctionDefinition<infer _I, infer O> ? O : never> {
-    // Assert input matches schema
-    const assertInput = functionDef.inputSchema.pipe(Schema.asserts);
-    (assertInput as any)(input);
-
-    const context: FunctionContext = {
-      space: undefined,
-      getService: this._services.getService.bind(this._services),
-      getSpace: async (_spaceId: SpaceId) => {
-        throw new Error('Not available. Use the database service instead.');
-      },
-    };
-
-    const result = functionDef.handler({ context, data: input });
-
-    let data: unknown;
-    if (Effect.isEffect(result)) {
-      data = await (result as Effect.Effect<unknown, unknown, Services>).pipe(
-        Effect.provide(this._services.createLayer()),
-        runAndForwardErrors,
-      );
-    } else {
-      data = await result;
-    }
-
-    // Assert output matches schema
-    const assertOutput = functionDef.outputSchema?.pipe(Schema.asserts);
-    (assertOutput as any)(data);
-
-    return data as any;
-  }
-}

package/src/handler.ts

@@ -1,122 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import { type Context, type Effect, Schema } from 'effect';
-
-import { type EchoDatabase } from '@dxos/echo-db';
-import { type HasId } from '@dxos/echo-schema';
-import { type DXN, type SpaceId } from '@dxos/keys';
-import { type QueryResult } from '@dxos/protocols';
-
-import { type Services } from './services';
-
-// TODO(burdon): Model after http request. Ref Lambda/OpenFaaS.
-// https://docs.aws.amazon.com/lambda/latest/dg/typescript-handler.html
-// https://www.serverless.com/framework/docs/providers/aws/guide/serverless.yml/#functions
-// https://www.npmjs.com/package/aws-lambda
-
-/**
- * Function handler.
- */
-export type FunctionHandler<TData = {}, TOutput = any> = (params: {
-  /**
-   * Services and context available to the function.
-   */
-  context: FunctionContext;
-
-  /**
-   * Data passed as the input to the function.
-   * Must match the function's input schema.
-   * This will be the payload from the trigger or other data passed into the function in a workflow.
-   */
-  data: TData;
-}) => TOutput | Promise<TOutput> | Effect.Effect<TOutput, any, Services>;
-
-/**
- * Function context.
- */
-export interface FunctionContext {
-  /**
-   * Space from which the function was invoked.
-   */
-  space: SpaceAPI | undefined;
-
-  /**
-   * Resolves a service available to the function.
-   * @throws if the service is not available.
-   */
-  getService: <T extends Context.Tag<any, any>>(tag: T) => Context.Tag.Service<T>;
-
-  getSpace: (spaceId: SpaceId) => Promise<SpaceAPI>;
-}
-
-export interface FunctionContextAi {
-  // TODO(dmaretskyi): Refer to cloudflare AI docs for more comprehensive typedefs.
-  run(model: string, inputs: any, options?: any): Promise<any>;
-}
-
-//
-// API.
-//
-
-// TODO(dmaretskyi): Temporary API to get the queues working.
-// TODO(dmaretskyi): To be replaced with integrating queues into echo.
-export interface QueuesAPI {
-  queryQueue(queue: DXN, options?: {}): Promise<QueryResult>;
-  insertIntoQueue(queue: DXN, objects: HasId[]): Promise<void>;
-}
-
-/**
- * Space interface available to functions.
- */
-export interface SpaceAPI {
-  get id(): SpaceId;
-  get db(): EchoDatabase;
-
-  // TODO(dmaretskyi): Align with echo api: queues.get(id).append(items);
-  get queues(): QueuesAPI;
-}
-
-// TODO(wittjosiah): Queues are incompatible.
-const __assertFunctionSpaceIsCompatibleWithTheClientSpace = () => {
-  // const _: SpaceAPI = {} as Space;
-};
-
-export type FunctionDefinition<T = any, O = any> = {
-  // TODO(dmaretskyi): Use `key` for FQN and `name` for human-readable-name.
-  name: string;
-  description?: string;
-  inputSchema: Schema.Schema<T, any>;
-  outputSchema?: Schema.Schema<O, any>;
-  handler: FunctionHandler<T, O>;
-};
-
-export const defineFunction = <T, O>({
-  name,
-  description,
-  inputSchema,
-  outputSchema = Schema.Any,
-  handler,
-}: FunctionDefinition<T, O>): FunctionDefinition<T, O> => {
-  if (!Schema.isSchema(inputSchema)) {
-    throw new Error('Input schema must be a valid schema');
-  }
-  if (typeof handler !== 'function') {
-    throw new Error('Handler must be a function');
-  }
-
-  return {
-    name,
-    description,
-    inputSchema,
-    outputSchema,
-    handler,
-  };
-};
-
-export namespace FunctionDefinition {
-  export type Any = FunctionDefinition<any, any>;
-  export type Input<T extends FunctionDefinition> = T extends FunctionDefinition<infer I, any> ? I : never;
-  export type Output<T extends FunctionDefinition> = T extends FunctionDefinition<any, infer O> ? O : never;
-}

package/src/services/database.ts

@@ -1,170 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Context, Effect, Layer, Option, type Schema } from 'effect';
-
-import { type Filter, type Live, Obj, type Query, type Ref, type Relation, type Type } from '@dxos/echo';
-import type { EchoDatabase, FlushOptions, OneShotQueryResult, QueryResult, SchemaRegistryQuery } from '@dxos/echo-db';
-import type { SchemaRegistryPreparedQuery } from '@dxos/echo-db';
-import type { EchoSchema } from '@dxos/echo-schema';
-import { promiseWithCauseCapture } from '@dxos/effect';
-import { BaseError } from '@dxos/errors';
-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({ dxn: 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())),
-    );
-}
-
-// TODO(burdon): Move to echo/errors.
-class ObjectNotFoundError extends BaseError.extend('OBJECT_NOT_FOUND') {
-  constructor(context?: Record<string, unknown>) {
-    super('Object not found', { context });
-  }
-}

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

@@ -1,77 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Context, Effect, Layer, Schema } from 'effect';
-
-import { todo } from '@dxos/debug';
-
-import { FunctionError } from '../errors';
-import type { FunctionContext, FunctionDefinition } from '../handler';
-
-import type { Services } from './service-container';
-
-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(functionDef: FunctionDefinition<any, any>, input: unknown): Effect.Effect<unknown, never, Services>;
-  }
->() {
-  static layer = Layer.succeed(LocalFunctionExecutionService, {
-    invokeFunction: (functionDef, input) => invokeFunction(functionDef, input),
-  });
-
-  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
-    const assertInput = functionDef.inputSchema.pipe(Schema.asserts);
-    (assertInput as any)(input);
-
-    const context: FunctionContext = {
-      space: undefined,
-      getService: () => todo(),
-      getSpace: async (_spaceId: any) => {
-        throw new Error('Not available. Use the database service instead.');
-      },
-    };
-
-    // 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('Error running function', { context: { name: functionDef.name }, cause: defect })),
-      ),
-    );
-
-    // Assert output matches schema
-    const assertOutput = functionDef.outputSchema?.pipe(Schema.asserts);
-    (assertOutput as any)(data);
-
-    return data;
-  }).pipe(Effect.withSpan('invokeFunction', { attributes: { name: functionDef.name } }));

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

@@ -1,46 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Context, Layer } from 'effect';
-
-import type { SpaceId } from '@dxos/keys';
-
-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>;
-  }
->() {
-  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();
-      },
-    };
-  }
-
-  static mock = (): Context.Tag.Service<RemoteFunctionExecutionService> => {
-    return {
-      callFunction: async (deployedFunctionId: string, input: any) => {
-        return input;
-      },
-    };
-  };
-
-  static mockLayer = Layer.succeed(RemoteFunctionExecutionService, RemoteFunctionExecutionService.mock());
-}

package/src/services/service-container.ts

@@ -1,114 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type Context, Layer } from 'effect';
-
-import { AiService } from '@dxos/ai';
-import { entries } from '@dxos/util';
-
-import { ConfiguredCredentialsService, CredentialsService } from './credentials';
-import { DatabaseService } from './database';
-import { ComputeEventLogger } from './event-logger';
-import { QueueService } from './queues';
-import { RemoteFunctionExecutionService } from './remote-function-execution-service';
-import { TracingService } from './tracing';
-
-// TODO(dmaretskyi): Refactor this module to only rely on tags and not the human-assigned names.
-
-/**
- * List of all services.
- */
-const SERVICES = {
-  ai: AiService.AiService,
-  credentials: CredentialsService,
-  database: DatabaseService,
-  eventLogger: ComputeEventLogger,
-  functionCallService: RemoteFunctionExecutionService,
-  queues: QueueService,
-  tracing: TracingService,
-} as const satisfies Record<string, Context.TagClass<any, string, any>>;
-
-/**
- * Mapping of service names to their tags.
- */
-export type ServiceTagRecord = {
-  [K in keyof typeof SERVICES]: (typeof SERVICES)[K] extends { new (_: never): infer T } ? T : never;
-};
-
-/**
- * Mapping of service names to their runtime types.
- */
-export type ServiceRecord = {
-  [K in keyof ServiceTagRecord]: Context.Tag.Service<ServiceTagRecord[K]>;
-};
-
-/**
- * Union of all services tags.
- */
-export type Services = ServiceTagRecord[keyof ServiceTagRecord];
-
-const SERVICE_MAPPING: Record<string, keyof ServiceRecord> = Object.fromEntries(
-  entries(SERVICES).map(([name, tag]) => [tag.key, name]),
-);
-
-export const SERVICE_TAGS: Context.Tag<any, any>[] = Object.values(SERVICES);
-
-const DEFAULT_SERVICES: Partial<ServiceRecord> = {
-  tracing: TracingService.noop,
-};
-
-/**
- * @deprecated
- */
-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<Id, T>(tag: Context.Tag<Id, T>): 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 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.AiService, this._services.ai) : AiService.notAvailable;
-    const credentials = Layer.succeed(
-      CredentialsService,
-      this._services.credentials ?? 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(ComputeEventLogger, this._services.eventLogger ?? ComputeEventLogger.noop);
-    const functionCallService = Layer.succeed(
-      RemoteFunctionExecutionService,
-      this._services.functionCallService ?? RemoteFunctionExecutionService.mock(),
-    );
-
-    return Layer.mergeAll(ai, credentials, database, queues, tracing, eventLogger, functionCallService);
-  }
-}