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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/effect",
-  "version": "0.8.4-main.5ea62a8",
+  "version": "0.8.4-main.66e292d",
   "description": "Effect utils.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -24,15 +24,23 @@
     "src"
   ],
   "dependencies": {
+    "@effect/opentelemetry": "^0.58.0",
+    "@opentelemetry/api": "^1.9.0",
     "jsonpath-plus": "10.2.0",
-    "@dxos/context": "0.8.4-main.5ea62a8",
-    "@dxos/invariant": "0.8.4-main.5ea62a8",
-    "@dxos/util": "0.8.4-main.5ea62a8",
-    "@dxos/node-std": "0.8.4-main.5ea62a8"
+    "@dxos/context": "0.8.4-main.66e292d",
+    "@dxos/invariant": "0.8.4-main.66e292d",
+    "@dxos/node-std": "0.8.4-main.66e292d",
+    "@dxos/util": "0.8.4-main.66e292d"
   },
   "devDependencies": {
-    "effect": "3.17.7",
-    "@dxos/log": "0.8.4-main.5ea62a8"
+    "@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.66e292d"
   },
   "peerDependencies": {
     "effect": "^3.13.3"

package/src/ast.test.ts

@@ -2,7 +2,8 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema, SchemaAST } from 'effect';
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
 import { describe, test } from 'vitest';
 
 import { invariant } from '@dxos/invariant';
@@ -20,7 +21,7 @@ import {
   isSimpleType,
   visit,
 } from './ast';
-import { type JsonPath, type JsonProp } from './jsonPath';
+import { type JsonPath, type JsonProp } from './json-path';
 
 const ZipCode = Schema.String.pipe(
   Schema.pattern(/^\d{5}$/, {

package/src/ast.ts

@@ -2,13 +2,15 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Option, Schema, SchemaAST, pipe } from 'effect';
-import { isUndefinedKeyword } from 'effect/SchemaAST';
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
 
 import { invariant } from '@dxos/invariant';
 import { isNonNullable } from '@dxos/util';
 
-import { type JsonPath, type JsonProp } from './jsonPath';
+import { type JsonPath, type JsonProp } from './json-path';
 
 //
 // Refs
@@ -212,6 +214,12 @@ export const findNode = (node: SchemaAST.AST, test: (node: SchemaAST.AST) => boo
         return child;
       }
     }
+    for (const prop of getIndexSignatures(node)) {
+      const child = findNode(prop.type, test);
+      if (child) {
+        return child;
+      }
+    }
   }
 
   // Tuple.
@@ -226,12 +234,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;
       }
     }
   }
@@ -287,8 +297,8 @@ export const getAnnotation =
   <T>(annotationId: symbol, noDefault = true) =>
   (node: SchemaAST.AST): T | undefined => {
     // Title fallback seems to be the identifier.
-    const id = pipe(SchemaAST.getIdentifierAnnotation(node), Option.getOrUndefined);
-    const value = pipe(SchemaAST.getAnnotation<T>(annotationId)(node), Option.getOrUndefined);
+    const id = Function.pipe(SchemaAST.getIdentifierAnnotation(node), Option.getOrUndefined);
+    const value = Function.pipe(SchemaAST.getAnnotation<T>(annotationId)(node), Option.getOrUndefined);
     if (noDefault && (value === defaultAnnotations[node._tag]?.annotations[annotationId] || value === id)) {
       return undefined;
     }
@@ -440,6 +450,7 @@ export const mapAst = (
             ),
         ),
         ast.indexSignatures,
+        ast.annotations,
       );
     }
     case 'Union': {
@@ -472,7 +483,23 @@ export const isArrayType = (node: SchemaAST.AST): boolean => {
     SchemaAST.isTupleType(node) ||
     (SchemaAST.isUnion(node) &&
       node.types.some(isArrayType) &&
-      node.types.some(isUndefinedKeyword) &&
+      node.types.some(SchemaAST.isUndefinedKeyword) &&
       node.types.length === 2)
   );
 };
+
+const getIndexSignatures = (ast: SchemaAST.AST): Array<SchemaAST.IndexSignature> => {
+  const annotation = SchemaAST.getSurrogateAnnotation(ast);
+  if (Option.isSome(annotation)) {
+    return getIndexSignatures(annotation.value);
+  }
+  switch (ast._tag) {
+    case 'TypeLiteral':
+      return ast.indexSignatures.slice();
+    case 'Suspend':
+      return getIndexSignatures(ast.f());
+    case 'Refinement':
+      return getIndexSignatures(ast.from);
+  }
+  return [];
+};

package/src/context.ts

@@ -2,7 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect, type Scope } from 'effect';
+import * as Effect from 'effect/Effect';
+import type * as Scope from 'effect/Scope';
 
 import { Context } from '@dxos/context';
 

package/src/errors.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Data } from 'effect';
+import * as Data from 'effect/Data';
 import { test } from 'vitest';
 
 class MyError extends Data.TaggedError('MyError')<{

package/src/errors.ts

@@ -2,8 +2,13 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Cause, Chunk, Effect, Exit, GlobalValue, Option } from 'effect';
-import type { AnySpan, Span } from 'effect/Tracer';
+import * as Cause from 'effect/Cause';
+import * as Chunk from 'effect/Chunk';
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
+import * as GlobalValue from 'effect/GlobalValue';
+import * as Option from 'effect/Option';
+import type * as Tracer from 'effect/Tracer';
 
 const spanSymbol = Symbol.for('effect/SpanAnnotation');
 const originalSymbol = Symbol.for('effect/OriginalAnnotation');
@@ -48,7 +53,7 @@ const prettyErrorStack = (error: any, appendStacks: string[] = []): any => {
   }
 
   if (span) {
-    let current: Span | AnySpan | undefined = span;
+    let current: Tracer.Span | Tracer.AnySpan | undefined = span;
     let i = 0;
     while (current && current._tag === 'Span' && i < 10) {
       const stackFn = spanToTrace.get(current);
@@ -106,9 +111,9 @@ const prettyErrorStack = (error: any, appendStacks: string[] = []): any => {
  */
 export const causeToError = (cause: Cause.Cause<any>): Error => {
   if (Cause.isEmpty(cause)) {
-    throw new Error('Fiber failed without a cause');
+    return new Error('Fiber failed without a cause');
   } else if (Cause.isInterruptedOnly(cause)) {
-    throw new Error('Fiber was interrupted');
+    return new Error('Fiber was interrupted');
   } else {
     const errors = [...Chunk.toArray(Cause.failures(cause)), ...Chunk.toArray(Cause.defects(cause))];
 
@@ -122,9 +127,9 @@ export const causeToError = (cause: Cause.Cause<any>): Error => {
     const newErrors = errors.map((error) => prettyErrorStack(error, stackFrames));
 
     if (newErrors.length === 1) {
-      throw newErrors[0];
+      return newErrors[0];
     } else {
-      throw new AggregateError(newErrors);
+      return new AggregateError(newErrors);
     }
   }
 };

package/src/index.ts

@@ -3,7 +3,7 @@
 //
 
 export * from './ast';
-export * from './jsonPath';
+export * from './json-path';
 export * from './url';
 export * from './context';
 export * from './errors';

package/src/interrupt.test.ts

@@ -3,26 +3,25 @@
 //
 
 import { it } from '@effect/vitest';
-import { Cause, Effect, Fiber } from 'effect';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import * as Fiber from 'effect/Fiber';
 
 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* ({ expect: _ }) {
+    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) => {

package/src/{jsonPath.test.ts → json-path.test.ts}

@@ -4,7 +4,7 @@
 
 import { describe, expect, test } from 'vitest';
 
-import { type JsonPath, createJsonPath, getField, isJsonPath, splitJsonPath } from './jsonPath';
+import { type JsonPath, createJsonPath, getField, getValue, isJsonPath, setValue, splitJsonPath } from './json-path';
 
 describe('createJsonPath', () => {
   test('supported path subset', () => {
@@ -99,3 +99,42 @@ describe('createJsonPath', () => {
     expect(getField({ a: 'foo' }, 'a' as JsonPath)).toBe('foo');
   });
 });
+
+describe('Types', () => {
+  test('checks sanity', async ({ expect }) => {
+    const obj = {};
+    expect(obj).to.exist;
+  });
+});
+
+describe('get/set deep', () => {
+  test('get/set operations', ({ expect }) => {
+    const obj = {
+      name: 'test',
+      items: ['a', 'b', 'c'],
+      nested: {
+        prop: 'value',
+        arr: [1, 2, 3],
+      },
+    };
+
+    // Basic property access.
+    expect(getValue(obj, 'name' as JsonPath)).toBe('test');
+
+    // Array index access.
+    expect(getValue(obj, 'items[1]' as JsonPath)).toBe('b');
+
+    // Nested property access.
+    expect(getValue(obj, 'nested.prop' as JsonPath)).toBe('value');
+
+    // Nested array access.
+    expect(getValue(obj, 'nested.arr[2]' as JsonPath)).toBe(3);
+
+    // Setting values.
+    const updated1 = setValue(obj, 'items[1]' as JsonPath, 'x');
+    expect(updated1.items[1]).toBe('x');
+
+    const updated2 = setValue(obj, 'nested.arr[0]' as JsonPath, 99);
+    expect(updated2.nested.arr[0]).toBe(99);
+  });
+});

package/src/{jsonPath.ts → json-path.ts}

@@ -2,20 +2,26 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Option, Schema } from 'effect';
+import * as Option from 'effect/Option';
+import * as Schema from 'effect/Schema';
 import { JSONPath } from 'jsonpath-plus';
 
 import { invariant } from '@dxos/invariant';
+import { getDeep, setDeep } from '@dxos/util';
 
 export type JsonProp = string & { __JsonPath: true; __JsonProp: true };
 export type JsonPath = string & { __JsonPath: true };
 
+// TODO(burdon): Start with "$."?
+
 const PATH_REGEX = /^($|[a-zA-Z_$][\w$]*(?:\.[a-zA-Z_$][\w$]*|\[\d+\](?:\.)?)*$)/;
+
 const PROP_REGEX = /^\w+$/;
 
 /**
  * https://www.ietf.org/archive/id/draft-goessner-dispatch-jsonpath-00.html
  */
+// TODO(burdon): Keys could be arbitrary strings.
 export const JsonPath = Schema.String.pipe(Schema.pattern(PATH_REGEX)).annotations({
   title: 'JSON path',
   description: 'JSON path to a property',
@@ -94,7 +100,29 @@ export const splitJsonPath = (path: JsonPath): string[] => {
 /**
  * Applies a JsonPath to an object.
  */
+// TODO(burdon): Reconcile with getValue.
 export const getField = (object: any, path: JsonPath): any => {
   // By default, JSONPath returns an array of results.
   return JSONPath({ path, json: object })[0];
 };
+
+/**
+ * Get value from object using JsonPath.
+ */
+export const getValue = <T extends object>(obj: T, path: JsonPath): any => {
+  return getDeep(
+    obj,
+    splitJsonPath(path).map((p) => p.replace(/[[\]]/g, '')),
+  );
+};
+
+/**
+ * Set value on object using JsonPath.
+ */
+export const setValue = <T extends object>(obj: T, path: JsonPath, value: any): T => {
+  return setDeep(
+    obj,
+    splitJsonPath(path).map((p) => p.replace(/[[\]]/g, '')),
+    value,
+  );
+};

package/src/layers.test.ts

@@ -3,7 +3,11 @@
 //
 
 import { it } from '@effect/vitest';
-import { Context, Duration, Effect, Layer, ManagedRuntime } from 'effect';
+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';
 
 class ClientConfig extends Context.Tag('ClientConfig')<ClientConfig, { endpoint: string }>() {}
@@ -46,7 +50,7 @@ const ServerLive = Layer.scoped(
 it.effect.skip(
   'test',
   Effect.fn(
-    function* ({ expect: _ }) {
+    function* (_) {
       const client = yield* Client;
       yield* client.call();
     },

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

@@ -3,15 +3,15 @@
 //
 
 import { it } from '@effect/vitest';
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
 
-import { accuireReleaseResource } from './resource';
+import { acquireReleaseResource } from './resource';
 
 it.effect(
   'acquire-release',
   Effect.fn(function* ({ expect }) {
     const events: string[] = [];
-    const makeResource = accuireReleaseResource(() => ({
+    const makeResource = acquireReleaseResource(() => ({
       open: () => {
         events.push('open');
       },

package/src/resource.ts

@@ -2,12 +2,17 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
+import type * as Scope from 'effect/Scope';
 
 import type { Lifecycle } from '@dxos/context';
 
-// TODO(dmaretskyi): Extract to effect-utils.
-export const accuireReleaseResource = <T extends Lifecycle>(getResource: () => T) =>
+/**
+ * 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();