@dxos/effect 0.8.3 → 0.8.4-main.3a94e84

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/effect",
-  "version": "0.8.3",
+  "version": "0.8.4-main.3a94e84",
   "description": "Effect utils.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -24,13 +24,14 @@
   ],
   "dependencies": {
     "jsonpath-plus": "10.2.0",
-    "@dxos/invariant": "0.8.3",
-    "@dxos/node-std": "0.8.3",
-    "@dxos/util": "0.8.3"
+    "@dxos/context": "0.8.4-main.3a94e84",
+    "@dxos/invariant": "0.8.4-main.3a94e84",
+    "@dxos/node-std": "0.8.4-main.3a94e84",
+    "@dxos/util": "0.8.4-main.3a94e84"
   },
   "devDependencies": {
-    "effect": "3.14.21",
-    "@dxos/log": "0.8.3"
+    "effect": "3.17.0",
+    "@dxos/log": "0.8.4-main.3a94e84"
   },
   "peerDependencies": {
     "effect": "^3.13.3"

package/src/ast.test.ts

@@ -18,6 +18,7 @@ import {
   isOption,
   isSimpleType,
   visit,
+  isArrayType,
 } from './ast';
 import { type JsonPath, type JsonProp } from './jsonPath';
 
@@ -178,4 +179,20 @@ describe('AST', () => {
       );
     }
   });
+
+  test('Schema.pluck', ({ expect }) => {
+    const TestSchema = Schema.Struct({
+      name: Schema.String,
+    });
+
+    expect(TestSchema.pipe(Schema.pluck('name'), Schema.typeSchema).ast).toEqual(SchemaAST.stringKeyword);
+    expect(() => TestSchema.pipe(Schema.pluck('missing' as any), Schema.typeSchema)).to.throw();
+  });
+
+  test('isArray', ({ expect }) => {
+    expect(isArrayType(Schema.String.ast)).to.be.false;
+    expect(isArrayType(Schema.Array(Schema.String).ast)).to.be.true;
+    expect(isArrayType(findProperty(Schema.Struct({ a: Schema.Array(Schema.String) }), 'a' as JsonPath)!)).to.be.true;
+    expect(isArrayType(Schema.Union(Schema.String, Schema.Array(Schema.String)).ast)).to.be.false;
+  });
 });

package/src/ast.ts

@@ -3,6 +3,7 @@
 //
 
 import { Option, pipe, SchemaAST, Schema } from 'effect';
+import { isUndefinedKeyword } from 'effect/SchemaAST';
 
 import { invariant } from '@dxos/invariant';
 import { isNonNullable } from '@dxos/util';
@@ -454,3 +455,16 @@ export const mapAst = (
     }
   }
 };
+
+/**
+ * @returns true if AST is for Array(T) or optional(Array(T)).
+ */
+export const isArrayType = (node: SchemaAST.AST): boolean => {
+  return (
+    SchemaAST.isTupleType(node) ||
+    (SchemaAST.isUnion(node) &&
+      node.types.some(isArrayType) &&
+      node.types.some(isUndefinedKeyword) &&
+      node.types.length === 2)
+  );
+};

package/src/context.ts

@@ -0,0 +1,15 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Effect, type Scope } from 'effect';
+
+import { Context } from '@dxos/context';
+
+// TODO(dmaretskyi): Error handling.
+export const contextFromScope = (): Effect.Effect<Context, never, Scope.Scope> =>
+  Effect.gen(function* () {
+    const ctx = new Context();
+    yield* Effect.addFinalizer(() => Effect.promise(() => ctx.dispose()));
+    return ctx;
+  });

package/src/errors.test.ts

@@ -0,0 +1,22 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Data } from 'effect';
+import { test } from 'vitest';
+
+class MyError extends Data.TaggedError('MyError')<{
+  message: string;
+}> {
+  constructor() {
+    super({ message: 'My error message' });
+  }
+}
+
+// Experimenting with error formatting:
+// - If the error doesn't have the message set, vitest will print the error as a JS object.
+// - If the error has non-empty message, vitest will pretty-print the error.
+test.skip('Data error formatting', () => {
+  console.log(JSON.stringify(new MyError(), null, 2));
+  throw new MyError();
+});

package/src/errors.ts

@@ -0,0 +1,138 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+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[] = []): any => {
+  const span = error[spanSymbol];
+
+  const lines = typeof error.stack === 'string' ? error.stack.split('\n') : [];
+  const out = [];
+
+  let atStack = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (!atStack && !lines[i].startsWith('    at ')) {
+      out.push(lines[i]);
+      continue;
+    }
+    atStack = true;
+
+    if (lines[i].includes(' at new BaseEffectError') || lines[i].includes(' at new YieldableError')) {
+      i++;
+      continue;
+    }
+    if (lines[i].includes('Generator.next')) {
+      break;
+    }
+    if (lines[i].includes('effect_internal_function')) {
+      break;
+    }
+    out.push(
+      lines[i]
+        .replace(/at .*effect_instruction_i.*\((.*)\)/, 'at $1')
+        .replace(/EffectPrimitive\.\w+/, '<anonymous>')
+        .replace(/at Arguments\./, 'at '),
+    );
+  }
+
+  if (span) {
+    let current: Span | AnySpan | undefined = span;
+    let i = 0;
+    while (current && current._tag === 'Span' && i < 10) {
+      const stackFn = spanToTrace.get(current);
+      if (typeof stackFn === 'function') {
+        const stack = stackFn();
+        if (typeof stack === 'string') {
+          const locationMatchAll = stack.matchAll(locationRegex);
+          let match = false;
+          for (const [, location] of locationMatchAll) {
+            match = true;
+            out.push(`    at ${current.name} (${location})`);
+          }
+          if (!match) {
+            out.push(`    at ${current.name} (${stack.replace(/^at /, '')})`);
+          }
+        } else {
+          out.push(`    at ${current.name}`);
+        }
+      } else {
+        out.push(`    at ${current.name}`);
+      }
+      current = Option.getOrUndefined(current.parent);
+      i++;
+    }
+  }
+
+  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.
+ * 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);
+  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');
+  } else {
+    const errors = [...Chunk.toArray(Cause.failures(exit.cause)), ...Chunk.toArray(Cause.defects(exit.cause))];
+
+    const getStackFrames = (): string[] => {
+      const o: { stack: string } = {} as any;
+      Error.captureStackTrace(o, getStackFrames);
+      return o.stack.split('\n').slice(1);
+    };
+
+    const stackFrames = getStackFrames();
+    const newErrors = errors.map((error) => prettyErrorStack(error, stackFrames));
+
+    if (newErrors.length === 1) {
+      throw newErrors[0];
+    } else {
+      throw new AggregateError(newErrors);
+    }
+  }
+};

package/src/index.ts

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

package/src/resource.test.ts

@@ -0,0 +1,31 @@
+//
+// 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;
+      }),
+  );

package/src/testing.ts

@@ -0,0 +1,58 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Effect } from 'effect';
+import type { TestContext } from 'vitest';
+
+export namespace TestHelpers {
+  /**
+   * Skip the test if the condition is false.
+   *
+   * Exmaple:
+   * ```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.
+   *
+   * Exmaple:
+   * ```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;
+        }
+      });
+}