@dxos/effect 0.8.3 → 0.8.4-main.16b68245aa

package/src/layers.test.ts

@@ -0,0 +1,112 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { it } from '@effect/vitest';
+import * as Context from 'effect/Context';
+import * as Duration from 'effect/Duration';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as ManagedRuntime from 'effect/ManagedRuntime';
+import { test } from 'vitest';
+
+import { runAndForwardErrors } from './errors';
+
+class ClientConfig extends Context.Tag('ClientConfig')<ClientConfig, { endpoint: string }>() {}
+
+class Client extends Context.Tag('Client')<Client, { call: () => Effect.Effect<void> }>() {
+  static layer = Layer.effect(
+    Client,
+    Effect.gen(function* () {
+      const config = yield* ClientConfig;
+      return {
+        call: () => {
+          console.log('called', config.endpoint);
+          return Effect.void;
+        },
+      };
+    }),
+  );
+}
+
+const ServerLive = Layer.scoped(
+  ClientConfig,
+  Effect.gen(function* () {
+    console.log('start server');
+
+    yield* Effect.sleep(Duration.millis(100));
+
+    yield* Effect.addFinalizer(
+      Effect.fn(function* () {
+        yield* Effect.sleep(Duration.millis(100));
+        console.log('stop server');
+      }),
+    );
+
+    return {
+      endpoint: 'http://localhost:8080',
+    };
+  }),
+);
+
+it.effect.skip(
+  'test',
+  Effect.fn(
+    function* (_) {
+      const client = yield* Client;
+      yield* client.call();
+    },
+    Effect.provide(Layer.provide(Client.layer, ServerLive)),
+  ),
+);
+
+class ServerPlugin {
+  #runtime = ManagedRuntime.make(ServerLive);
+
+  readonly clientConfigLayer = Layer.effectContext(
+    this.#runtime.runtimeEffect.pipe(Effect.map((rt) => rt.context.pipe(Context.pick(ClientConfig)))),
+  );
+
+  async dispose() {
+    await this.#runtime.dispose();
+  }
+}
+
+class ClientPlugin {
+  constructor(private readonly _serverPlugin: ServerPlugin) {}
+
+  async run() {
+    const layer = Layer.provide(Client.layer, this._serverPlugin.clientConfigLayer);
+
+    await runAndForwardErrors(
+      Effect.gen(function* () {
+        const client = yield* Client;
+        yield* client.call();
+      }).pipe(Effect.provide(layer)),
+    );
+  }
+}
+
+test.skip('plugins', async () => {
+  const serverPlugin = new ServerPlugin();
+  console.log('ServerPlugin created');
+
+  await runAndForwardErrors(Effect.sleep(Duration.millis(500)));
+  console.log('wake up');
+
+  {
+    const clientPlugin1 = new ClientPlugin(serverPlugin);
+    console.log('ClientPlugin1 created');
+    await clientPlugin1.run();
+    console.log('client1 run');
+  }
+
+  {
+    const clientPlugin2 = new ClientPlugin(serverPlugin);
+    console.log('ClientPlugin2 created');
+    await clientPlugin2.run();
+    console.log('client2 run');
+  }
+
+  await serverPlugin.dispose();
+});

package/src/otel.test.ts

@@ -0,0 +1,126 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { afterAll, beforeAll, it } from '@effect/vitest';
+import { SpanStatusCode, trace } from '@opentelemetry/api';
+import { type Logger, SeverityNumber, logs } from '@opentelemetry/api-logs';
+import { resourceFromAttributes } from '@opentelemetry/resources';
+import { ConsoleLogRecordExporter, LoggerProvider, SimpleLogRecordProcessor } from '@opentelemetry/sdk-logs';
+import { NodeSDK } from '@opentelemetry/sdk-node';
+import { ConsoleSpanExporter } from '@opentelemetry/sdk-trace-node';
+import {
+  ATTR_CODE_FILE_PATH,
+  ATTR_CODE_LINE_NUMBER,
+  ATTR_CODE_STACKTRACE,
+  ATTR_SERVICE_NAME,
+} from '@opentelemetry/semantic-conventions';
+import * as Duration from 'effect/Duration';
+import * as Effect from 'effect/Effect';
+import { beforeEach } from 'vitest';
+
+import { LogLevel, type LogProcessor, log } from '@dxos/log';
+
+import { layerOtel } from './otel';
+
+const resource = resourceFromAttributes({
+  [ATTR_SERVICE_NAME]: 'test',
+});
+
+const sdk = new NodeSDK({
+  traceExporter: new ConsoleSpanExporter(),
+  resource,
+});
+
+// and add a processor to export log record
+const loggerProvider = new LoggerProvider({
+  processors: [new SimpleLogRecordProcessor(new ConsoleLogRecordExporter())],
+  resource,
+});
+logs.setGlobalLoggerProvider(loggerProvider);
+
+// You can also use global singleton
+const logger = logs.getLogger('test');
+
+const makeOtelLogProcessor = (logger: Logger): LogProcessor => {
+  return (config, entry) => {
+    let severity: SeverityNumber = SeverityNumber.UNSPECIFIED;
+    switch (entry.level) {
+      case LogLevel.DEBUG:
+        severity = SeverityNumber.DEBUG;
+        break;
+      case LogLevel.INFO:
+        severity = SeverityNumber.INFO;
+        break;
+      case LogLevel.WARN:
+        severity = SeverityNumber.WARN;
+        break;
+      case LogLevel.ERROR:
+        severity = SeverityNumber.ERROR;
+        break;
+    }
+
+    logger.emit({
+      body: entry.error ? ('stack' in entry.error ? entry.error.stack : String(entry.error)) : entry.message,
+      severityNumber: severity,
+      attributes: {
+        [ATTR_CODE_FILE_PATH]: entry.meta?.F,
+        [ATTR_CODE_LINE_NUMBER]: entry.meta?.L,
+        [ATTR_CODE_STACKTRACE]: entry.error?.stack,
+        ...(typeof entry.context === 'object'
+          ? entry.context
+          : {
+              ctx: entry.context,
+            }),
+      },
+    });
+  };
+};
+
+log.addProcessor(makeOtelLogProcessor(logger));
+
+beforeAll(() => {
+  sdk.start();
+});
+
+afterAll(async () => {
+  await loggerProvider.shutdown();
+  await sdk.shutdown();
+});
+
+beforeEach((ctx) => {
+  const span = trace.getTracer('testing-framework').startSpan(ctx.task.name);
+  ctx.onTestFailed((ctx) => {
+    // TODO(dmaretskyi): Record result.
+    span.setStatus({ code: SpanStatusCode.ERROR });
+    span.end();
+  });
+  ctx.onTestFinished((ctx) => {
+    span.setStatus({ code: SpanStatusCode.OK });
+    span.end();
+  });
+});
+
+const foo = Effect.fn('foo')(function* () {
+  yield* Effect.sleep(Duration.millis(100));
+
+  log('log inside foo', { detail: 123 });
+});
+
+const bar = Effect.fn('bar')(function* () {
+  yield* foo();
+});
+
+const baz = Effect.fn('baz')(function* () {
+  yield* bar();
+});
+
+it.live(
+  'Test Suite One',
+  Effect.fnUntraced(
+    function* () {
+      yield* baz();
+    },
+    Effect.provide(layerOtel(Effect.succeed({}))),
+  ),
+);

package/src/otel.ts

@@ -0,0 +1,45 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Resource from '@effect/opentelemetry/Resource';
+import * as Tracer from '@effect/opentelemetry/Tracer';
+import { type Attributes, trace } from '@opentelemetry/api';
+import * as Effect from 'effect/Effect';
+import type * as Function from 'effect/Function';
+import * as Layer from 'effect/Layer';
+
+export interface Configuration {
+  readonly resource?:
+    | {
+        readonly serviceName: string;
+        readonly serviceVersion?: string;
+        readonly attributes?: Attributes;
+      }
+    | undefined;
+}
+
+// Based on https://github.com/Effect-TS/effect/blob/main/packages/opentelemetry/src/NodeSdk.ts
+export const layerOtel: {
+  (evaluate: Function.LazyArg<Configuration>): Layer.Layer<Resource.Resource>;
+  <R, E>(evaluate: Effect.Effect<Configuration, E, R>): Layer.Layer<Resource.Resource, E, R>;
+} = (
+  evaluate: Function.LazyArg<Configuration> | Effect.Effect<Configuration, any, any>,
+): Layer.Layer<Resource.Resource> =>
+  Layer.unwrapEffect(
+    Effect.map(
+      Effect.isEffect(evaluate) ? (evaluate as Effect.Effect<Configuration>) : Effect.sync(evaluate),
+      (config) => {
+        const ResourceLive = Resource.layerFromEnv(config.resource && Resource.configToAttributes(config.resource));
+
+        const provider = trace.getTracerProvider();
+        const TracerLive = Layer.provide(Tracer.layer, Layer.succeed(Tracer.OtelTracerProvider, provider));
+
+        // TODO(wittjosiah): Add metrics and logger layers.
+        const MetricsLive = Layer.empty;
+        const LoggerLive = Layer.empty;
+
+        return Layer.mergeAll(TracerLive, MetricsLive, LoggerLive).pipe(Layer.provideMerge(ResourceLive));
+      },
+    ),
+  );

package/src/resource.test.ts

@@ -0,0 +1,32 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+
+import { acquireReleaseResource } from './resource';
+
+it.effect(
+  'acquire-release',
+  Effect.fn(function* ({ expect }) {
+    const events: string[] = [];
+    const makeResource = acquireReleaseResource(() => ({
+      open: () => {
+        events.push('open');
+      },
+      close: () => {
+        events.push('close');
+      },
+    }));
+
+    yield* Effect.gen(function* () {
+      events.push('1');
+      const _resource = yield* makeResource;
+      events.push('2');
+    }).pipe(Effect.scoped);
+
+    events.push('3');
+    expect(events).to.deep.equal(['1', 'open', '2', 'close', '3']);
+  }),
+);

package/src/resource.ts

@@ -0,0 +1,30 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import type * as Scope from 'effect/Scope';
+
+import type { Lifecycle } from '@dxos/context';
+
+/**
+ * Acquires a resource and releases it when the scope is closed.
+ */
+export const acquireReleaseResource = <T extends Lifecycle>(
+  getResource: () => T,
+): Effect.Effect<T, never, Scope.Scope> =>
+  Effect.acquireRelease(
+    Effect.gen(function* () {
+      const resource = getResource();
+      yield* Effect.promise(async () => {
+        await resource.open?.();
+        return undefined;
+      });
+      return resource;
+    }),
+    (resource) =>
+      Effect.promise(async () => {
+        await resource.close?.();
+        return undefined;
+      }),
+  );

package/src/sanity.test.ts

@@ -2,14 +2,17 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Effect, pipe } from 'effect';
+import * as Effect from 'effect/Effect';
+import * as Function from 'effect/Function';
 import { describe, test } from 'vitest';
 
 import { log } from '@dxos/log';
 
+import { runAndForwardErrors } from './errors';
+
 describe('sanity tests', () => {
   test('function pipeline', async ({ expect }) => {
-    const result = pipe(
+    const result = Function.pipe(
       10,
       (value) => value + 3,
       (value) => value * 2,
@@ -18,36 +21,48 @@ describe('sanity tests', () => {
   });
 
   test('effect pipeline (mixing types)', async ({ expect }) => {
-    const result = await Effect.runPromise(
-      pipe(
+    const result = await runAndForwardErrors(
+      Function.pipe(
         Effect.promise(() => Promise.resolve(100)),
-        Effect.tap((value) => log('tap', { value })),
+        Effect.tap((value) => {
+          log('tap', { value });
+        }),
         Effect.map((value: number) => String(value)),
-        Effect.tap((value) => log('tap', { value })),
+        Effect.tap((value) => {
+          log('tap', { value });
+        }),
         Effect.map((value: string) => value.length),
-        Effect.tap((value) => log('tap', { value })),
+        Effect.tap((value) => {
+          log('tap', { value });
+        }),
       ),
     );
     expect(result).to.eq(3);
   });
 
   test('effect pipeline (mixing sync/async)', async ({ expect }) => {
-    const result = await Effect.runPromise(
-      pipe(
+    const result = await runAndForwardErrors(
+      Function.pipe(
         Effect.succeed(100),
-        Effect.tap((value) => log('tap', { value })),
+        Effect.tap((value) => {
+          log('tap', { value });
+        }),
         Effect.flatMap((value) => Effect.promise(() => Promise.resolve(String(value)))),
-        Effect.tap((value) => log('tap', { value })),
+        Effect.tap((value) => {
+          log('tap', { value });
+        }),
         Effect.map((value) => value.length),
-        Effect.tap((value) => log('tap', { value })),
+        Effect.tap((value) => {
+          log('tap', { value });
+        }),
       ),
     );
     expect(result).to.eq(3);
   });
 
   test('error handling', async ({ expect }) => {
-    Effect.runPromise(
-      pipe(
+    runAndForwardErrors(
+      Function.pipe(
         Effect.succeed(10),
         Effect.map((value) => value * 2),
         Effect.flatMap((value) =>
@@ -62,7 +77,7 @@ describe('sanity tests', () => {
       ),
     )
       .then(() => expect.fail())
-      .catch((error) => {
+      .catch((error: any) => {
         expect(error).to.be.instanceOf(Error);
       });
   });

package/src/testing.ts

@@ -0,0 +1,86 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import type { TestContext } from 'vitest';
+
+export namespace TestHelpers {
+  /**
+   * Skip the test if the condition is false.
+   *
+   * Example:
+   * ```ts
+   * it.effect(
+   *   'should process an agentic loop using Claude',
+   *   Effect.fn(function* ({ expect }) {
+   *     // ...
+   *   }),
+   *   TestHelpers.runIf(process.env.ANTHROPIC_API_KEY),
+   * );
+   * ```
+   */
+  export const runIf =
+    (condition: unknown) =>
+    <A, E, R>(effect: Effect.Effect<A, E, R>, ctx: TestContext): Effect.Effect<A, E, R> =>
+      Effect.gen(function* () {
+        if (!condition) {
+          ctx.skip();
+        } else {
+          return yield* effect;
+        }
+      });
+
+  /**
+   * Skip the test if the condition is true.
+   *
+   * Example:
+   * ```ts
+   * it.effect(
+   *   'should process an agentic loop using Claude',
+   *   Effect.fn(function* ({ expect }) {
+   *     // ...
+   *   }),
+   *   TestHelpers.skipIf(!process.env.ANTHROPIC_API_KEY),
+   * );
+   * ```
+   */
+  export const skipIf =
+    (condition: unknown) =>
+    <A, E, R>(effect: Effect.Effect<A, E, R>, ctx: TestContext): Effect.Effect<A, E, R> =>
+      Effect.gen(function* () {
+        if (condition) {
+          ctx.skip();
+        } else {
+          return yield* effect;
+        }
+      });
+
+  /**
+   * Provide TestContext from test parameters.
+   *
+   * Example:
+   * ```ts
+   * it.effect(
+   *   'with context',
+   *   Effect.fn(function* ({ expect }) {
+   *     const ctx = yield* TestContextService;
+   *   }),
+   *   TestHelpers.provideTestContext,
+   * );
+   * ```
+   */
+  export const provideTestContext = <A, E, R>(
+    effect: Effect.Effect<A, E, R>,
+    ctx: TestContext,
+  ): Effect.Effect<A, E, Exclude<R, TestContextService>> => Effect.provideService(effect, TestContextService, ctx);
+}
+
+/**
+ * Exposes vitest test context as an effect service.
+ */
+export class TestContextService extends Context.Tag('@dxos/effect/TestContextService')<
+  TestContextService,
+  TestContext
+>() {}

package/src/types.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+/**
+ * Flat intersection of up to five types. Behaves like `A & B & C & ...` but
+ * formats as a comma-separated tuple, which fits multi-line layouts more
+ * cleanly than chained `&` operators. Unused slots default to `unknown`,
+ * which is inert under intersection (`T & unknown = T`).
+ */
+export type Merge<A, B = unknown, C = unknown, D = unknown, E = unknown> = A & B & C & D & E;

package/src/url.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 import { describe, expect, test } from 'vitest';
 
 import { ParamKeyAnnotation, UrlParser } from './url';

package/src/url.ts

@@ -2,7 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
-import { SchemaAST, type Schema, Option, pipe } from 'effect';
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
+import type * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
 
 import { decamelize } from '@dxos/util';
 
@@ -59,7 +62,7 @@ export class UrlParser<T extends Record<string, any>> {
       if (value !== undefined) {
         const field = this._schema.fields[key];
         if (field) {
-          const { key: serializedKey } = pipe(
+          const { key: serializedKey } = Function.pipe(
             getParamKeyAnnotation(field.ast),
             Option.getOrElse(() => ({
               key: decamelize(key),