@dxos/effect 0.8.4-main.84f28bd → 0.8.4-main.937b3ca

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,110 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import type { TestContext } from 'vitest';
+
+// TODO(dmaretskyi): Add all different test tags here.
+export type TestTag =
+  | 'flaky' // Flaky tests.
+  | 'llm' // Tests with AI.
+  | 'sync'; // Sync with external services.
+
+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;
+        }
+      });
+
+  /**
+   * Skips this test if the tag is not in the list of tags to run.
+   * Tags are specified in the `DX_TEST_TAGS` environment variable.
+   *
+   * @param tag
+   * @returns
+   */
+  export const taggedTest =
+    (tag: TestTag) =>
+    <A, E, R>(effect: Effect.Effect<A, E, R>, ctx: TestContext): Effect.Effect<A, E, R> =>
+      Effect.gen(function* () {
+        if (!process.env.DX_TEST_TAGS?.includes(tag)) {
+          ctx.skip();
+        } else {
+          return yield* effect;
+        }
+      });
+
+  /**
+   * Provide TestContext from test parameters.
+   *
+   * Exmaple:
+   * ```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/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),

package/dist/types/src/jsonPath.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsonPath.d.ts","sourceRoot":"","sources":["../../../src/jsonPath.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAC;AAKxC,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG;IAAE,UAAU,EAAE,IAAI,CAAC;IAAC,UAAU,EAAE,IAAI,CAAA;CAAE,CAAC;AACvE,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG;IAAE,UAAU,EAAE,IAAI,CAAA;CAAE,CAAC;AAKrD;;GAEG;AACH,eAAO,MAAM,QAAQ,EAGR,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;AACrC,eAAO,MAAM,QAAQ,EAIT,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;AAEpC,eAAO,MAAM,UAAU,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,QAEpD,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,cAAc,GAAI,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,KAAG,QAa1D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,wBAAwB,GAAI,YAAY,MAAM,KAAG,QAK7D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa,GAAI,MAAM,QAAQ,KAAG,MAAM,EAUpD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,QAAQ,GAAI,QAAQ,GAAG,EAAE,MAAM,QAAQ,KAAG,GAGtD,CAAC"}

package/dist/types/src/jsonPath.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=jsonPath.test.d.ts.map

package/dist/types/src/jsonPath.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsonPath.test.d.ts","sourceRoot":"","sources":["../../../src/jsonPath.test.ts"],"names":[],"mappings":""}