move more methods

Author: KurtGokhan

packages/tanstack-query-builder/src/builder/QueryBuilder.ts

@@ -1,6 +1,7 @@
 import { QueryClient } from '@tanstack/react-query';
 import { operateOnTags } from '../tags/operateOnTags';
 import type { QueryTagObject, QueryTagOption, QueryUpdateTagObject } from '../tags/types';
+import { TODO } from '../type-utils';
 import { QueryBuilderFrozen } from './QueryBuilderFrozen';
 import { type MiddlewareFn, createMiddlewareFunction } from './createMiddlewareFunction';
 import { type PreprocessorFn, createPreprocessorFunction, identityPreprocessor } from './createPreprocessorFunction';
@@ -19,6 +20,7 @@ export class QueryBuilder<
   TFlags extends BuilderFlags = '',
 > extends QueryBuilderFrozen<TVars, TData, TError, TKey, TTags, TFlags> {
   withVars<TVars$ = TVars, const TReset extends boolean = false>(
+    this: this,
     vars?: TVars$,
     resetVars = false as TReset,
   ): QueryBuilder<TVars$, TData, TError, TKey, TTags, TFlags> {
@@ -29,37 +31,45 @@ export class QueryBuilder<
     }) as any;
   }
 
-  withData<TData$>(): QueryBuilder<TVars, TData$, TError, TKey, TTags, TFlags> {
+  withData<TData$>(this: this): QueryBuilder<TVars, TData$, TError, TKey, TTags, TFlags> {
     return this as any;
   }
 
-  withError<TError$>(): QueryBuilder<TVars, TData, TError$, TKey, TTags, TFlags> {
+  withError<TError$>(this: this): QueryBuilder<TVars, TData, TError$, TKey, TTags, TFlags> {
     return this as any;
   }
 
-  withConfig(config: Partial<typeof this.config>): this {
+  withConfig(this: this, config: Partial<typeof this.config>): this {
     const ctor = this.constructor as typeof QueryBuilder;
     const newConfig = this.mergeConfigs(this.config, config);
     return new ctor(newConfig) as this;
   }
 
-  withPreprocessor(preprocessor: PreprocessorFn<TVars, TVars>): this;
-  withPreprocessor<TVars$ = TVars>(preprocessor: PreprocessorFn<TVars$, TVars>): QueryBuilder<TVars$, TData, TError, TKey, TTags, TFlags>;
+  withPreprocessor(this: this, preprocessor: PreprocessorFn<TVars, TVars>): this;
+  withPreprocessor<TVars$ = TVars>(
+    this: this,
+    preprocessor: PreprocessorFn<TVars$, TVars>,
+  ): QueryBuilder<TVars$, TData, TError, TKey, TTags, TFlags>;
 
-  withPreprocessor<TVars$ = TVars>(preprocessor: PreprocessorFn<TVars$, TVars>): QueryBuilder<TVars$, TData, TError, TKey, TTags, TFlags> {
+  withPreprocessor<TVars$ = TVars>(
+    this: this,
+    preprocessor: PreprocessorFn<TVars$, TVars>,
+  ): QueryBuilder<TVars$, TData, TError, TKey, TTags, TFlags> {
     const newBuilder = this as unknown as QueryBuilder<TVars$, TData, TError, TKey, TTags, TFlags>;
 
     return newBuilder.withConfig({
       preprocessorFn: createPreprocessorFunction(preprocessor, this.config.preprocessorFn || identityPreprocessor),
     });
   }
 
-  withMiddleware(middleware: MiddlewareFn<TVars, TData, TError, TKey>): this;
+  withMiddleware(this: this, middleware: MiddlewareFn<TVars, TData, TError, TKey>): this;
   withMiddleware<TVars$ = TVars, TData$ = TData, TError$ = TError>(
+    this: this,
     middleware: MiddlewareFn<TVars$, TData$, TError$, TKey>,
   ): QueryBuilder<TVars$, TData$, TError$, TKey, TTags, TFlags>;
 
   withMiddleware<TVars$ = TVars, TData$ = TData, TError$ = TError>(
+    this: this,
     middleware: MiddlewareFn<TVars$, TData$, TError$, TKey>,
     config?: Partial<BuilderConfig<TVars$, TData$, TError$, TKey>>,
   ): QueryBuilder<TVars$, TData$, TError$, TKey, TTags, TFlags> {
@@ -68,26 +78,27 @@ export class QueryBuilder<
     return newBuilder.withConfig({
       ...config,
       queryFn: createMiddlewareFunction(this.config.queryFn, middleware, newBuilder.config),
-    });
+    } as TODO);
   }
 
   static tagCacheId = 0;
 
-  withTags(...tags: QueryTagOption<TVars, TData, TError, QueryTagObject<TTags>>[]): this {
+  withTags(this: this, ...tags: QueryTagOption<TVars, TData, TError, QueryTagObject<TTags>>[]): this {
     return this.withMiddleware(createTagMiddleware(tags.flat(), QueryBuilder.tagCacheId++)) as unknown as this;
   }
 
-  withUpdates(...tags: QueryTagOption<TVars, TData, TError, QueryUpdateTagObject<TVars, TData, TError, TTags>>[]): this {
+  withUpdates(this: this, ...tags: QueryTagOption<TVars, TData, TError, QueryUpdateTagObject<TVars, TData, TError, TTags>>[]): this {
     return this.withMiddleware(createUpdateMiddleware<TVars, TData, TError, TKey, TTags>(tags)) as unknown as this;
   }
 
-  withTagTypes<TTag extends string, T = unknown>(): QueryBuilder<TVars, TData, TError, TKey, TTags & Record<TTag, T>, TFlags>;
-  withTagTypes<TTags$ extends Record<string, unknown>>(): QueryBuilder<TVars, TData, TError, TKey, TTags$, TFlags>;
-  withTagTypes(): this {
+  withTagTypes<TTag extends string, T = unknown>(this: this): QueryBuilder<TVars, TData, TError, TKey, TTags & Record<TTag, T>, TFlags>;
+  withTagTypes<TTags$ extends Record<string, unknown>>(this: this): QueryBuilder<TVars, TData, TError, TKey, TTags$, TFlags>;
+  withTagTypes(this: this): this {
     return this as any;
   }
 
   withClient(
+    this: this,
     queryClient: QueryClient,
     { syncTagsWithOtherTabs = true }: { syncTagsWithOtherTabs?: boolean } = {},
   ): QueryBuilder<TVars, TData, TError, TKey, TTags, TFlags | 'withClient'> {
@@ -105,16 +116,17 @@ export class QueryBuilder<
   }
 
   withPagination(
+    this: this,
     paginationOptions: BuilderPaginationOptions<TVars, TData, TError, TKey>,
   ): QueryBuilder<TVars, TData, TError, TKey, TTags, TFlags | 'withPagination'> {
-    return this.withConfig({ paginationOptions }) as any;
+    return this.withConfig({ paginationOptions } as TODO);
   }
 
-  asFrozen(): QueryBuilderFrozen<TVars, TData, TError, TKey, TTags, TFlags> {
-    return this;
+  asFrozen(this: this): QueryBuilderFrozen<TVars, TData, TError, TKey, TTags, TFlags> {
+    return this as any;
   }
 
-  asBound(): QueryBuilder<TVars, TData, TError, TKey, TTags, TFlags | 'bound'> {
+  asBound(this: this): QueryBuilder<TVars, TData, TError, TKey, TTags, TFlags | 'bound'> {
     return this.withConfig({ bound: true });
   }
 }

packages/tanstack-query-builder/src/builder/QueryBuilderFrozen.ts

@@ -35,8 +35,7 @@ import { type BuilderOptions, BuilderPaginationOptions, mergeBuilderOptions, mer
 import type { BuilderConfig, BuilderFlags, BuilderQueriesResult, HasClient, HasPagination, IsBound } from './types';
 import { areKeysEqual, assertBound, getRandomKey, mergeMutationOptions, mergeVars } from './utils';
 
-type AnyBuilder<TFlags extends BuilderFlags> = QueryBuilderFrozen<any, any, any, any, any, TFlags>;
-type IsBoundThis<TFlags extends BuilderFlags> = IsBound<TFlags, AnyBuilder<TFlags>>;
+type IsBoundThis<TFlags extends BuilderFlags, TB extends QueryBuilderFrozen<any, any, any, any, any, TFlags>> = IsBound<TFlags, TB>;
 
 type UseQueriesArgs<TVars, TData, TError, TKey extends unknown[]> = [
   queries: {
@@ -113,7 +112,7 @@ export class QueryBuilderFrozen<
   //#region Query
 
   getQueryFn(
-    this: IsBoundThis<TFlags>,
+    this: IsBoundThis<TFlags, this>,
     operationType: 'query' | 'queries' | 'infiniteQuery' = 'query',
   ): QueryFunction<TData, TKey, Partial<TVars>> {
     assertBound(this);
@@ -130,21 +129,21 @@ export class QueryBuilderFrozen<
     };
   }
 
-  getQueryKeyHashFn(this: IsBoundThis<TFlags>): (key: TKey) => string {
+  getQueryKeyHashFn(this: IsBoundThis<TFlags, this>): (key: TKey) => string {
     assertBound(this);
     return (key) => {
       const sanitized = this.config.queryKeySanitizer ? this.config.queryKeySanitizer(key) : key;
       return hashKey(sanitized);
     };
   }
 
-  getQueryKey(this: IsBoundThis<TFlags>, vars: TVars): DataTag<TKey, TData, TError> {
+  getQueryKey(this: IsBoundThis<TFlags, this>, vars: TVars): DataTag<TKey, TData, TError> {
     assertBound(this);
     return [this.preprocessVars(this.mergeVars([this.config.vars, vars as TODO]))] as DataTag<TKey, TData, TError>;
   }
 
   getQueryOptions(
-    this: IsBoundThis<TFlags>,
+    this: IsBoundThis<TFlags, this>,
     vars: TVars,
     opts?: BuilderOptions<TVars, TData, TError, TKey>,
     operationType?: 'query' | 'queries' | 'infiniteQuery',
@@ -162,26 +161,26 @@ export class QueryBuilderFrozen<
     ]) as TODO;
   }
 
-  useQuery(this: IsBoundThis<TFlags>, vars: TVars, opts?: BuilderOptions<TVars, TData, TError, TKey>): UseQueryResult<TData, TError> {
+  useQuery(this: IsBoundThis<TFlags, this>, vars: TVars, opts?: BuilderOptions<TVars, TData, TError, TKey>): UseQueryResult<TData, TError> {
     assertBound(this);
     return useQuery(this.getQueryOptions(vars, opts), this.config.queryClient);
   }
 
   useSuspenseQuery(
-    this: IsBoundThis<TFlags>,
+    this: IsBoundThis<TFlags, this>,
     vars: TVars,
     opts?: BuilderOptions<TVars, TData, TError, TKey>,
   ): UseSuspenseQueryResult<TData, TError> {
     assertBound(this);
     return useSuspenseQuery(this.getQueryOptions(vars, opts), this.config.queryClient);
   }
 
-  usePrefetchQuery(this: IsBoundThis<TFlags>, vars: TVars, opts?: BuilderOptions<TVars, TData, TError, TKey>): void {
+  usePrefetchQuery(this: IsBoundThis<TFlags, this>, vars: TVars, opts?: BuilderOptions<TVars, TData, TError, TKey>): void {
     assertBound(this);
     usePrefetchQuery(this.getQueryOptions(vars, opts), this.config.queryClient);
   }
 
-  useIsFetching(this: IsBoundThis<TFlags>, vars: TVars, filters?: QueryFilters): number {
+  useIsFetching(this: IsBoundThis<TFlags, this>, vars: TVars, filters?: QueryFilters): number {
     assertBound(this);
     return useIsFetching({ queryKey: this.getQueryKey(vars), ...filters }, this.config.queryClient);
   }
@@ -191,7 +190,7 @@ export class QueryBuilderFrozen<
   //#region Queries
 
   private useQueriesInternal(
-    this: IsBoundThis<TFlags>,
+    this: IsBoundThis<TFlags, this>,
     useHook: typeof useQueries | typeof useSuspenseQueries,
     ...[queries, sharedVars, sharedOpts]: UseQueriesArgs<TVars, TData, TError, TKey>
   ): BuilderQueriesResult<TVars, TData, TError, TKey> {
@@ -219,15 +218,15 @@ export class QueryBuilderFrozen<
   }
 
   useQueries(
-    this: IsBoundThis<TFlags>,
+    this: IsBoundThis<TFlags, this>,
     ...args: UseQueriesArgs<TVars, TData, TError, TKey>
   ): BuilderQueriesResult<TVars, TData, TError, TKey> {
     assertBound(this);
     return this.useQueriesInternal(useQueries, ...args);
   }
 
   useSuspenseQueries(
-    this: IsBoundThis<TFlags>,
+    this: IsBoundThis<TFlags, this>,
     ...args: UseQueriesArgs<TVars, TData, TError, TKey>
   ): BuilderQueriesResult<TVars, TData, TError, TKey> {
     assertBound(this);
@@ -241,7 +240,7 @@ export class QueryBuilderFrozen<
   declare getInfiniteQueryOptions: HasPagination<
     TFlags,
     (
-      this: IsBoundThis<TFlags>,
+      this: IsBoundThis<TFlags, this>,
       vars: TVars,
       opts?: Partial<BuilderPaginationOptions<TVars, TData, TError, TKey>>,
     ) => WithRequired<BuilderPaginationOptions<TVars, TData, TError, TKey>, 'queryFn' | 'queryKey' | 'initialPageParam'>
@@ -250,21 +249,21 @@ export class QueryBuilderFrozen<
   declare useInfiniteQuery: HasPagination<
     TFlags,
     (
-      this: IsBoundThis<TFlags>,
+      this: IsBoundThis<TFlags, this>,
       vars: TVars,
       opts?: Partial<BuilderPaginationOptions<TVars, TData, TError, TKey>>,
     ) => UseInfiniteQueryResult<InfiniteData<TData, Partial<TVars>>, TError>
   >;
 
   declare usePrefetchInfiniteQuery: HasPagination<
     TFlags,
-    (this: IsBoundThis<TFlags>, vars: TVars, opts?: Partial<BuilderPaginationOptions<TVars, TData, TError, TKey>>) => void
+    (this: IsBoundThis<TFlags, this>, vars: TVars, opts?: Partial<BuilderPaginationOptions<TVars, TData, TError, TKey>>) => void
   >;
 
   declare useSuspenseInfiniteQuery: HasPagination<
     TFlags,
     (
-      this: IsBoundThis<TFlags>,
+      this: IsBoundThis<TFlags, this>,
       vars: TVars,
       opts?: Partial<BuilderPaginationOptions<TVars, TData, TError, TKey>>,
     ) => UseSuspenseInfiniteQueryResult<InfiniteData<TData, Partial<TVars>>, TError>
@@ -274,7 +273,7 @@ export class QueryBuilderFrozen<
 
   //#region Mutation
 
-  getMutationFn(this: IsBoundThis<TFlags>, queryClient: QueryClient, meta?: any): MutationFunction<TData, TVars> {
+  getMutationFn(this: IsBoundThis<TFlags, this>, queryClient: QueryClient, meta?: any): MutationFunction<TData, TVars> {
     assertBound(this);
 
     return async (vars) => {
@@ -291,7 +290,7 @@ export class QueryBuilderFrozen<
   }
 
   #randomKey?: string;
-  getMutationKey(this: IsBoundThis<TFlags>): MutationKey {
+  getMutationKey(this: IsBoundThis<TFlags, this>): MutationKey {
     assertBound(this);
 
     if (this.config.options?.mutationKey) return this.config.options.mutationKey;
@@ -302,7 +301,7 @@ export class QueryBuilderFrozen<
   }
 
   getMutationOptions(
-    this: IsBoundThis<TFlags>,
+    this: IsBoundThis<TFlags, this>,
     queryClient: QueryClient,
     opts?: BuilderOptions<TVars, TData, TError, TKey>,
   ): UseMutationOptions<TData, TError, TVars> {
@@ -319,7 +318,7 @@ export class QueryBuilderFrozen<
   }
 
   getMutationFilters(
-    this: IsBoundThis<TFlags>,
+    this: IsBoundThis<TFlags, this>,
     vars?: TVars,
     filters?: MutationFilters<TData, TError, TVars>,
   ): MutationFilters<any, any, any> {
@@ -342,21 +341,21 @@ export class QueryBuilderFrozen<
   }
 
   useMutation(
-    this: IsBoundThis<TFlags>,
+    this: IsBoundThis<TFlags, this>,
     opts?: BuilderOptions<TVars, TData, TError, TKey>,
   ): ReturnType<typeof useMutation<TData, TError, TVars>> {
     assertBound(this);
     const queryClient = useQueryClient(this.config.queryClient);
     return useMutation(this.getMutationOptions(queryClient, opts), this.config.queryClient);
   }
 
-  useIsMutating(this: IsBoundThis<TFlags>, vars: TVars, filters?: MutationFilters<TData, TError, TVars>): number {
+  useIsMutating(this: IsBoundThis<TFlags, this>, vars: TVars, filters?: MutationFilters<TData, TError, TVars>): number {
     assertBound(this);
     return useIsMutating(this.getMutationFilters(vars, filters), this.config.queryClient);
   }
 
   useMutationState<TSelect = Mutation<TData, TError, TVars>>(
-    this: IsBoundThis<TFlags>,
+    this: IsBoundThis<TFlags, this>,
     vars?: TVars,
     filters?: MutationFilters<TData, TError, TVars>,
     select?: (mt: Mutation<TData, TError, TVars>) => TSelect,

packages/tanstack-query-builder/src/builder/utils.ts

@@ -53,6 +53,6 @@ export function getRandomKey() {
   return Math.random().toString(36).substring(7);
 }
 
-export function assertBound<T extends IsBound<any, unknown>>(t: T): asserts t is Exclude<T, void> {
+export function assertBound<T extends IsBound<any, unknown>>(t: T): asserts t is T & Exclude<T, void> {
   if (t === undefined) throw new Error('Method called on unbound instance');
 }