@dxos/functions 0.8.4-main.5ea62a8 → 0.8.4-main.66e292d

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);
-  }
-}

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

@@ -1,42 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { describe, it } from '@effect/vitest';
-import { Context, Effect, Layer, Option } from 'effect';
-
-import { ServiceRegistry } from './service-registry';
-
-class MyTag extends Context.Tag('MyTag')<MyTag, { value: string }>() {}
-
-const mockRegistry = Layer.succeed(ServiceRegistry, {
-  resolve: (tag) => ((tag as any) === MyTag ? Option.some({ value: 'test' } as any) : Option.none()),
-});
-
-describe('ServiceRegistry', () => {
-  it.effect(
-    'provide',
-    Effect.fn(function* ({ expect }) {
-      const body = Effect.gen(function* () {
-        const { value } = yield* MyTag;
-        expect(value).toEqual('test');
-      });
-
-      const eff = body.pipe(ServiceRegistry.provide(MyTag));
-      yield* eff;
-    }, Effect.provide(mockRegistry)),
-  );
-
-  it.effect(
-    'provide or die',
-    Effect.fn(function* ({ expect }) {
-      const body = Effect.gen(function* () {
-        const { value } = yield* MyTag;
-        expect(value).toEqual('test');
-      });
-
-      const eff = body.pipe(ServiceRegistry.provideOrDie(MyTag));
-      yield* eff;
-    }, Effect.provide(mockRegistry)),
-  );
-});

package/src/services/service-registry.ts

@@ -1,59 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Context, Effect, type Option, flow } from 'effect';
-
-import { ServiceNotAvailableError } from '../errors';
-
-export namespace ServiceRegistry {
-  export interface Service {
-    resolve: <T extends Context.Tag<any, any>>(tag: T) => Option.Option<Context.Tag.Service<T>>;
-  }
-}
-
-export class ServiceRegistry extends Context.Tag('@dxos/functions/ServiceRegistry')<
-  ServiceRegistry,
-  ServiceRegistry.Service
->() {
-  /**
-   * Resolves the service from the registry.
-   * @param tag Service tag to resolve.
-   * @throws {@link ServiceNotAvailableError} if the service is not found.
-   * @returns Effect that resolve to the service.
-   */
-  static resolve: <T extends Context.Tag<any, any>>(
-    tag: T,
-  ) => Effect.Effect<T, ServiceNotAvailableError, ServiceRegistry> = (tag) =>
-    ServiceRegistry.pipe(
-      Effect.flatMap((_) => _.resolve(tag)),
-      Effect.mapError(() => new ServiceNotAvailableError(tag.key)),
-    );
-
-  static provide: {
-    <Tags extends [Context.Tag<any, any>, ...Context.Tag<any, any>[]]>(
-      ...tags: Tags
-    ): <A, E, R>(
-      effect: Effect.Effect<A, E, R>,
-    ) => Effect.Effect<
-      A,
-      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))));
-
-  static provideOrDie: {
-    <Tags extends [Context.Tag<any, any>, ...Context.Tag<any, any>[]]>(
-      ...tags: Tags
-    ): <A, E, R>(
-      effect: Effect.Effect<A, E, R>,
-    ) => Effect.Effect<
-      A,
-      E,
-      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).pipe(Effect.orDie))),
-    );
-}

package/src/testing/index.ts

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

package/src/testing/layer.ts

@@ -1,97 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import type { Schema } from 'effect';
-import { Context, Effect, Layer } from 'effect';
-
-import type { EchoDatabaseImpl, QueueFactory } from '@dxos/echo-db';
-import { EchoTestBuilder } from '@dxos/echo-db/testing';
-import type { EchoHostIndexingConfig } from '@dxos/echo-pipeline';
-import { accuireReleaseResource } from '@dxos/effect';
-import { PublicKey } from '@dxos/keys';
-import type { LevelDB } from '@dxos/kv-store';
-import { createTestLevel } from '@dxos/kv-store/testing';
-import { log } from '@dxos/log';
-
-import { DatabaseService, QueueService } from '../services';
-
-const testBuilder = accuireReleaseResource(() => new EchoTestBuilder());
-
-export const testStoragePath = ({ name = PublicKey.random().toHex() }: { name?: string }) => {
-  return `/tmp/dxos-${name}`;
-};
-
-export type TestDatabaseOptions = {
-  indexing?: Partial<EchoHostIndexingConfig>;
-  types?: Schema.Schema.AnyNoContext[];
-  storagePath?: string;
-};
-
-export const TestDatabaseLayer = ({ indexing, types, storagePath }: TestDatabaseOptions = {}) =>
-  Layer.scopedContext(
-    Effect.gen(function* () {
-      const builder = yield* testBuilder;
-
-      let kv: LevelDB | undefined;
-      if (storagePath) {
-        kv = createTestLevel(storagePath);
-        yield* Effect.promise(() => kv!.open());
-        // const keyCount = yield* Effect.promise(async () => (await kv!.iterator({ values: false }).all()).length);
-        // log.info('opened test db', { storagePath, keyCount });
-      }
-      const peer = yield* Effect.promise(() => builder.createPeer({ indexing, types, kv }));
-
-      let db: EchoDatabaseImpl | undefined;
-      let queues: QueueFactory | undefined;
-
-      if (storagePath) {
-        const testMetadata = yield* Effect.promise(async () => {
-          try {
-            return await kv!.get('test-metadata', { valueEncoding: 'json' });
-          } catch (e) {
-            if ((e as any).code === 'LEVEL_NOT_FOUND') {
-              return undefined;
-            }
-            throw e;
-          }
-        });
-        log('starting persistant test db', { storagePath, testMetadata });
-        if (!testMetadata) {
-          const key = PublicKey.random();
-          db = yield* Effect.promise(() => peer.createDatabase(key));
-          queues = peer.client.constructQueueFactory(db.spaceId);
-
-          yield* Effect.promise(() =>
-            kv!.put('test-metadata', { key: key.toHex(), rootUrl: db!.rootUrl }, { valueEncoding: 'json' }),
-          );
-        } else {
-          const key = PublicKey.from((testMetadata as any).key);
-          const rootUrl = (testMetadata as any).rootUrl;
-          db = yield* Effect.promise(() => peer.openDatabase(key, rootUrl));
-          queues = peer.client.constructQueueFactory(db.spaceId);
-        }
-      } else {
-        db = yield* Effect.promise(() => peer.createDatabase());
-        queues = peer.client.constructQueueFactory(db.spaceId);
-      }
-
-      yield* Effect.addFinalizer(() =>
-        Effect.promise(async () => {
-          if (kv) {
-            // {
-            //   const keyCount = (await kv.iterator({ values: false }).all()).length;
-            //   log.info('closing persistant test db', { storagePath, keyCount });
-            // }
-
-            await kv.close();
-          }
-        }),
-      );
-
-      return Context.mergeAll(
-        Context.make(DatabaseService, DatabaseService.make(db)),
-        Context.make(QueueService, QueueService.make(queues, undefined)),
-      );
-    }),
-  );

package/src/testing/logger.ts

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

package/src/testing/persist-database.test.ts

@@ -1,87 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { describe, expect, it } from '@effect/vitest';
-import { Effect } from 'effect';
-
-import { Filter, Obj, Query, Type } from '@dxos/echo';
-import { DataType } from '@dxos/schema';
-
-import { DatabaseService } from '../services';
-
-import { TestDatabaseLayer, testStoragePath } from './layer';
-
-describe('TestDatabaseLayer', { timeout: 600_000 }, () => {
-  it.effect(
-    'persist database to disk',
-    Effect.fnUntraced(function* ({ expect: _ }) {
-      const DbLayer = TestDatabaseLayer({
-        storagePath: testStoragePath({ name: `feed-test-${Date.now()}` }),
-      });
-
-      yield* Effect.gen(function* () {
-        yield* DatabaseService.add(Obj.make(Type.Expando, { label: 'test' }));
-        yield* DatabaseService.flush({ indexes: true });
-      }).pipe(Effect.provide(DbLayer));
-
-      yield* Effect.gen(function* () {
-        const { objects } = yield* DatabaseService.runQuery(Query.select(Filter.everything()));
-        expect(objects[0]?.label).toEqual('test');
-      }).pipe(Effect.provide(DbLayer));
-    }),
-  );
-
-  it.effect(
-    'reload database -- save index before restart',
-    Effect.fnUntraced(function* ({ expect: _ }) {
-      const NUM_OBJECTS = 500;
-      const DbLayer = TestDatabaseLayer({
-        types: [DataType.Person],
-        storagePath: testStoragePath({ name: `reload-test-${Date.now()}` }),
-      });
-
-      yield* Effect.gen(function* () {
-        for (let i = 0; i < NUM_OBJECTS; i++) {
-          yield* DatabaseService.add(Obj.make(DataType.Person, { nickname: `Person ${i}` }));
-        }
-        yield* DatabaseService.flush({ indexes: true });
-      }).pipe(Effect.provide(DbLayer));
-
-      yield* Effect.gen(function* () {
-        const { objects } = yield* DatabaseService.runQuery(Query.select(Filter.type(DataType.Person)));
-        expect(objects.length).toEqual(NUM_OBJECTS);
-      }).pipe(Effect.provide(DbLayer));
-    }),
-  );
-
-  it.effect.skip(
-    'reload database -- save index before restart [manual]',
-    Effect.fnUntraced(
-      function* ({ expect: _ }) {
-        const NUM_OBJECTS = 500;
-
-        {
-          const { objects } = yield* DatabaseService.runQuery(Query.select(Filter.type(DataType.Person)));
-          console.log({ count: objects.length });
-        }
-
-        for (let i = 0; i < NUM_OBJECTS; i++) {
-          yield* DatabaseService.add(Obj.make(DataType.Person, { nickname: `Person ${i}` }));
-        }
-        yield* DatabaseService.flush({ indexes: true });
-
-        {
-          const { objects } = yield* DatabaseService.runQuery(Query.select(Filter.type(DataType.Person)));
-          console.log({ count: objects.length });
-        }
-      },
-      Effect.provide(
-        TestDatabaseLayer({
-          types: [DataType.Person],
-          storagePath: testStoragePath({ name: `reload-test` }),
-        }),
-      ),
-    ),
-  );
-});

package/src/testing/services.ts

@@ -1,115 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type Context } from 'effect';
-
-import type { Space } from '@dxos/client/echo';
-import type { EchoDatabase, QueueFactory } from '@dxos/echo-db';
-import { assertArgument } from '@dxos/invariant';
-
-import {
-  type ComputeEventLogger,
-  ConfiguredCredentialsService,
-  type CredentialsService,
-  DatabaseService,
-  QueueService,
-  ServiceContainer,
-  type ServiceCredential,
-  type TracingService,
-} from '../services';
-
-import { consoleLogger, noopLogger } from './logger';
-
-// TODO(burdon): Factor out.
-export type OneOf<T> = {
-  [K in keyof T]: { [P in K]: T[P] } & { [P in Exclude<keyof T, K>]?: never };
-}[keyof T];
-
-export type AiServiceProvider = 'dev' | 'edge' | 'ollama' | 'lmstudio';
-
-export type TestServiceOptions = {
-  /**
-   * AI service configuration.
-   */
-  ai?: any;
-
-  /**
-   * Credentials service configuration.
-   */
-  credentials?: OneOf<{
-    /**
-     * Predefined credentials list.
-     */
-    services?: ServiceCredential[];
-
-    /**
-     * Custom credentials service.
-     */
-    service?: Context.Tag.Service<CredentialsService>;
-  }>;
-
-  /**
-   * Database configuration.
-   */
-  db?: EchoDatabase;
-
-  /**
-   * Gets database and queue services from the space.
-   * Exclusive with: `db`, `queues`
-   */
-  space?: Space;
-
-  /**
-   * Logging configuration.
-   */
-  logging?: {
-    enabled?: boolean;
-    logger?: Context.Tag.Service<ComputeEventLogger>;
-  };
-
-  /**
-   * Queue service configuration.
-   */
-  queues?: QueueFactory;
-
-  tracing?: {
-    service?: Context.Tag.Service<TracingService>;
-  };
-};
-
-/**
- * @deprecated
- */
-export const createTestServices = ({
-  ai,
-  credentials,
-  db,
-  logging,
-  queues,
-  space,
-  tracing,
-}: TestServiceOptions = {}): ServiceContainer => {
-  assertArgument(!(!!space && (!!db || !!queues)), 'space can be provided only if db and queues are not');
-
-  return new ServiceContainer().setServices({
-    // ai: createAiService(ai),
-    credentials: createCredentialsService(credentials),
-    database: space || db ? DatabaseService.make(space?.db || db!) : undefined,
-    eventLogger: (logging?.logger ?? logging?.enabled) ? consoleLogger : noopLogger,
-    queues: space || queues ? QueueService.make(space?.queues || queues!, undefined) : undefined,
-    tracing: tracing?.service,
-  });
-};
-
-const createCredentialsService = (
-  credentials: TestServiceOptions['credentials'] | undefined,
-): Context.Tag.Service<CredentialsService> | undefined => {
-  if (credentials?.services) {
-    return new ConfiguredCredentialsService(credentials.services);
-  }
-
-  if (credentials?.service) {
-    return credentials.service;
-  }
-};