API Reference

Type Exports

Import types from the main entry point:

import type {
  // Query types
  QueryKey,
  QueryOptions,
  CreateQueryOptions,
  CreateQueryResult,

  // Infinite query types
  InfiniteQueryOptions,
  CreateInfiniteQueryOptions,
  CreateInfiniteQueryResult,

  // Mutation types
  MutationKey,
  CreateMutationOptions,
  CreateMutationResult,

  // Utility types
  Arguments,
  RootKey,
  DefaultOptions,
  SetDataFn,
  SetDataFnParam,
} from "@teardown/queries";

import {
  QueryClient,
  type TanstackQueryClient,
  type TanstackQueryCore,
} from "@teardown/queries";

QueryClient

Abstract base class for domain-specific query clients.

Constructor

constructor(
  client: TanstackQueryClient,
  resource: Resource,
  defaultOptions?: DefaultOptions
)

Parameter	Type	Description
`client`	`TanstackQueryClient`	TanStack Query's QueryClient
`resource`	`string`	Resource name (e.g., "projects")
`defaultOptions`	`DefaultOptions`	Optional staleTime and gcTime

Methods

`query()`

Create a standard query configuration.

query<SubResource, Args, TData, TError>(
  options: CreateQueryOptions<SubResource, Args, TData, TError>
): CreateQueryResult<Resource, SubResource, Args, TData, TError>

`infiniteQuery()`

Create an infinite/paginated query configuration.

infiniteQuery<SubResource, TQueryFnData, TPageParam, TError, TData, Args>(
  options: CreateInfiniteQueryOptions<...>
): CreateInfiniteQueryResult<...>

`mutation()`

Create a mutation configuration.

mutation<MKey, TData, TError, TVariables, TContext, Args>(
  options: CreateMutationOptions<MKey, TData, TError, TVariables, TContext, Args>
): CreateMutationResult<...>

`queryKeyGen()`

Generate a query key.

queryKeyGen<SubResource, Args>(
  subResource: SubResource,
  ...args: Args
): QueryKey<Resource, SubResource, Args>

`mutationKeyGen()`

Generate a mutation key.

mutationKeyGen<MKey, Args>(
  mKey: MKey,
  ...args: Args
): MutationKey<Resource, MKey, Args>

`refresh()`

Invalidate queries.

refresh<SubResource, Args>(
  subResource?: SubResource,
  ...args: Args
): Promise<void>

`shutdown()`

Clear all cached data.

shutdown(): void

CreateQueryResult

Result returned by query() method.

interface CreateQueryResult<Resource, SubResource, Args, TData, TError> {
  // Standard options
  queryKey: QueryKey<Resource, SubResource, Args>;
  queryFn: QueryFunction<TData>;
  staleTime?: number;
  gcTime?: number;
  enabled?: boolean;
  // ... other QueryOptions

  // Convenience methods
  fetch(): Promise<TData>;
  prefetch(): Promise<void>;
  get(): TData | undefined;
  set(param: SetDataFnParam<TData>): void;
  refresh(): Promise<void>;
}

CreateInfiniteQueryResult

Result returned by infiniteQuery() method.

interface CreateInfiniteQueryResult<
  Resource, SubResource, Args,
  TQueryFnData, TError, TData, TPageParam
> {
  queryKey: QueryKey<Resource, SubResource, Args>;
  queryFn: InfiniteQueryFunction;
  initialPageParam: TPageParam;
  getNextPageParam: GetNextPageParamFunction;
  // ... other InfiniteQueryOptions

  fetch(): Promise<InfiniteData<TQueryFnData, TPageParam>>;
  refresh(): Promise<void>;
}

CreateMutationResult

Result returned by mutation() method.

interface CreateMutationResult<
  Resource, MKey, TData, TError, TVariables, TContext, Args
> {
  mutationKey: MutationKey<Resource, MKey, Args>;
  mutationFn: MutationFunction<TData, TVariables>;
  onMutate?: (variables: TVariables) => Promise<TContext>;
  onSuccess?: (data: TData, variables: TVariables, context: TContext) => void;
  onError?: (error: TError, variables: TVariables, context: TContext) => void;
  onSettled?: (
    data: TData | undefined,
    error: TError | null,
    variables: TVariables,
    context: TContext
  ) => void;
}

Key Types

QueryKey

type QueryKey<Resource, SubResource, Args> = [
  "@teardown",
  Resource,
  "query",
  SubResource,
  ...Args
];

MutationKey

type MutationKey<Resource, SubResource, Args> = [
  "@teardown",
  Resource,
  "mutation",
  SubResource,
  ...Args
];

RootKey

type RootKey<Resource> = ["@teardown", Resource];

Arguments

type Arguments = readonly unknown[];

Options Types

DefaultOptions

interface DefaultOptions {
  staleTime?: number;
  gcTime?: number;
}

CreateQueryOptions

type CreateQueryOptions<SubResource, Args, TData, TError> = {
  key: [SubResource, ...Args];
  fn: QueryFunction<TData>;
} & QueryOptions<TData, TError>;

CreateMutationOptions

type CreateMutationOptions<MKey, TData, TError, TVariables, TContext, Args> = {
  key: [MKey, ...Args];
  fn: MutationFunction<TData, TVariables>;
} & MutationOptions<TData, TVariables, TError, TContext>;

Package Structure

packages/queries/
├── src/
│   ├── query.client.ts    # QueryClient class + types
│   └── index.ts           # Package exports
├── package.json
├── tsconfig.json
└── tsconfig.lib.json

Scripts

bun run dev           # Watch mode
bun run build         # Build for distribution
bun run typecheck     # TypeScript check
bun run fmt           # Format with Biome
bun run lint          # Lint with Biome
bun run check         # Full Biome check

Package	Purpose
`@teardown/sdk`	Auth and API client
`@teardown/types`	Shared TypeScript types
`@teardown/schemas`	Zod schemas for validation
`@tanstack/react-query`	Underlying query library

On this page