@effectify/solid-query 0.4.5 → 0.4.6

package/dist/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@effectify/solid-query",
+  "version": "0.4.5",
+  "description": "Integration of Effect with TanStack Query for Solid.js",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "@effectify/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "dependencies": {
+    "tslib": "catalog:",
+    "@tanstack/solid-query": "catalog:",
+    "@tanstack/query-core": "catalog:",
+    "effect": "catalog:",
+    "solid-js": "catalog:"
+  },
+  "devDependencies": {
+    "typescript": "catalog:"
+  },
+  "optionalDependencies": {},
+  "peerDependencies": {}
+}

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from './lib/internal/query-data-helpers.js';
+export * from './lib/tanstack-query-effect.jsx';
+export * from './lib/types.js';

package/dist/src/index.js

@@ -0,0 +1,5 @@
+export * from './lib/internal/query-data-helpers.js';
+export * from './lib/tanstack-query-effect.jsx';
+export * from './lib/types.js';
+// Testing release workflow with changelog generation
+// This should only affect solid-query package

package/dist/src/lib/internal/make-use-effect-mutation.d.ts

@@ -0,0 +1,3 @@
+import { type UseMutationResult } from '@tanstack/solid-query';
+import type { EffectfulError, EffectfulMutationOptions, Runner } from '../types.js';
+export declare const makeUseEffectMutation: <R>(createRunner: Runner<R>) => <TData, TError extends EffectfulError, TVariables>(options: EffectfulMutationOptions<TData, TError, TVariables, R>) => UseMutationResult<TData, Error, TVariables>;

package/dist/src/lib/internal/make-use-effect-mutation.js

@@ -0,0 +1,13 @@
+import { useMutation } from '@tanstack/solid-query';
+export const makeUseEffectMutation = (createRunner) => (options) => {
+    const effectRunner = createRunner();
+    const [spanName] = options.mutationKey;
+    const mutationFn = () => (variables) => {
+        const effect = options.mutationFn(variables);
+        return effectRunner()(spanName)(effect);
+    };
+    return useMutation(() => ({
+        ...options,
+        mutationFn: mutationFn(),
+    }));
+};

package/dist/src/lib/internal/make-use-effect-query.d.ts

@@ -0,0 +1,3 @@
+import { type UseQueryResult } from '@tanstack/solid-query';
+import type { EffectfulError, EffectfulQueryOptions, QueryKey, Runner } from '../types.js';
+export declare const makeUseEffectQuery: <R>(createRunner: Runner<R>) => <TData, TError extends EffectfulError, TQueryKey extends QueryKey = QueryKey>({ gcTime, staleTime, ...options }: EffectfulQueryOptions<TData, TError, R, TQueryKey>) => UseQueryResult<TData, Error>;

package/dist/src/lib/internal/make-use-effect-query.js

@@ -0,0 +1,21 @@
+import { skipToken } from '@tanstack/query-core';
+import { useQuery } from '@tanstack/solid-query';
+import * as Duration from 'effect/Duration';
+import { createMemo } from 'solid-js';
+export const makeUseEffectQuery = (createRunner) => ({ gcTime, staleTime, ...options }) => {
+    const effectRunner = createRunner();
+    const [spanName] = options.queryKey;
+    const queryFn = createMemo(() => (context) => {
+        const effect = options.queryFn(context);
+        return effect.pipe(effectRunner()(spanName));
+    })();
+    return useQuery(() => ({
+        ...options,
+        queryKey: options.queryKey, // Aseguramos que queryKey es no-undefined
+        queryFn: options.queryFn === skipToken ? skipToken : queryFn,
+        ...(staleTime !== undefined && {
+            staleTime: Duration.toMillis(staleTime),
+        }),
+        ...(gcTime !== undefined && { gcTime: Duration.toMillis(gcTime) }),
+    }));
+};

package/dist/src/lib/internal/make-use-rx-subsciption-ref.d.ts

@@ -0,0 +1,6 @@
+import * as Effect from 'effect/Effect';
+import type * as ManagedRuntime from 'effect/ManagedRuntime';
+import * as SubscriptionRef from 'effect/SubscriptionRef';
+import { type Context } from 'solid-js';
+import type { Subscribable, SubscriptionOptions } from '../types.js';
+export declare const makeUseRxSubscriptionRef: <R, E>(RuntimeContext: Context<ManagedRuntime.ManagedRuntime<R, E> | null>) => <A, E2>(subscribable: Subscribable<A, E2> | Effect.Effect<Subscribable<A, E2>, never, R> | Effect.Effect<SubscriptionRef.SubscriptionRef<A>, never, R>, onNext: (value: A) => void, opts?: SubscriptionOptions) => A;

package/dist/src/lib/internal/make-use-rx-subsciption-ref.js

@@ -0,0 +1,53 @@
+import * as Effect from 'effect/Effect';
+import * as Fiber from 'effect/Fiber';
+import * as Stream from 'effect/Stream';
+import * as SubscriptionRef from 'effect/SubscriptionRef';
+import { createEffect, createSignal, onCleanup, useContext } from 'solid-js';
+export const makeUseRxSubscriptionRef = (RuntimeContext) => (subscribable, onNext, opts) => {
+    const options = {
+        skipInitial: opts?.skipInitial ?? true,
+    };
+    const runtime = useContext(RuntimeContext);
+    if (!runtime) {
+        throw new Error('Runtime context not found. Make sure to wrap your app with RuntimeProvider');
+    }
+    const setInitialValue = () => {
+        const initialValue = Effect.gen(function* () {
+            const resolved = Effect.isEffect(subscribable) ? yield* subscribable : subscribable;
+            const resolvedValue = SubscriptionRef.SubscriptionRefTypeId in resolved ? yield* SubscriptionRef.get(resolved) : resolved.get();
+            if (!options?.skipInitial) {
+                onNext(resolvedValue);
+            }
+            return resolvedValue;
+        });
+        const newVal = runtime.runSync(initialValue);
+        return newVal;
+    };
+    const [value, setValue] = createSignal(setInitialValue());
+    createEffect(() => {
+        const fiber = Effect.gen(function* () {
+            const resolved = Effect.isEffect(subscribable) ? yield* subscribable : subscribable;
+            const adaptedSubscribable = SubscriptionRef.SubscriptionRefTypeId in resolved
+                ? {
+                    changes: resolved.changes,
+                    get: () => runtime.runSync(SubscriptionRef.get(resolved)),
+                }
+                : resolved;
+            const currentValue = adaptedSubscribable.get();
+            setValue(() => currentValue);
+            let hasEmittedInitial = false;
+            return yield* adaptedSubscribable.changes.pipe(Stream.tap((val) => Effect.sync(() => {
+                setValue(() => val);
+                if (options?.skipInitial && !hasEmittedInitial) {
+                    hasEmittedInitial = true;
+                    return;
+                }
+                onNext(val);
+            })), Stream.runDrain, Effect.forever, Effect.forkDaemon);
+        }).pipe(runtime.runSync);
+        onCleanup(() => {
+            runtime.runCallback(Fiber.interrupt(fiber));
+        });
+    });
+    return value();
+};

package/dist/src/lib/internal/make-use-rx-subscribe.d.ts

@@ -0,0 +1,5 @@
+import * as Effect from 'effect/Effect';
+import type * as ManagedRuntime from 'effect/ManagedRuntime';
+import * as Stream from 'effect/Stream';
+import { type Context } from 'solid-js';
+export declare const makeUseRxSubscribe: <R, E>(RuntimeContext: Context<ManagedRuntime.ManagedRuntime<R, E> | null>) => <E2, A>(stream: Stream.Stream<A, E2, R> | Effect.Effect<Stream.Stream<A, E2, R>, E2, R>, initialValue: A, onNext: (value: A) => void, onError?: (error: E2) => void) => import("solid-js").Accessor<A | undefined>;

package/dist/src/lib/internal/make-use-rx-subscribe.js

@@ -0,0 +1,37 @@
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
+import * as Fiber from 'effect/Fiber';
+import * as Stream from 'effect/Stream';
+import { createSignal, onCleanup, useContext } from 'solid-js';
+export const makeUseRxSubscribe = (RuntimeContext) => {
+    return (stream, initialValue, onNext, onError) => {
+        const runtime = useContext(RuntimeContext);
+        if (!runtime) {
+            throw new Error('Runtime context not found. Make sure to wrap your app with RuntimeProvider');
+        }
+        const [value, setValue] = createSignal(initialValue);
+        const [fiberRef, setFiberRef] = createSignal(null);
+        const finalStream = Effect.isEffect(stream) ? Stream.unwrap(stream) : stream;
+        const subscription = finalStream.pipe(Stream.tap((a) => Effect.sync(() => {
+            setValue(() => a);
+            onNext(a);
+        })), Stream.catchAll((e) => Stream.fromEffect(Effect.sync(() => {
+            onError?.(e);
+            return;
+        }))), Stream.runDrain, Effect.forever, Effect.forkDaemon);
+        runtime.runCallback(subscription, {
+            onExit: (exit) => {
+                if (Exit.isSuccess(exit)) {
+                    setFiberRef(exit.value);
+                }
+            },
+        });
+        onCleanup(() => {
+            if (fiberRef() !== null) {
+                // biome-ignore lint/style/noNonNullAssertion: <testing>
+                runtime.runCallback(Fiber.interrupt(fiberRef()));
+            }
+        });
+        return value;
+    };
+};

package/dist/src/lib/internal/query-data-helpers.d.ts

@@ -0,0 +1,75 @@
+import type { QueryClient } from '@tanstack/query-core';
+type DeepMutable<T> = {
+    -readonly [P in keyof T]: T[P] extends object ? DeepMutable<T[P]> : T[P];
+};
+export type QueryDataUpdater<TData> = (draft: DeepMutable<TData>) => void;
+type QueryKey<TKey extends string, TVariables = void> = TVariables extends void ? readonly [TKey] : readonly [TKey, TVariables];
+/**
+ * Creates a type-safe query key factory that can be used with or without variables
+ * @template TKey The string literal type for the query key
+ * @template TVariables Optional variables type. If not provided, the factory will not accept variables
+ * @param key The query key string
+ * @returns A function that creates a query key tuple
+ *
+ * @example Without variables:
+ * ```typescript
+ * const userKey = createQueryKey("user");
+ * const key = userKey(); // returns ["user"]
+ * ```
+ *
+ * @example With variables:
+ * ```typescript
+ * type UserVars = { id: string };
+ * const userKey = createQueryKey<"user", UserVars>("user");
+ * const key = userKey({ id: "123" }); // returns ["user", { id: "123" }]
+ * ```
+ */
+export declare function createQueryKey<TKey extends string, TVariables = void>(key: TKey): TVariables extends void ? () => QueryKey<TKey> : (variables: TVariables) => QueryKey<TKey, TVariables>;
+type QueryDataHelpers<TData, TVariables> = {
+    removeQuery: (variables: TVariables) => void;
+    removeAllQueries: () => void;
+    setData: (variables: TVariables, updater: QueryDataUpdater<TData>) => TData | undefined;
+    invalidateQuery: (variables: TVariables) => Promise<void>;
+    invalidateAllQueries: () => Promise<void>;
+    refetchQuery: (variables: TVariables) => Promise<void>;
+    refetchAllQueries: () => Promise<void>;
+};
+/**
+ * Creates a set of helpers to manage query data in the cache
+ * @template TData The type of data stored in the query
+ * @template TVariables Automatically inferred from the queryKey function parameter
+ * @param queryKey A function that creates a query key tuple from variables
+ * @returns An object with methods to remove, update, invalidate, and invalidate all query data
+ *
+ * @example Without variables:
+ * ```typescript
+ * const userKey = createQueryKey("user");
+ * type User = { name: string };
+ *
+ * // Types are inferred from userKey
+ * const helpers = createQueryDataHelpers<User>(userKey);
+ * helpers.setData(undefined, (draft) => {
+ *   draft.name = "New Name";
+ * });
+ * ```
+ *
+ * @example With variables and explicit types:
+ * ```typescript
+ * type UserVars = { id: string };
+ * type User = { id: string; name: string };
+ *
+ * const userKey = createQueryKey<"user", UserVars>("user");
+ * const helpers = createQueryDataHelpers<User, UserVars>(userKey);
+ *
+ * helpers.setData({ id: "123" }, (draft) => {
+ *   draft.name = "New Name";
+ * });
+ *
+ * // Other helper methods
+ * await helpers.invalidateQuery({ id: "123" });
+ * await helpers.refetchQuery({ id: "123" });
+ * helpers.removeQuery({ id: "123" });
+ * ```
+ */
+export declare const makeCreateQueryDataHelpers: (queryClient: QueryClient) => <TData, TVariables = void>(queryKey: (variables: TVariables) => readonly [string, ...unknown[]]) => QueryDataHelpers<TData, TVariables>;
+export {};

package/dist/src/lib/internal/query-data-helpers.js

@@ -0,0 +1,107 @@
+// Simple deep clone function to replace mutative
+function deepClone(obj) {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    if (obj instanceof Date) {
+        return new Date(obj.getTime());
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => deepClone(item));
+    }
+    if (typeof obj === 'object') {
+        const cloned = {};
+        for (const key in obj) {
+            if (Object.hasOwn(obj, key)) {
+                cloned[key] = deepClone(obj[key]);
+            }
+        }
+        return cloned;
+    }
+    return obj;
+}
+/**
+ * Creates a type-safe query key factory that can be used with or without variables
+ * @template TKey The string literal type for the query key
+ * @template TVariables Optional variables type. If not provided, the factory will not accept variables
+ * @param key The query key string
+ * @returns A function that creates a query key tuple
+ *
+ * @example Without variables:
+ * ```typescript
+ * const userKey = createQueryKey("user");
+ * const key = userKey(); // returns ["user"]
+ * ```
+ *
+ * @example With variables:
+ * ```typescript
+ * type UserVars = { id: string };
+ * const userKey = createQueryKey<"user", UserVars>("user");
+ * const key = userKey({ id: "123" }); // returns ["user", { id: "123" }]
+ * ```
+ */
+export function createQueryKey(key) {
+    return ((variables) => variables === undefined ? [key] : [key, variables]);
+}
+/**
+ * Creates a set of helpers to manage query data in the cache
+ * @template TData The type of data stored in the query
+ * @template TVariables Automatically inferred from the queryKey function parameter
+ * @param queryKey A function that creates a query key tuple from variables
+ * @returns An object with methods to remove, update, invalidate, and invalidate all query data
+ *
+ * @example Without variables:
+ * ```typescript
+ * const userKey = createQueryKey("user");
+ * type User = { name: string };
+ *
+ * // Types are inferred from userKey
+ * const helpers = createQueryDataHelpers<User>(userKey);
+ * helpers.setData(undefined, (draft) => {
+ *   draft.name = "New Name";
+ * });
+ * ```
+ *
+ * @example With variables and explicit types:
+ * ```typescript
+ * type UserVars = { id: string };
+ * type User = { id: string; name: string };
+ *
+ * const userKey = createQueryKey<"user", UserVars>("user");
+ * const helpers = createQueryDataHelpers<User, UserVars>(userKey);
+ *
+ * helpers.setData({ id: "123" }, (draft) => {
+ *   draft.name = "New Name";
+ * });
+ *
+ * // Other helper methods
+ * await helpers.invalidateQuery({ id: "123" });
+ * await helpers.refetchQuery({ id: "123" });
+ * helpers.removeQuery({ id: "123" });
+ * ```
+ */
+export const makeCreateQueryDataHelpers = (queryClient) => (queryKey) => {
+    const [namespaceKey] = queryKey(undefined);
+    return {
+        removeQuery: (variables) => {
+            queryClient.removeQueries({ queryKey: queryKey(variables) });
+        },
+        removeAllQueries: () => {
+            queryClient.removeQueries({ queryKey: [namespaceKey], exact: false });
+        },
+        setData: (variables, updater) => {
+            return queryClient.setQueryData(queryKey(variables), (oldData) => {
+                if (oldData === undefined) {
+                    return oldData;
+                }
+                const clonedData = deepClone(oldData);
+                updater(clonedData);
+                return clonedData;
+            });
+        },
+        invalidateQuery: (variables) => queryClient.invalidateQueries({ queryKey: queryKey(variables) }),
+        invalidateAllQueries: () => queryClient.invalidateQueries({ queryKey: [namespaceKey], exact: false }),
+        refetchQuery: (variables) => queryClient.refetchQueries({ queryKey: queryKey(variables) }),
+        refetchAllQueries: () => queryClient.refetchQueries({ queryKey: [namespaceKey], exact: false }),
+    };
+};

package/dist/src/lib/tanstack-query-effect.d.ts

@@ -0,0 +1,28 @@
+import { type QueryClient } from '@tanstack/solid-query';
+import * as Effect from 'effect/Effect';
+import type * as Layer from 'effect/Layer';
+import * as ManagedRuntime from 'effect/ManagedRuntime';
+import { type Component, type JSX } from 'solid-js';
+export declare const tanstackQueryEffect: <R, E>({ layer, queryClient, }: {
+    layer: Layer.Layer<R, E, never>;
+    queryClient: QueryClient;
+}) => {
+    useRunner: () => import("solid-js").Accessor<(<A, E2>(span: string) => (effect: Effect.Effect<A, E2, R>) => Promise<A>)>;
+    RuntimeProvider: Component<{
+        children: JSX.Element;
+    }>;
+    useRuntime: () => ManagedRuntime.ManagedRuntime<R, E>;
+    useEffectQuery: <TData, TError extends import("./types.js").EffectfulError, TQueryKey extends import("./types.js").QueryKey = import("./types.js").QueryKey>({ gcTime, staleTime, ...options }: import("./types.js").EffectfulQueryOptions<TData, TError, R, TQueryKey>) => import("@tanstack/solid-query").UseQueryResult<TData, Error>;
+    useEffectMutation: <TData, TError_1 extends import("./types.js").EffectfulError, TVariables>(options: import("./types.js").EffectfulMutationOptions<TData, TError_1, TVariables, R>) => import("@tanstack/solid-query").UseMutationResult<TData, Error, TVariables>;
+    useRxSubscribe: <E2_1, A>(stream: import("effect/Stream").Stream<A, E2_1, R> | Effect.Effect<import("effect/Stream").Stream<A, E2_1, R>, E2_1, R>, initialValue: A, onNext: (value: A) => void, onError?: ((error: E2_1) => void) | undefined) => import("solid-js").Accessor<A | undefined>;
+    useRxSubscriptionRef: <A_1, E2_1>(subscribable: import("./types.js").Subscribable<A_1, E2_1> | Effect.Effect<import("./types.js").Subscribable<A_1, E2_1>, never, R> | Effect.Effect<import("effect/SubscriptionRef").SubscriptionRef<A_1>, never, R>, onNext: (value: A_1) => void, opts?: import("./types.js").SubscriptionOptions) => A_1;
+    createQueryDataHelpers: <TData, TVariables_1 = void>(queryKey: (variables: TVariables_1) => readonly [string, ...unknown[]]) => {
+        removeQuery: (variables: TVariables_1) => void;
+        removeAllQueries: () => void;
+        setData: (variables: TVariables_1, updater: import("./internal/query-data-helpers.js").QueryDataUpdater<TData>) => TData | undefined;
+        invalidateQuery: (variables: TVariables_1) => Promise<void>;
+        invalidateAllQueries: () => Promise<void>;
+        refetchQuery: (variables: TVariables_1) => Promise<void>;
+        refetchAllQueries: () => Promise<void>;
+    };
+};

package/dist/src/lib/tanstack-query-effect.jsx

@@ -0,0 +1,45 @@
+import { QueryClientProvider } from '@tanstack/solid-query';
+import * as Effect from 'effect/Effect';
+import * as ManagedRuntime from 'effect/ManagedRuntime';
+import { createContext, createMemo, onCleanup, useContext } from 'solid-js';
+import { makeUseEffectMutation } from './internal/make-use-effect-mutation.js';
+import { makeUseEffectQuery } from './internal/make-use-effect-query.js';
+import { makeUseRxSubscriptionRef } from './internal/make-use-rx-subsciption-ref.js';
+import { makeUseRxSubscribe } from './internal/make-use-rx-subscribe.js';
+import { makeCreateQueryDataHelpers } from './internal/query-data-helpers.js';
+export const tanstackQueryEffect = ({ layer, queryClient, }) => {
+    const RuntimeContext = createContext(null);
+    const useRunner = () => {
+        const runtime = useContext(RuntimeContext);
+        if (!runtime) {
+            throw new Error('Runtime context not found. Make sure to wrap your app with RuntimeProvider');
+        }
+        return createMemo(() => (span) => (effect) => effect.pipe(Effect.withSpan(span), Effect.tapErrorCause(Effect.logError), runtime.runPromise));
+    };
+    const RuntimeProvider = (props) => {
+        const runtime = ManagedRuntime.make(layer);
+        onCleanup(() => {
+            runtime.dispose();
+        });
+        return (<RuntimeContext.Provider value={runtime}>
+        <QueryClientProvider client={queryClient}>{props.children}</QueryClientProvider>
+      </RuntimeContext.Provider>);
+    };
+    const useRuntime = () => {
+        const runtime = useContext(RuntimeContext);
+        if (!runtime) {
+            throw new Error('Runtime context not found. Make sure to wrap your app with RuntimeProvider');
+        }
+        return runtime;
+    };
+    return {
+        useRunner,
+        RuntimeProvider,
+        useRuntime,
+        useEffectQuery: makeUseEffectQuery(useRunner),
+        useEffectMutation: makeUseEffectMutation(useRunner),
+        useRxSubscribe: makeUseRxSubscribe(RuntimeContext),
+        useRxSubscriptionRef: makeUseRxSubscriptionRef(RuntimeContext),
+        createQueryDataHelpers: makeCreateQueryDataHelpers(queryClient),
+    };
+};

package/dist/src/lib/types.d.ts

@@ -0,0 +1,31 @@
+import type { QueryFunctionContext, skipToken } from '@tanstack/query-core';
+import type { UseMutationOptions, UseQueryOptions } from '@tanstack/solid-query';
+import type { DurationInput } from 'effect/Duration';
+import type * as Effect from 'effect/Effect';
+import type * as Stream from 'effect/Stream';
+import type { Accessor } from 'solid-js';
+export type QueryKey = readonly [string, Record<string, unknown>?];
+export type EffectfulError = {
+    _tag: string;
+};
+export type Runner<R> = () => Accessor<(<A, E>(span: string) => (effect: Effect.Effect<A, E, R>) => Promise<A>)>;
+export type EffectfulMutationOptions<TData, TError extends EffectfulError, TVariables, R> = Omit<UseMutationOptions<TData, Error, TVariables>, // Actualizado a UseMutationOptions
+// Actualizado a UseMutationOptions
+'mutationFn' | 'onSuccess' | 'onError' | 'onSettled' | 'onMutate' | 'retry' | 'retryDelay'> & {
+    mutationKey: QueryKey;
+    mutationFn: (variables: TVariables) => Effect.Effect<TData, TError, R>;
+};
+export type EffectfulQueryFunction<TData, TError, TQueryKey extends QueryKey = QueryKey, R = never, TPageParam = never> = (context: QueryFunctionContext<TQueryKey, TPageParam>) => Effect.Effect<TData, TError, R>;
+export type EffectfulQueryOptions<TData, TError, R, TQueryKey extends QueryKey = QueryKey, TPageParam = never> = Omit<UseQueryOptions<TData, Error, TData, TQueryKey>, 'queryKey' | 'queryFn' | 'retry' | 'retryDelay' | 'staleTime' | 'gcTime'> & {
+    queryKey: TQueryKey;
+    queryFn: EffectfulQueryFunction<TData, TError, TQueryKey, R, TPageParam> | typeof skipToken;
+    staleTime?: DurationInput;
+    gcTime?: DurationInput;
+};
+export interface Subscribable<A, E = never> {
+    readonly changes: Stream.Stream<A, E>;
+    readonly get: () => A;
+}
+export interface SubscriptionOptions {
+    readonly skipInitial?: boolean;
+}

package/dist/src/lib/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effectify/solid-query",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "description": "Integration of Effect with TanStack Query for Solid.js",
   "type": "module",
   "main": "./dist/index.js",