@raf-query/core 0.9.1 → 0.9.2

package/CHANGELOG.md

@@ -1,14 +1,20 @@
 # Changelog
 
+## [0.9.2](https://github.com/KATT/raf-query/compare/0.9.1...0.9.2) (2026-10-15)
+
+### Bug Fixes
+
+* **core:** keep handles of factories with the same signature apart ([#167](https://github.com/KATT/raf-query/issues/167)) ([5894bcb](https://github.com/KATT/raf-query/commit/5894bcbcc382c60e9c04768c0e178bf0996f4b45))
+
 ## [0.9.1](https://github.com/KATT/raf-query/compare/0.9.0...0.9.1) (2026-10-15)
 
 ### Features
 
-* **react:** add @raf-query/react/react-router for React Router Framework Mode ([#146](https://github.com/KATT/raf-query/issues/146)) ([4e02c80](https://github.com/KATT/raf-query/commit/4e02c809d8be1eea33935c9f0b6abc38cbdce25c)), references [#130](https://github.com/KATT/raf-query/issues/130) [#148](https://github.com/KATT/raf-query/issues/148) [#148](https://github.com/KATT/raf-query/issues/148)
+- **react:** add @raf-query/react/react-router for React Router Framework Mode ([#146](https://github.com/KATT/raf-query/issues/146)) ([4e02c80](https://github.com/KATT/raf-query/commit/4e02c809d8be1eea33935c9f0b6abc38cbdce25c)), references [#130](https://github.com/KATT/raf-query/issues/130) [#148](https://github.com/KATT/raf-query/issues/148) [#148](https://github.com/KATT/raf-query/issues/148)
 
 ### Miscellaneous Chores
 
-* **lint:** ban member access on use(), in code and Markdown fences ([#155](https://github.com/KATT/raf-query/issues/155)) ([b7b37b4](https://github.com/KATT/raf-query/commit/b7b37b4f6d83c0a232697d05b177c33bdea11df1)), references [#140](https://github.com/KATT/raf-query/issues/140)
+- **lint:** ban member access on use(), in code and Markdown fences ([#155](https://github.com/KATT/raf-query/issues/155)) ([b7b37b4](https://github.com/KATT/raf-query/commit/b7b37b4f6d83c0a232697d05b177c33bdea11df1)), references [#140](https://github.com/KATT/raf-query/issues/140)
 
 ## [0.9.0](https://github.com/KATT/raf-query/compare/0.8.0...0.9.0) (2026-10-15)
 

package/dist/options.d.mts

@@ -2,10 +2,11 @@ import { QueryKey } from "./key.mjs";
 import { Effect, Schedule } from "effect";
 //#region src/options.d.ts
 /**
- * The types of a plain query: what its `queryFn` resolves to, and for an
- * Effect `queryFn`, its error and the services it needs. Leave `error` out
- * and it is `unknown` (promises reject with anything); leave `services` out
- * and it is `never`.
+ * The types of a plain query: what its `queryFn` resolves to, for an Effect
+ * `queryFn` its error and the services it needs, and the shape of its key.
+ * Leave `error` out and it is `unknown` (promises reject with anything);
+ * leave `services` out and it is `never`; leave `key` out and it is any
+ * {@link QueryKey}.
  *
  * ```ts
  * type PostOptions = QueryOptions<{ data: Post }>;
@@ -14,14 +15,16 @@ import { Effect, Schedule } from "effect";
 export interface QueryTypes {
   readonly data: unknown;
   readonly error?: unknown;
+  readonly key?: QueryKey;
   readonly services?: unknown;
 }
 /**
  * The types of a paged query: one page, the param that loads it, and as in
- * {@link QueryTypes}, an Effect `queryFn`'s error and services.
+ * {@link QueryTypes}, an Effect `queryFn`'s error and services and the key.
  */
 export interface InfiniteQueryTypes {
   readonly error?: unknown;
+  readonly key?: QueryKey;
   readonly page: unknown;
   readonly pageParam: unknown;
   readonly services?: unknown;
@@ -34,39 +37,52 @@ type ErrorIn<TTypes> = TTypes extends {
 type ServicesIn<TTypes> = TTypes extends {
   readonly services: infer TServices;
 } ? TServices : never;
+/** `key` of a types bag, any {@link QueryKey} when it has none. */
+type KeyIn<TTypes> = TTypes extends {
+  readonly key: infer TKey extends QueryKey;
+} ? TKey : QueryKey;
 /**
  * The bag `queryOptions` returns. `error` is left out when the `queryFn`
  * doesn't name one (`unknown`: a promise or a plain value). `services` is
  * left out when the `queryFn` needs none (`never`). An Effect's error,
- * including `never` when it can't fail, stays.
+ * including `never` when it can't fail, stays. `key` is always there, so two
+ * factories with different key shapes have different types.
  */
-type QueryTypesOf<TData, TError, TServices> = unknown extends TError ? [TServices] extends [never] ? {
+type QueryTypesOf<TData, TError, TServices, TKey> = unknown extends TError ? [TServices] extends [never] ? {
   data: TData;
+  key: TKey;
 } : {
   data: TData;
+  key: TKey;
   services: TServices;
 } : [TServices] extends [never] ? {
   data: TData;
   error: TError;
+  key: TKey;
 } : {
   data: TData;
   error: TError;
+  key: TKey;
   services: TServices;
 };
 /** As {@link QueryTypesOf}, for a paged query. */
-type InfiniteQueryTypesOf<TPage, TPageParam, TError, TServices> = unknown extends TError ? [TServices] extends [never] ? {
+type InfiniteQueryTypesOf<TPage, TPageParam, TError, TServices, TKey> = unknown extends TError ? [TServices] extends [never] ? {
+  key: TKey;
   page: TPage;
   pageParam: TPageParam;
 } : {
+  key: TKey;
   page: TPage;
   pageParam: TPageParam;
   services: TServices;
 } : [TServices] extends [never] ? {
   error: TError;
+  key: TKey;
   page: TPage;
   pageParam: TPageParam;
 } : {
   error: TError;
+  key: TKey;
   page: TPage;
   pageParam: TPageParam;
   services: TServices;
@@ -165,7 +181,7 @@ interface ServicesField<TServices> {
 export interface QueryOptions<TTypes extends QueryTypes> extends QueryBehavior, ServicesField<ServicesIn<TTypes>> {
   readonly kind: "query";
   queryFn(context: QueryFunctionContext): QueryFnResult<TTypes>;
-  readonly queryKey: QueryKey;
+  readonly queryKey: KeyIn<TTypes>;
 }
 /**
  * The functions of paged options, typed by the page and page param types
@@ -189,7 +205,7 @@ export interface InfiniteQueryOptions<TTypes extends InfiniteQueryTypes> extends
   readonly kind: "infinite";
   /** Keep at most this many pages; the far end is dropped when paging. */
   readonly maxPages?: number;
-  readonly queryKey: QueryKey;
+  readonly queryKey: KeyIn<TTypes>;
 }
 /** Data of a paged query. */
 export interface InfiniteData<TTypes extends Pick<InfiniteQueryTypes, "page" | "pageParam">> {
@@ -223,25 +239,32 @@ export type AnyQueryOptions = QueryOptions<{
  * type. A promise or a plain value has no error to infer, so the type leaves
  * `error` out (`ErrorOf` is `unknown`).
  *
+ * The key's literal type is kept too (`readonly ["post", string]`), so two
+ * factories with the same input and data but different keys have different
+ * types, and a handle of one doesn't type-check where the other's goes.
+ *
  * The type parameters are only there for TypeScript to infer the types bag
- * from `queryFn`; it can't infer a bag's members.
+ * from `queryFn` and `queryKey`; it can't infer a bag's members.
  */
-export declare function queryOptions<TData, TError = unknown, TServices = never>(options: Omit<QueryOptions<{
+export declare function queryOptions<TData, TError = unknown, TServices = never, const TKey extends QueryKey = QueryKey>(options: Omit<QueryOptions<{
   data: TData;
   error: TError;
+  key: TKey;
   services: TServices;
-}>, "kind">): QueryOptions<QueryTypesOf<TData, TError, TServices>>;
+}>, "kind">): QueryOptions<QueryTypesOf<TData, TError, TServices, TKey>>;
 /**
  * Typed options for a paged query factory. The page type is inferred from
  * `queryFn`, as in {@link queryOptions}. So is an Effect `queryFn`'s error;
- * a promise or a plain value leaves `error` out.
+ * a promise or a plain value leaves `error` out. The key's literal type is
+ * kept, as in {@link queryOptions}.
  */
-export declare function infiniteQueryOptions<TPage, TPageParam, TError = unknown, TServices = never>(options: Omit<InfiniteQueryOptions<{
+export declare function infiniteQueryOptions<TPage, TPageParam, TError = unknown, TServices = never, const TKey extends QueryKey = QueryKey>(options: Omit<InfiniteQueryOptions<{
   error: TError;
+  key: TKey;
   page: TPage;
   pageParam: TPageParam;
   services: TServices;
-}>, "kind">): InfiniteQueryOptions<InfiniteQueryTypesOf<TPage, TPageParam, TError, TServices>>;
+}>, "kind">): InfiniteQueryOptions<InfiniteQueryTypesOf<TPage, TPageParam, TError, TServices, TKey>>;
 interface FactoryResult {
   readonly kind: "infinite" | "query";
   readonly queryKey: QueryKey;

package/dist/options.mjs

@@ -16,8 +16,12 @@
 * type. A promise or a plain value has no error to infer, so the type leaves
 * `error` out (`ErrorOf` is `unknown`).
 *
+* The key's literal type is kept too (`readonly ["post", string]`), so two
+* factories with the same input and data but different keys have different
+* types, and a handle of one doesn't type-check where the other's goes.
+*
 * The type parameters are only there for TypeScript to infer the types bag
-* from `queryFn`; it can't infer a bag's members.
+* from `queryFn` and `queryKey`; it can't infer a bag's members.
 */
 function queryOptions(options) {
 	return {
@@ -28,7 +32,8 @@ function queryOptions(options) {
 /**
 * Typed options for a paged query factory. The page type is inferred from
 * `queryFn`, as in {@link queryOptions}. So is an Effect `queryFn`'s error;
-* a promise or a plain value leaves `error` out.
+* a promise or a plain value leaves `error` out. The key's literal type is
+* kept, as in {@link queryOptions}.
 */
 function infiniteQueryOptions(options) {
 	return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raf-query/core",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "description": "Framework-agnostic core of raf-query, a render-as-you-fetch query library",
   "keywords": [
     "query",