effect-query 0.1.0 → 0.1.1

package/README.md

@@ -0,0 +1,24 @@
+<p align="center">
+    <img src="https://github.com/voidhashcom/effect-query/raw/main/banner.png" alt="Effect Query Logo">
+</p>
+
+# Effect Query
+
+Integration of Effect-ts with Tanstack Query. Run your Effects from Tanstack Query. Fully type-safe and compatible with Effect RPC and Effect HttpApi.
+
+## Quick Start
+
+```bash
+# Install the package
+npm install effect-query
+
+# Install peer dependencies (if not already installed)
+npm install @tanstack/react-query effect
+
+```
+
+### Read the full documentation [here](https://github.com/voidhashcom/effect-query)
+
+<p align="center">
+  Made with ❤️ by <a href="https://voidhash.com">Voidhash</a>
+</p>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-query",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Effect adapter for Tanstack Query",
   "repository": {
     "type": "git",
@@ -20,7 +20,6 @@
   },
   "files": [
     "dist",
-    "src",
     "README.md",
     "package.json",
     "!**/*.test.*",

package/src/errors.ts

@@ -1,74 +0,0 @@
-import { Cause } from "effect";
-
-const EffectQueryFailureTag = "EffectQueryFailure" as const;
-const EffectQueryDefectTag = "EffectQueryDefect" as const;
-
-type EffectQueryErrorMatcher<
-  TFailure extends { _tag: string } | never = never,
-  TReturn = unknown,
-> = {
-  OrElse: (cause: Cause.Cause<unknown>) => TReturn;
-} & ([TFailure] extends [never]
-  ? Record<never, never>
-  : TFailure extends { _tag: string }
-    ? {
-        [K in TFailure["_tag"]]?: (
-          failure: Extract<TFailure, { _tag: K }>
-        ) => TReturn;
-      }
-    : Record<never, never>);
-
-export class EffectQueryFailure<
-  TFailure extends { _tag: string } | never = never,
-> extends Error {
-  readonly _tag: typeof EffectQueryFailureTag;
-  readonly failure: TFailure;
-  readonly failureCause: Cause.Cause<TFailure>;
-  constructor(
-    message: string,
-    failure: TFailure,
-    cause: Cause.Cause<TFailure>
-  ) {
-    super(message);
-    this._tag = EffectQueryFailureTag;
-    this.failure = failure;
-    this.failureCause = cause;
-  }
-
-  match<TReturn>(
-    matcher: EffectQueryErrorMatcher<
-      TFailure extends { _tag: string } ? TFailure : never,
-      TReturn
-    >
-  ): TReturn {
-    if (
-      this.failure &&
-      typeof this.failure === "object" &&
-      "_tag" in this.failure
-    ) {
-      const tag = this.failure._tag;
-      // biome-ignore lint/suspicious/noExplicitAny: Dynamic tag matching requires any
-      const handler = (matcher as any)[tag];
-      if (typeof handler === "function") {
-        return handler(this.failure);
-      }
-    }
-    return matcher.OrElse(this.failureCause);
-  }
-}
-
-export class EffectQueryDefect<TDefect> extends Error {
-  readonly _tag: typeof EffectQueryDefectTag;
-  readonly defectCause: Cause.Cause<TDefect>;
-  constructor(message: string, defect: TDefect) {
-    super(message);
-    this._tag = EffectQueryDefectTag;
-    this.defectCause = Cause.die(defect);
-  }
-
-  match<TReturn>(
-    matcher: EffectQueryErrorMatcher<never, TReturn> & Record<string, unknown>
-  ): TReturn {
-    return matcher.OrElse(this.defectCause);
-  }
-}

package/src/index.ts

@@ -1,86 +0,0 @@
-import { type Layer, ManagedRuntime } from "effect";
-import {
-  type EffectInfiniteQueryOptionsInput,
-  effectInfiniteQueryOptions,
-} from "./infiniteQueryOptions";
-import {
-  type EffectQueryMutationOptionsInput,
-  effectQueryMutationOptions,
-} from "./mutationOptions";
-import {
-  type EffectQueryOptionsInput,
-  effectQueryQueryOptions,
-} from "./queryOptions";
-import { EffectQueryRunner } from "./runner";
-
-export function createEffectQuery<Input>(
-  layer: Layer.Layer<Input, never, never>
-) {
-  const runtime = ManagedRuntime.make(layer);
-  const runner = new EffectQueryRunner(runtime);
-
-  return {
-    queryOptions: <
-      TFnResult,
-      TFnErrorResult extends { _tag: string },
-      TFnRequirements,
-    >(
-      options: EffectQueryOptionsInput<
-        TFnResult,
-        TFnErrorResult,
-        TFnRequirements
-      >
-    ) =>
-      effectQueryQueryOptions<
-        typeof runtime,
-        TFnResult,
-        TFnErrorResult,
-        TFnRequirements
-      >(
-        {
-          queryKey: options.queryKey,
-          queryFn: options.queryFn,
-        },
-        {
-          runner,
-        }
-      ),
-    infiniteQueryOptions: <
-      TFnResult,
-      TFnErrorResult extends { _tag: string },
-      TFnRequirements,
-    >(
-      options: EffectInfiniteQueryOptionsInput<
-        TFnResult,
-        TFnErrorResult,
-        TFnRequirements
-      >
-    ) =>
-      effectInfiniteQueryOptions<
-        typeof runtime,
-        TFnResult,
-        TFnErrorResult,
-        TFnRequirements
-      >(options, { runner }),
-    mutationOptions: <
-      TFnResult,
-      TFnErrorResult extends { _tag: string },
-      TFnRequirements,
-      TVariables,
-    >(
-      options: EffectQueryMutationOptionsInput<
-        TFnResult,
-        TFnErrorResult,
-        TFnRequirements,
-        TVariables
-      >
-    ) =>
-      effectQueryMutationOptions<
-        typeof runtime,
-        TFnResult,
-        TFnErrorResult,
-        TFnRequirements,
-        TVariables
-      >(options, { runner }),
-  };
-}

package/src/infiniteQueryOptions.ts

@@ -1,144 +0,0 @@
-import {
-  type DefinedInitialDataInfiniteOptions,
-  type InfiniteData,
-  infiniteQueryOptions,
-  type QueryFunctionContext,
-  type SkipToken,
-  type UndefinedInitialDataInfiniteOptions,
-  type UnusedSkipTokenInfiniteOptions,
-  type UseInfiniteQueryOptions,
-} from "@tanstack/react-query";
-import { Cause, type Effect, Exit } from "effect";
-import type { ManagedRuntime } from "effect/ManagedRuntime";
-import { EffectQueryDefect, EffectQueryFailure } from "./errors";
-import type { EffectQueryRunner } from "./runner";
-import type { EffectQueryQueryKey } from "./types";
-
-type EffectInfiniteQueryQueryFn<
-  TFnResult,
-  TFnErrorResult,
-  TFnRequirements,
-  TQueryKey extends EffectQueryQueryKey = EffectQueryQueryKey,
-  TPageParam = never,
-> = (
-  context: QueryFunctionContext<TQueryKey, TPageParam>
-) => Effect.Effect<TFnResult, TFnErrorResult, TFnRequirements>;
-
-type EffectInfiniteQueryUndefinedInitialDataOptions<
-  TQueryFnData,
-  TError,
-  TData = InfiniteData<TQueryFnData, unknown>,
-  TQueryKey extends EffectQueryQueryKey = EffectQueryQueryKey,
-> = UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey>;
-
-type EffectInfiniteQueryUnusedSkipTokenOptions<
-  TQueryFnData,
-  TError,
-  TData = InfiniteData<TQueryFnData, unknown>,
-  TQueryKey extends EffectQueryQueryKey = EffectQueryQueryKey,
-> = UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey>;
-
-type EffectInfiniteQueryDefinedInitialDataOptions<
-  TQueryFnData,
-  TError,
-  TData = InfiniteData<TQueryFnData, unknown>,
-  TQueryKey extends EffectQueryQueryKey = EffectQueryQueryKey,
-> = DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey>;
-
-export type EffectInfiniteQueryOptionsInput<
-  TFnResult,
-  TFnErrorResult,
-  TFnRequirements,
-  TQueryKey extends EffectQueryQueryKey = EffectQueryQueryKey,
-> = Omit<
-  | EffectInfiniteQueryUndefinedInitialDataOptions<
-      TFnResult,
-      TFnErrorResult,
-      TFnResult,
-      TQueryKey
-    >
-  | EffectInfiniteQueryDefinedInitialDataOptions<
-      TFnResult,
-      TFnErrorResult,
-      TFnResult,
-      TQueryKey
-    >
-  | EffectInfiniteQueryUnusedSkipTokenOptions<
-      TFnResult,
-      TFnErrorResult,
-      TFnResult,
-      TQueryKey
-    >,
-  "queryFn" | "queryKey"
-> & {
-  queryKey: EffectQueryQueryKey;
-  queryFn: EffectInfiniteQueryQueryFn<
-    TFnResult,
-    TFnErrorResult,
-    TFnRequirements,
-    EffectQueryQueryKey
-  >;
-};
-
-/**
- * @internal
- */
-export function effectInfiniteQueryOptions<
-  // biome-ignore lint/suspicious/noExplicitAny: generic
-  TManagedRuntime extends ManagedRuntime<any, never>,
-  TFnResult,
-  TFnErrorResult extends { _tag: string },
-  TFnRequirements,
->(
-  inputOptions: EffectInfiniteQueryOptionsInput<
-    TFnResult,
-    TFnErrorResult,
-    TFnRequirements
-  >,
-  context: {
-    runner: EffectQueryRunner<TManagedRuntime>;
-    signal?: AbortSignal;
-  }
-) {
-  const [spanName] = inputOptions.queryKey;
-
-  const queryFn: Exclude<
-    UseInfiniteQueryOptions<
-      TFnResult,
-      TFnErrorResult,
-      InfiniteData<TFnResult, unknown>,
-      EffectQueryQueryKey,
-      unknown
-    >["queryFn"],
-    SkipToken | undefined
-  > = async (queryFnContext) => {
-    const effect = inputOptions.queryFn(queryFnContext);
-    const result = await context.runner.run(effect, spanName, {
-      signal: context.signal,
-    });
-    return Exit.match(result, {
-      onSuccess: (value) => value,
-      onFailure: (cause) => {
-        if (cause._tag === "Fail") {
-          const failure = cause.error;
-          throw new EffectQueryFailure(Cause.pretty(cause), failure, cause);
-        }
-        throw new EffectQueryDefect(Cause.pretty(cause), cause);
-      },
-    });
-  };
-
-  // The as UseQueryOptions is a workaround to set the correct error type. React Query has no way to infer the error type from the Effect.
-  return infiniteQueryOptions({
-    ...inputOptions,
-    queryKey: inputOptions.queryKey as EffectQueryQueryKey,
-    queryFn,
-  }) as UseInfiniteQueryOptions<
-    TFnResult,
-    [TFnErrorResult] extends [never]
-      ? EffectQueryDefect<unknown>
-      : EffectQueryFailure<TFnErrorResult> | EffectQueryDefect<unknown>,
-    TFnResult,
-    EffectQueryQueryKey
-  >;
-}

package/src/mutationOptions.ts

@@ -1,97 +0,0 @@
-import {
-  type MutationFunction,
-  mutationOptions,
-  type skipToken,
-  type UseMutationOptions,
-} from "@tanstack/react-query";
-import { Cause, type Effect, Exit } from "effect";
-import type { ManagedRuntime } from "effect/ManagedRuntime";
-import { EffectQueryDefect, EffectQueryFailure } from "./errors";
-import type { EffectQueryRunner } from "./runner";
-
-type EffectfulMutationFunction<
-  TFnResult,
-  TFnErrorResult,
-  TFnRequirements,
-  TVariables,
-> = (
-  variables: TVariables
-) => Effect.Effect<TFnResult, TFnErrorResult, TFnRequirements>;
-
-export type EffectQueryMutationOptionsInput<
-  TFnResult,
-  TFnErrorResult,
-  TFnRequirements,
-  TVariables,
-> = Omit<
-  UseMutationOptions<TFnResult, TFnErrorResult, TVariables>,
-  "mutationKey" | "mutationFn"
-> & {
-  mutationKey: string;
-  mutationFn:
-    | EffectfulMutationFunction<
-        TFnResult,
-        TFnErrorResult,
-        TFnRequirements,
-        TVariables
-      >
-    | typeof skipToken;
-};
-
-/**
- * @internal
- */
-export function effectQueryMutationOptions<
-  // biome-ignore lint/suspicious/noExplicitAny: generic
-  TManagedRuntime extends ManagedRuntime<any, never>,
-  TFnResult,
-  TFnErrorResult extends { _tag: string },
-  TFnRequirements,
-  TVariables,
->(
-  inputOptions: EffectQueryMutationOptionsInput<
-    TFnResult,
-    TFnErrorResult,
-    TFnRequirements,
-    TVariables
-  >,
-  context: {
-    runner: EffectQueryRunner<TManagedRuntime>;
-  }
-) {
-  const spanName = inputOptions.mutationKey;
-  const mutationFn: MutationFunction<TFnResult, TVariables> = async (
-    variables: TVariables
-  ) => {
-    const effect = (
-      inputOptions.mutationFn as EffectfulMutationFunction<
-        TFnResult,
-        TFnErrorResult,
-        TFnRequirements,
-        TVariables
-      >
-    )(variables);
-    const result = await context.runner.run(effect, spanName);
-    return Exit.match(result, {
-      onSuccess: (value) => value,
-      onFailure: (cause) => {
-        if (cause._tag === "Fail") {
-          const failure = cause.error;
-          throw new EffectQueryFailure(Cause.pretty(cause), failure, cause);
-        }
-        throw new EffectQueryDefect(Cause.pretty(cause), cause);
-      },
-    });
-  };
-
-  return mutationOptions({
-    ...inputOptions,
-    mutationFn,
-  }) as UseMutationOptions<
-    TFnResult,
-    [TFnErrorResult] extends [never]
-      ? never
-      : EffectQueryFailure<TFnErrorResult> | EffectQueryDefect<unknown>,
-    TVariables
-  >;
-}

package/src/queryOptions.ts

@@ -1,136 +0,0 @@
-import {
-  type DefinedInitialDataOptions,
-  type QueryFunction,
-  type QueryFunctionContext,
-  queryOptions,
-  type UndefinedInitialDataOptions,
-  type UnusedSkipTokenOptions,
-  type UseQueryOptions,
-} from "@tanstack/react-query";
-import { Cause, type Effect, Exit } from "effect";
-import type { ManagedRuntime } from "effect/ManagedRuntime";
-import { EffectQueryDefect, EffectQueryFailure } from "./errors";
-import type { EffectQueryRunner } from "./runner";
-import type { EffectQueryQueryKey } from "./types";
-
-type EffectQueryQueryFn<
-  TFnResult,
-  TFnErrorResult,
-  TFnRequirements,
-  TQueryKey extends EffectQueryQueryKey = EffectQueryQueryKey,
-  TPageParam = never,
-> = (
-  context: QueryFunctionContext<TQueryKey, TPageParam>
-) => Effect.Effect<TFnResult, TFnErrorResult, TFnRequirements>;
-
-type EffectQueryUndefinedInitialDataOptions<
-  TQueryFnData,
-  TError,
-  TData = TQueryFnData,
-  TQueryKey extends EffectQueryQueryKey = EffectQueryQueryKey,
-> = UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>;
-
-type EffectQueryUnusedSkipTokenOptions<
-  TQueryFnData,
-  TError,
-  TData = TQueryFnData,
-  TQueryKey extends EffectQueryQueryKey = EffectQueryQueryKey,
-> = UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>;
-
-type EffectQueryDefinedInitialDataOptions<
-  TQueryFnData,
-  TError,
-  TData = TQueryFnData,
-  TQueryKey extends EffectQueryQueryKey = EffectQueryQueryKey,
-> = DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>;
-
-export type EffectQueryOptionsInput<
-  TFnResult,
-  TFnErrorResult,
-  TFnRequirements,
-  TQueryKey extends EffectQueryQueryKey = EffectQueryQueryKey,
-> = Omit<
-  | EffectQueryUndefinedInitialDataOptions<
-      TFnResult,
-      TFnErrorResult,
-      TFnResult,
-      TQueryKey
-    >
-  | EffectQueryDefinedInitialDataOptions<
-      TFnResult,
-      TFnErrorResult,
-      TFnResult,
-      TQueryKey
-    >
-  | EffectQueryUnusedSkipTokenOptions<
-      TFnResult,
-      TFnErrorResult,
-      TFnResult,
-      TQueryKey
-    >,
-  "queryFn" | "queryKey"
-> & {
-  queryKey: EffectQueryQueryKey;
-  queryFn: EffectQueryQueryFn<
-    TFnResult,
-    TFnErrorResult,
-    TFnRequirements,
-    EffectQueryQueryKey
-  >;
-};
-
-/**
- * @internal
- */
-export function effectQueryQueryOptions<
-  // biome-ignore lint/suspicious/noExplicitAny: generic
-  TManagedRuntime extends ManagedRuntime<any, never>,
-  TFnResult,
-  TFnErrorResult extends { _tag: string },
-  TFnRequirements,
->(
-  inputOptions: EffectQueryOptionsInput<
-    TFnResult,
-    TFnErrorResult,
-    TFnRequirements
-  >,
-  context: {
-    runner: EffectQueryRunner<TManagedRuntime>;
-    signal?: AbortSignal;
-  }
-) {
-  const [spanName] = inputOptions.queryKey;
-
-  const queryFn: QueryFunction<TFnResult, EffectQueryQueryKey> = async (
-    queryFnContext
-  ) => {
-    const effect = inputOptions.queryFn(queryFnContext);
-    const result = await context.runner.run(effect, spanName, {
-      signal: context.signal,
-    });
-    return Exit.match(result, {
-      onSuccess: (value) => value,
-      onFailure: (cause) => {
-        if (cause._tag === "Fail") {
-          const failure = cause.error;
-          throw new EffectQueryFailure(Cause.pretty(cause), failure, cause);
-        }
-        throw new EffectQueryDefect(Cause.pretty(cause), cause);
-      },
-    });
-  };
-
-  // The as UseQueryOptions is a workaround to set the correct error type. React Query has no way to infer the error type from the Effect.
-  return queryOptions({
-    ...inputOptions,
-    queryKey: inputOptions.queryKey,
-    queryFn,
-  }) as UseQueryOptions<
-    TFnResult,
-    [TFnErrorResult] extends [never]
-      ? EffectQueryDefect<unknown>
-      : EffectQueryFailure<TFnErrorResult> | EffectQueryDefect<unknown>,
-    TFnResult,
-    EffectQueryQueryKey
-  >;
-}

package/src/runner.ts

@@ -1,25 +0,0 @@
-import { Effect, type Exit } from "effect";
-import type { ManagedRuntime } from "effect/ManagedRuntime";
-
-export class EffectQueryRunner<
-  // biome-ignore lint/suspicious/noExplicitAny: generic
-  TManagedRuntime extends ManagedRuntime<any, never>,
-> {
-  readonly runtime: TManagedRuntime;
-  constructor(runtime: TManagedRuntime) {
-    this.runtime = runtime;
-  }
-
-  async run<TResult, TError, TRequirements>(
-    effect: Effect.Effect<TResult, TError, TRequirements>,
-    span: string,
-    options: { signal?: AbortSignal } = {}
-  ): Promise<Exit.Exit<TResult, TError>> {
-    const runnable = Effect.scoped(
-      effect.pipe(Effect.withSpan(span), Effect.tapErrorCause(Effect.logError))
-    );
-    return await this.runtime.runPromiseExit(runnable, {
-      signal: options.signal,
-    });
-  }
-}

package/src/types.ts

@@ -1,5 +0,0 @@
-export type EffectQueryQueryKey = readonly [
-  string,
-  string,
-  Record<string, unknown>?,
-];