@dxos/effect 0.8.4-main.84f28bd → 0.8.4-main.a4bbb77

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/effect",
-  "version": "0.8.4-main.84f28bd",
+  "version": "0.8.4-main.a4bbb77",
   "description": "Effect utils.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -9,6 +9,7 @@
   "type": "module",
   "exports": {
     ".": {
+      "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
       "browser": "./dist/lib/browser/index.mjs",
       "node": "./dist/lib/node-esm/index.mjs"
@@ -23,15 +24,24 @@
     "src"
   ],
   "dependencies": {
+    "@effect/opentelemetry": "^0.58.0",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/core": "^2.1.0",
     "jsonpath-plus": "10.2.0",
-    "@dxos/context": "0.8.4-main.84f28bd",
-    "@dxos/invariant": "0.8.4-main.84f28bd",
-    "@dxos/node-std": "0.8.4-main.84f28bd",
-    "@dxos/util": "0.8.4-main.84f28bd"
+    "@dxos/context": "0.8.4-main.a4bbb77",
+    "@dxos/invariant": "0.8.4-main.a4bbb77",
+    "@dxos/node-std": "0.8.4-main.a4bbb77",
+    "@dxos/util": "0.8.4-main.a4bbb77"
   },
   "devDependencies": {
-    "effect": "3.16.13",
-    "@dxos/log": "0.8.4-main.84f28bd"
+    "@opentelemetry/api-logs": "^0.203.0",
+    "@opentelemetry/resources": "^2.1.0",
+    "@opentelemetry/sdk-logs": "^0.203.0",
+    "@opentelemetry/sdk-node": "^0.203.0",
+    "@opentelemetry/sdk-trace-node": "^2.1.0",
+    "@opentelemetry/semantic-conventions": "^1.37.0",
+    "effect": "3.18.3",
+    "@dxos/log": "0.8.4-main.a4bbb77"
   },
   "peerDependencies": {
     "effect": "^3.13.3"

package/src/ast.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { SchemaAST, Schema } from 'effect';
+import { Schema, SchemaAST } from 'effect';
 import { describe, test } from 'vitest';
 
 import { invariant } from '@dxos/invariant';
@@ -12,13 +12,13 @@ import {
   findNode,
   findProperty,
   getAnnotation,
-  getDiscriminatingProps,
   getDiscriminatedType,
+  getDiscriminatingProps,
   getSimpleType,
+  isArrayType,
   isOption,
   isSimpleType,
   visit,
-  isArrayType,
 } from './ast';
 import { type JsonPath, type JsonProp } from './jsonPath';
 

package/src/ast.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Option, pipe, SchemaAST, Schema } from 'effect';
+import { Option, Schema, SchemaAST, pipe } from 'effect';
 import { isUndefinedKeyword } from 'effect/SchemaAST';
 
 import { invariant } from '@dxos/invariant';
@@ -17,8 +17,14 @@ import { type JsonPath, type JsonProp } from './jsonPath';
 // https://effect-ts.github.io/effect/schema/SchemaAST.ts.html
 //
 
+// TODO(wittjosiah): What is a "simple type"?
 export type SimpleType = 'object' | 'string' | 'number' | 'boolean' | 'enum' | 'literal';
 
+const isTupleType = (node: SchemaAST.AST): boolean => {
+  // NOTE: Arrays are represented as tuples with no elements and a rest part.
+  return SchemaAST.isTupleType(node) && node.elements.length > 0;
+};
+
 /**
  * Get the base type; e.g., traverse through refinements.
  */
@@ -27,6 +33,8 @@ export const getSimpleType = (node: SchemaAST.AST): SimpleType | undefined => {
     SchemaAST.isDeclaration(node) ||
     SchemaAST.isObjectKeyword(node) ||
     SchemaAST.isTypeLiteral(node) ||
+    // TODO(wittjosiah): Tuples are actually arrays.
+    isTupleType(node) ||
     isDiscriminatedUnion(node)
   ) {
     return 'object';
@@ -127,15 +135,15 @@ const visitNode = (
   path: Path = [],
   depth = 0,
 ): VisitResult | undefined => {
-  const _result = test?.(node, path, depth);
+  const $result = test?.(node, path, depth);
   const result: VisitResult =
-    _result === undefined
+    $result === undefined
       ? VisitResult.CONTINUE
-      : typeof _result === 'boolean'
-        ? _result
+      : typeof $result === 'boolean'
+        ? $result
           ? VisitResult.CONTINUE
           : VisitResult.SKIP
-        : _result;
+        : $result;
 
   if (result === VisitResult.EXIT) {
     return result;
@@ -218,12 +226,14 @@ export const findNode = (node: SchemaAST.AST, test: (node: SchemaAST.AST) => boo
 
   // Branching union (e.g., optional, discriminated unions).
   else if (SchemaAST.isUnion(node)) {
-    if (isOption(node)) {
-      for (const type of node.types) {
-        const child = findNode(type, test);
-        if (child) {
-          return child;
-        }
+    if (isLiteralUnion(node)) {
+      return undefined;
+    }
+
+    for (const type of node.types) {
+      const child = findNode(type, test);
+      if (child) {
+        return child;
       }
     }
   }

package/src/errors.ts

@@ -6,14 +6,16 @@ import { Cause, Chunk, Effect, Exit, GlobalValue, Option } from 'effect';
 import type { AnySpan, Span } from 'effect/Tracer';
 
 const spanSymbol = Symbol.for('effect/SpanAnnotation');
+const originalSymbol = Symbol.for('effect/OriginalAnnotation');
 const spanToTrace = GlobalValue.globalValue('effect/Tracer/spanToTrace', () => new WeakMap());
 const locationRegex = /\((.*)\)/g;
 
 /**
  * Adds effect spans.
  * Removes effect internal functions.
+ * Unwraps error proxy.
  */
-const prettyErrorStack = (error: any, appendStacks: string[] = []): void => {
+const prettyErrorStack = (error: any, appendStacks: string[] = []): any => {
   const span = error[spanSymbol];
 
   const lines = typeof error.stack === 'string' ? error.stack.split('\n') : [];
@@ -75,16 +77,25 @@ const prettyErrorStack = (error: any, appendStacks: string[] = []): void => {
 
   out.push(...appendStacks);
 
+  if (error[originalSymbol]) {
+    error = error[originalSymbol];
+  }
+  if (error.cause) {
+    error.cause = prettyErrorStack(error.cause);
+  }
+
   Object.defineProperty(error, 'stack', {
     value: out.join('\n'),
     writable: true,
     enumerable: false,
     configurable: true,
   });
+
+  return error;
 };
 
 /**
- * Runs the embedded effect asynchronously and throws any failures and defects as errors.
+ * Converts a cause to an error.
  * Inserts effect spans as stack frames.
  * The error will have stack frames of where the effect was run (if stack trace limit allows).
  * Removes effect runtime internal stack frames.
@@ -93,21 +104,13 @@ const prettyErrorStack = (error: any, appendStacks: string[] = []): void => {
  *
  * @throws AggregateError if there are multiple errors.
  */
-export const runAndForwardErrors = async <A, E>(
-  effect: Effect.Effect<A, E, never>,
-  options?: { signal?: AbortSignal },
-): Promise<A> => {
-  const exit = await Effect.runPromiseExit(effect, options);
-  if (Exit.isSuccess(exit)) {
-    return exit.value;
-  }
-
-  if (Cause.isEmpty(exit.cause)) {
-    throw new Error('Fiber failed without a cause');
-  } else if (Cause.isInterrupted(exit.cause)) {
-    throw new Error('Fiber was interrupted');
+export const causeToError = (cause: Cause.Cause<any>): Error => {
+  if (Cause.isEmpty(cause)) {
+    return new Error('Fiber failed without a cause');
+  } else if (Cause.isInterruptedOnly(cause)) {
+    return new Error('Fiber was interrupted');
   } else {
-    const errors = [...Chunk.toArray(Cause.failures(exit.cause)), ...Chunk.toArray(Cause.defects(exit.cause))];
+    const errors = [...Chunk.toArray(Cause.failures(cause)), ...Chunk.toArray(Cause.defects(cause))];
 
     const getStackFrames = (): string[] => {
       const o: { stack: string } = {} as any;
@@ -116,14 +119,68 @@ export const runAndForwardErrors = async <A, E>(
     };
 
     const stackFrames = getStackFrames();
-    for (const error of errors) {
-      prettyErrorStack(error, stackFrames);
-    }
+    const newErrors = errors.map((error) => prettyErrorStack(error, stackFrames));
 
-    if (errors.length === 1) {
-      throw errors[0];
+    if (newErrors.length === 1) {
+      return newErrors[0];
     } else {
-      throw new AggregateError(errors);
+      return new AggregateError(newErrors);
     }
   }
 };
+
+/**
+ * Throws an error based on the cause.
+ * Inserts effect spans as stack frames.
+ * The error will have stack frames of where the effect was run (if stack trace limit allows).
+ * Removes effect runtime internal stack frames.
+ *
+ * To be used in place of `Effect.runPromise`.
+ *
+ * @throws AggregateError if there are multiple errors.
+ */
+export const throwCause = (cause: Cause.Cause<any>): never => {
+  throw causeToError(cause);
+};
+
+export const unwrapExit = <A>(exit: Exit.Exit<A, any>): A => {
+  if (Exit.isSuccess(exit)) {
+    return exit.value;
+  }
+
+  return throwCause(exit.cause);
+};
+
+/**
+ * Runs the embedded effect asynchronously and throws any failures and defects as errors.
+ * Inserts effect spans as stack frames.
+ * The error will have stack frames of where the effect was run (if stack trace limit allows).
+ * Removes effect runtime internal stack frames.
+ *
+ * To be used in place of `Effect.runPromise`.
+ *
+ * @throws AggregateError if there are multiple errors.
+ */
+export const runAndForwardErrors = async <A, E>(
+  effect: Effect.Effect<A, E, never>,
+  options?: { signal?: AbortSignal },
+): Promise<A> => {
+  const exit = await Effect.runPromiseExit(effect, options);
+  return unwrapExit(exit);
+};
+
+/**
+ * Like `Effect.promise` but also caputes spans for defects.
+ * Workaround for: https://github.com/Effect-TS/effect/issues/5436
+ */
+export const promiseWithCauseCapture: <A>(evaluate: (signal: AbortSignal) => PromiseLike<A>) => Effect.Effect<A> = (
+  evaluate,
+) =>
+  Effect.promise(async (signal) => {
+    try {
+      const result = await evaluate(signal);
+      return Effect.succeed(result);
+    } catch (err) {
+      return Effect.die(err);
+    }
+  }).pipe(Effect.flatten);

package/src/index.ts

@@ -7,3 +7,5 @@ export * from './jsonPath';
 export * from './url';
 export * from './context';
 export * from './errors';
+export * from './testing';
+export * from './resource';

package/src/interrupt.test.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { it } from '@effect/vitest';
+import { Cause, Effect, Fiber } from 'effect';
+
+const doWork = Effect.fn('doWork')(function* () {
+  yield* Effect.sleep('1 minute');
+  return 'work done';
+});
+
+it.effect.skip(
+  'call a function to generate a research report',
+  Effect.fnUntraced(
+    function* (_) {
+      const resultFiber = yield* doWork().pipe(Effect.fork);
+      setTimeout(() => {
+        void Effect.runPromise(Fiber.interrupt(resultFiber));
+      }, 2_000);
+
+      const result = yield* resultFiber;
+      console.log({ result });
+    },
+    Effect.catchAllCause((cause) => {
+      // console.log(inspect(cause, { depth: null, colors: true }));
+      console.log(Cause.pretty(cause));
+      return Effect.failCause(cause);
+    }),
+  ),
+);

package/src/jsonPath.test.ts

@@ -4,7 +4,7 @@
 
 import { describe, expect, test } from 'vitest';
 
-import { createJsonPath, getField, isJsonPath, type JsonPath, splitJsonPath } from './jsonPath';
+import { type JsonPath, createJsonPath, getField, isJsonPath, splitJsonPath } from './jsonPath';
 
 describe('createJsonPath', () => {
   test('supported path subset', () => {

package/src/jsonPath.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema, Option } from 'effect';
+import { Option, Schema } from 'effect';
 import { JSONPath } from 'jsonpath-plus';
 
 import { invariant } from '@dxos/invariant';

package/src/layers.test.ts

@@ -0,0 +1,106 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { it } from '@effect/vitest';
+import { Context, Duration, Effect, Layer, ManagedRuntime } from 'effect';
+import { test } from 'vitest';
+
+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 Effect.runPromise(
+      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 Effect.runPromise(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,124 @@
+//
+// 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 { Duration, Effect } from '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,41 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Resource, Tracer } from '@effect/opentelemetry';
+import { type Attributes, trace } from '@opentelemetry/api';
+import { Effect, Layer } from 'effect';
+import { type LazyArg } from 'effect/Function';
+
+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: LazyArg<Configuration>): Layer.Layer<Resource.Resource>;
+  <R, E>(evaluate: Effect.Effect<Configuration, E, R>): Layer.Layer<Resource.Resource, E, R>;
+} = (evaluate: 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 { Effect } from 'effect';
+
+import { accuireReleaseResource } from './resource';
+
+it.effect(
+  'acquire-release',
+  Effect.fn(function* ({ expect }) {
+    const events: string[] = [];
+    const makeResource = accuireReleaseResource(() => ({
+      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,25 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Effect } from 'effect';
+
+import type { Lifecycle } from '@dxos/context';
+
+// TODO(dmaretskyi): Extract to effect-utils.
+export const accuireReleaseResource = <T extends Lifecycle>(getResource: () => T) =>
+  Effect.acquireRelease(
+    Effect.gen(function* () {
+      const resource = getResource();
+      yield* Effect.promise(async () => {
+        resource.open?.();
+        return undefined;
+      });
+      return resource;
+    }),
+    (resource) =>
+      Effect.promise(async () => {
+        resource.close?.();
+        return undefined;
+      }),
+  );