chore: migrate to Effect v4

.changeset/effect-v4.md

@@ -0,0 +1,5 @@
+---
+"@spiko-tech/effect-react-query": major
+---
+
+Migrate to Effect v4. The `runtime` option now accepts a `Context.Context<R>` or a `ManagedRuntime` (v3 `Runtime.Runtime<R>` no longer exists). Cancellation now uses Effect's native `signal` run option.

docs/index.md

@@ -349,17 +349,17 @@ const mutation = useEffectMutation({
 
 # Dependency Injection
 
-When Effects have service requirements, provide a `ManagedRuntime` or `Runtime`:
+When Effects have service requirements, provide a `ManagedRuntime` or a `Context`:
 
 ```ts
 import { Context, Effect, Layer, ManagedRuntime } from "effect";
 import { useEffectQuery } from "@effect-react-query";
 
 // Define a service
-class UserService extends Context.Tag("UserService")<
+class UserService extends Context.Service<
   UserService,
   { readonly getUser: (id: string) => Effect.Effect<User, NetworkError> }
->() {}
+>()("UserService") {}
 
 // Create the layer
 const UserServiceLive = Layer.succeed(

package.json

@@ -62,7 +62,7 @@
   },
   "peerDependencies": {
     "@tanstack/react-query": "^5.99.2",
-    "effect": "^3.21.1"
+    "effect": "^4.0.0-rc.117"
   },
   "engines": {
     "node": ">=20"

src/internal/createEffectQueryFn.ts

@@ -1,5 +1,5 @@
-import { Cause, Effect, Exit, ManagedRuntime, Runtime } from "effect";
-import { hasProperty } from "effect/Predicate";
+import { Cause, Context, Effect, Exit } from "effect";
+import type { ManagedRuntime } from "effect";
 
 /**
  * Creates a query function that wraps an Effect-returning function.
@@ -9,39 +9,28 @@ import { hasProperty } from "effect/Predicate";
  */
 export function createEffectQueryFn<TQueryFnData, TError, TContext, R>(
   effectFn: (context: TContext) => Effect.Effect<TQueryFnData, TError, R>,
-  runtime: Runtime.Runtime<R> | ManagedRuntime.ManagedRuntime<R, unknown> | undefined,
+  runtime: Context.Context<R> | ManagedRuntime.ManagedRuntime<R, unknown> | undefined,
   getSignal: (context: TContext) => AbortSignal,
 ): (context: TContext) => Promise<TQueryFnData> {
   return async (context: TContext) => {
     const effect = effectFn(context);
-    const signal = getSignal(context);
-
-    // Create an effect that listens to the AbortSignal for cancellation
-    const withAbort = Effect.raceFirst(
-      effect,
-      Effect.async<never, never, never>((resume) => {
-        if (signal.aborted) {
-          resume(Effect.interrupt);
-          return;
-        }
-        const onAbort = () => resume(Effect.interrupt);
-        signal.addEventListener("abort", onAbort);
-        return Effect.sync(() => signal.removeEventListener("abort", onAbort));
-      }),
-    );
+    const options = { signal: getSignal(context) };
 
     // Determine how to run the effect based on runtime type
     // Use unknown for error type since ManagedRuntime can add layer errors
     let exit: Exit.Exit<TQueryFnData, unknown>;
 
     if (runtime) {
-      if (hasProperty(runtime, ManagedRuntime.TypeId)) {
-        exit = await runtime.runPromiseExit(withAbort);
+      if (Context.isContext(runtime)) {
+        exit = await Effect.runPromiseExitWith(runtime)(effect, options);
       } else {
-        exit = await Runtime.runPromiseExit(runtime)(withAbort);
+        exit = await runtime.runPromiseExit(effect, options);
       }
     } else {
-      exit = await Effect.runPromiseExit(withAbort as Effect.Effect<TQueryFnData, TError, never>);
+      exit = await Effect.runPromiseExit(
+        effect as Effect.Effect<TQueryFnData, TError, never>,
+        options,
+      );
     }
 
     if (Exit.isSuccess(exit)) return exit.value;
@@ -50,7 +39,7 @@ export function createEffectQueryFn<TQueryFnData, TError, TContext, R>(
 
     // Check for interruption - don't call onError, just hang
     // React Query will handle cleanup
-    if (Cause.isInterruptedOnly(cause)) {
+    if (Cause.hasInterruptsOnly(cause)) {
       return new Promise<TQueryFnData>(() => {
         // Never resolves - query is cancelled
       });

src/types.ts

@@ -21,7 +21,7 @@ import type {
   UseSuspenseQueryOptions,
   UseSuspenseQueryResult,
 } from "@tanstack/react-query";
-import type { Effect, ManagedRuntime, Runtime } from "effect";
+import type { Context, Effect, ManagedRuntime } from "effect";
 
 /**
  * Options for useEffectMutation hook.
@@ -47,11 +47,11 @@ export type UseEffectMutationOptions<
 
 /**
  * Runtime option - required when R is not never, forbidden when R is never.
- * Accepts either a Runtime or a ManagedRuntime.
+ * Accepts either a Context or a ManagedRuntime.
  */
 export type RuntimeOption<R> = [R] extends [never]
   ? { runtime?: undefined }
-  : { runtime: Runtime.Runtime<R> | ManagedRuntime.ManagedRuntime<R, unknown> };
+  : { runtime: Context.Context<R> | ManagedRuntime.ManagedRuntime<R, unknown> };
 
 /**
  * The result of useEffectMutation hook.

src/useEffectMutation.ts

@@ -1,6 +1,5 @@
 import { useMutation } from "@tanstack/react-query";
-import { Cause, Effect, Exit, ManagedRuntime, Runtime } from "effect";
-import { hasProperty } from "effect/Predicate";
+import { Cause, Context, Effect, Exit } from "effect";
 import type { UseEffectMutationOptions, UseEffectMutationResult } from "./types";
 
 /**
@@ -27,7 +26,7 @@ import type { UseEffectMutationOptions, UseEffectMutationResult } from "./types"
  * // Effect with requirements - runtime is required
  * const mutation = useEffectMutation({
  *   mutationFn: createUserWithService, // Effect<User, NetworkError, UserService>
- *   runtime: myRuntime, // Runtime<UserService>
+ *   runtime: myRuntime, // Context<UserService> or ManagedRuntime<UserService>
  *   onError: Match.valueTags({
  *     NetworkError: (e) => toast.error(e.message),
  *   }),
@@ -49,10 +48,10 @@ export function useEffectMutation<TData, TError, TVariables = void, TContext = u
       let exit: Exit.Exit<TData, unknown>;
 
       if (runtime) {
-        if (hasProperty(runtime, ManagedRuntime.TypeId)) {
-          exit = await runtime.runPromiseExit(effect);
+        if (Context.isContext(runtime)) {
+          exit = await Effect.runPromiseExitWith(runtime)(effect);
         } else {
-          exit = await Runtime.runPromiseExit(runtime)(effect);
+          exit = await runtime.runPromiseExit(effect);
         }
       } else {
         exit = await Effect.runPromiseExit(effect as Effect.Effect<TData, TError, never>);
@@ -64,7 +63,7 @@ export function useEffectMutation<TData, TError, TVariables = void, TContext = u
 
       // Check for interruption - don't call onError, just hang
       // React Query will handle cleanup
-      if (Cause.isInterruptedOnly(cause)) {
+      if (Cause.hasInterruptsOnly(cause)) {
         return new Promise<TData>(() => {
           // Never resolves - mutation is cancelled
         });

src/useEffectQueries.ts

@@ -1,6 +1,6 @@
 import type { QueryKey } from "@tanstack/react-query";
 import { useQueries } from "@tanstack/react-query";
-import type { Effect, ManagedRuntime, Runtime } from "effect";
+import type { Context, Effect, ManagedRuntime } from "effect";
 import { createEffectQueryFn } from "./internal/createEffectQueryFn";
 import type { EffectQueriesResults } from "./types";
 
@@ -12,7 +12,7 @@ import type { EffectQueriesResults } from "./types";
 type EffectQueryOptionsBase = {
   queryKey: QueryKey;
   queryFn: (...args: any[]) => Effect.Effect<any, any, any>;
-  runtime?: Runtime.Runtime<any> | ManagedRuntime.ManagedRuntime<any, any> | undefined;
+  runtime?: Context.Context<any> | ManagedRuntime.ManagedRuntime<any, any> | undefined;
 };
 
 /**

src/useEffectQuery.ts

@@ -1,6 +1,6 @@
 import type { QueryFunctionContext, QueryKey } from "@tanstack/react-query";
 import { useQuery } from "@tanstack/react-query";
-import type { Effect, ManagedRuntime, Runtime } from "effect";
+import type { Context, Effect, ManagedRuntime } from "effect";
 import { createEffectQueryFn } from "./internal/createEffectQueryFn";
 import type {
   DefinedInitialDataEffectQueryOptions,
@@ -32,7 +32,7 @@ import type {
  * const query = useEffectQuery({
  *   queryKey: ["user", userId],
  *   queryFn: () => fetchUserWithService(userId), // Effect<User, NetworkError, UserService>
- *   runtime: myRuntime, // Runtime<UserService>
+ *   runtime: myRuntime, // Context<UserService> or ManagedRuntime<UserService>
  * });
  *
  * // Handle errors with Match
@@ -86,7 +86,7 @@ export function useEffectQuery<
 ): UseEffectQueryResult<TData, TError> {
   const { queryFn, runtime, ...restOptions } = options as {
     queryFn: (context: QueryFunctionContext<TQueryKey>) => Effect.Effect<TQueryFnData, TError, R>;
-    runtime?: Runtime.Runtime<R> | ManagedRuntime.ManagedRuntime<R, unknown>;
+    runtime?: Context.Context<R> | ManagedRuntime.ManagedRuntime<R, unknown>;
   } & Omit<UseEffectQueryOptions<TQueryFnData, TError, TData, TQueryKey, R>, "queryFn" | "runtime">;
 
   return useQuery<TQueryFnData, TError, TData, TQueryKey>({

src/useEffectSuspenseQueries.ts

@@ -1,6 +1,6 @@
 import type { QueryKey } from "@tanstack/react-query";
 import { useSuspenseQueries } from "@tanstack/react-query";
-import type { Effect, ManagedRuntime, Runtime } from "effect";
+import type { Context, Effect, ManagedRuntime } from "effect";
 import { createEffectQueryFn } from "./internal/createEffectQueryFn";
 import type { EffectSuspenseQueriesResults } from "./types";
 
@@ -12,7 +12,7 @@ import type { EffectSuspenseQueriesResults } from "./types";
 type EffectSuspenseQueryOptionsBase = {
   queryKey: QueryKey;
   queryFn: (...args: any[]) => Effect.Effect<any, any, any>;
-  runtime?: Runtime.Runtime<any> | ManagedRuntime.ManagedRuntime<any, any>;
+  runtime?: Context.Context<any> | ManagedRuntime.ManagedRuntime<any, any>;
 };
 
 /**

src/useEffectSuspenseQuery.ts

@@ -1,6 +1,6 @@
 import type { QueryFunctionContext, QueryKey } from "@tanstack/react-query";
 import { useSuspenseQuery } from "@tanstack/react-query";
-import type { Effect, ManagedRuntime, Runtime } from "effect";
+import type { Context, Effect, ManagedRuntime } from "effect";
 import { createEffectQueryFn } from "./internal/createEffectQueryFn";
 import type { UseEffectSuspenseQueryOptions, UseEffectSuspenseQueryResult } from "./types";
 
@@ -25,7 +25,7 @@ import type { UseEffectSuspenseQueryOptions, UseEffectSuspenseQueryResult } from
  * const query = useEffectSuspenseQuery({
  *   queryKey: ["user", userId],
  *   queryFn: () => fetchUserWithService(userId), // Effect<User, NetworkError, UserService>
- *   runtime: myRuntime, // Runtime<UserService>
+ *   runtime: myRuntime, // Context<UserService> or ManagedRuntime<UserService>
  * });
  * ```
  */
@@ -40,7 +40,7 @@ export function useEffectSuspenseQuery<
 ): UseEffectSuspenseQueryResult<TData, TError> {
   const { queryFn, runtime, ...restOptions } = options as {
     queryFn: (context: QueryFunctionContext<TQueryKey>) => Effect.Effect<TQueryFnData, TError, R>;
-    runtime?: Runtime.Runtime<R> | ManagedRuntime.ManagedRuntime<R, unknown>;
+    runtime?: Context.Context<R> | ManagedRuntime.ManagedRuntime<R, unknown>;
   } & Omit<
     UseEffectSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey, R>,
     "queryFn" | "runtime"

src/useInfiniteEffectQuery.ts

@@ -1,6 +1,6 @@
 import type { InfiniteData, QueryFunctionContext, QueryKey } from "@tanstack/react-query";
 import { useInfiniteQuery } from "@tanstack/react-query";
-import type { Effect, ManagedRuntime, Runtime } from "effect";
+import type { Context, Effect, ManagedRuntime } from "effect";
 import { createEffectQueryFn } from "./internal/createEffectQueryFn";
 import type {
   DefinedInitialDataInfiniteEffectQueryOptions,
@@ -108,7 +108,7 @@ export function useInfiniteEffectQuery<
     queryFn: (
       context: QueryFunctionContext<TQueryKey, TPageParam>,
     ) => Effect.Effect<TQueryFnData, TError, R>;
-    runtime?: Runtime.Runtime<R> | ManagedRuntime.ManagedRuntime<R, unknown>;
+    runtime?: Context.Context<R> | ManagedRuntime.ManagedRuntime<R, unknown>;
   } & Omit<
     UseInfiniteEffectQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam, R>,
     "queryFn" | "runtime"

src/useInfiniteEffectSuspenseQuery.ts

@@ -1,6 +1,6 @@
 import type { InfiniteData, QueryFunctionContext, QueryKey } from "@tanstack/react-query";
 import { useSuspenseInfiniteQuery } from "@tanstack/react-query";
-import type { Effect, ManagedRuntime, Runtime } from "effect";
+import type { Context, Effect, ManagedRuntime } from "effect";
 import { createEffectQueryFn } from "./internal/createEffectQueryFn";
 import type {
   UseInfiniteEffectSuspenseQueryOptions,
@@ -61,7 +61,7 @@ export function useInfiniteEffectSuspenseQuery<
     queryFn: (
       context: QueryFunctionContext<TQueryKey, TPageParam>,
     ) => Effect.Effect<TQueryFnData, TError, R>;
-    runtime?: Runtime.Runtime<R> | ManagedRuntime.ManagedRuntime<R, unknown>;
+    runtime?: Context.Context<R> | ManagedRuntime.ManagedRuntime<R, unknown>;
   } & Omit<
     UseInfiniteEffectSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam, R>,
     "queryFn" | "runtime"

test/effectQueryOptions.test.ts

@@ -12,10 +12,10 @@ class NetworkError extends Schema.TaggedError<NetworkError>()("NetworkError", {
 }) {}
 
 // Define a service for testing runtime requirements
-class UserService extends Context.Tag("UserService")<
+class UserService extends Context.Service<
   UserService,
   { readonly getUser: (id: string) => Effect.Effect<{ id: string; name: string }, NetworkError> }
->() {}
+>()("UserService") {}
 
 describe("effectQueryOptions", () => {
   it("should export effectQueryOptions", () => {

test/infiniteEffectQueryOptions.test.ts

@@ -14,10 +14,10 @@ interface PostsPage {
 }
 
 // Define a service for testing runtime requirements
-class PostService extends Context.Tag("PostService")<
+class PostService extends Context.Service<
   PostService,
   { readonly getPosts: (cursor: number) => Effect.Effect<PostsPage, NetworkError> }
->() {}
+>()("PostService") {}
 
 describe("infiniteEffectQueryOptions", () => {
   it("should export infiniteEffectQueryOptions", () => {