@hypequery/react 0.1.1 → 0.3.0

package/README.md

@@ -1,377 +1,308 @@
 # @hypequery/react
 
-Type-safe React hooks for hypequery APIs. Wraps your generated API definition in thin TanStack Query shims so you can call `useQuery('weeklyRevenue')` with end-to-end type safety.
+React hooks for typed Hypequery HTTP endpoints, built on TanStack Query.
 
-## Installation
+Use `@hypequery/react` with APIs created by `@hypequery/serve`. The hooks call generated routes and infer input/output types from the API type you pass in.
+
+## Install
 
 ```bash
 npm install @hypequery/react @tanstack/react-query
+# or
+pnpm add @hypequery/react @tanstack/react-query
 ```
 
-Peer dependencies: `react@^18`, `@tanstack/react-query@^5`.
-
 ## Quick Start
 
-```ts
-// lib/analytics.ts
-import { createHooks } from '@hypequery/react';
-import type { Api } from '@/analytics/queries';
+Given a serve API:
 
-export const { useQuery, useMutation } = createHooks<Api>({
-  baseUrl: '/api',
+```ts
+// server/api.ts
+import { initServe } from '@hypequery/serve';
+import { z } from 'zod';
+import { db } from './db.js';
+
+const { query, serve } = initServe({
+  context: () => ({ db }),
+  basePath: '/api/analytics',
 });
-```
 
-Wrap your app with TanStack Query's provider:
+const weeklyRevenue = query({
+  description: 'Weekly revenue',
+  input: z.object({ startDate: z.string() }),
+  query: ({ ctx, input }) =>
+    ctx.db
+      .table('orders')
+      .where('created_at', 'gte', input.startDate)
+      .sum('total', 'revenue')
+      .execute(),
+});
 
-```tsx
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+export const api = serve({
+  queries: { weeklyRevenue },
+});
 
-const queryClient = new QueryClient();
+api.route('/weeklyRevenue', api.queries.weeklyRevenue);
 
-export function App({ children }: { children: React.ReactNode }) {
-  return (
-    <QueryClientProvider client={queryClient}>
-      {children}
-    </QueryClientProvider>
-  );
-}
+export type AnalyticsApi = typeof api;
 ```
 
-Use the hooks in your components:
+Create hooks on the client:
 
 ```tsx
-// Query
-const { data, error, isLoading } = useQuery('weeklyRevenue', { startDate: '2025-01-01' });
+// client/analytics-hooks.ts
+import { createHooks } from '@hypequery/react';
+import type { AnalyticsApi } from '../server/api.js';
 
-// Mutation
-const rebuild = useMutation('rebuildMetrics');
-rebuild.mutate({ force: true });
+export const { useQuery, useMutation } = createHooks<AnalyticsApi>({
+  baseUrl: '/api/analytics',
+  api: {} as AnalyticsApi,
+});
 ```
 
----
-
-## API Reference
-
-### `createHooks<Api>(config)`
+Use them inside a component:
 
-Factory function that creates type-safe `useQuery` and `useMutation` hooks for your API.
-
-**Parameters:**
+```tsx
+function RevenuePanel() {
+  const revenue = useQuery('weeklyRevenue', {
+    startDate: '2026-01-01',
+  });
 
-```ts
-interface CreateHooksConfig<TApi> {
-  baseUrl: string;                          // Required: API base URL (e.g., '/api' or 'https://api.example.com')
-  fetchFn?: typeof fetch;                   // Optional: Custom fetch implementation (defaults to global fetch)
-  headers?: Record<string, string | undefined> | (() => Record<string, string | undefined>); // Optional: Default headers or a resolver function
-  config?: Record<string, QueryMethodConfig>; // Optional: Per-route HTTP method overrides
-  api?: TApi;                               // Optional: API object to auto-extract HTTP methods
-}
+  if (revenue.isLoading) return <p>Loading...</p>;
+  if (revenue.error) return <p>{revenue.error.message}</p>;
 
-interface QueryMethodConfig {
-  method?: string; // HTTP method: 'GET', 'POST', 'PUT', 'DELETE', etc.
+  return <pre>{JSON.stringify(revenue.data, null, 2)}</pre>;
 }
 ```
 
-**Returns:**
-
-```ts
-{
-  useQuery: <Name>(name, input?, options?) => UseQueryResult<Output, HttpError>,
-  useMutation: <Name>(name, options?) => UseMutationResult<Output, HttpError, Input>
-}
-```
+## Dataset And Metric Hooks
 
-**Example:**
+`createAnalyticsHooks` adds convenience wrappers for semantic endpoint names. Metrics use their endpoint name directly. Dataset endpoints are addressed as `dataset:<name>` in the API type and exposed through `useDataset(name, ...)`.
 
-```ts
-const { useQuery, useMutation } = createHooks<Api>({
-  baseUrl: 'https://api.example.com',
-  headers: {
-    'X-API-Key': process.env.API_KEY,
-  },
-  config: {
-    // Override HTTP method for specific routes
-    uploadFile: { method: 'POST' },
-  },
-});
-```
+```tsx
+import { createAnalyticsHooks } from '@hypequery/react';
+import type { InferApiType } from '@hypequery/serve';
+import type { api } from '../server/api.js';
 
----
+import manifest from './hypequery-manifest.json';
 
-### `useQuery(name, input?, options?)`
+type AnalyticsApi = InferApiType<typeof api>;
 
-Type-safe wrapper around TanStack Query's `useQuery`. Automatically infers input and output types from your API definition.
+export const { useMetric, useDataset } = createAnalyticsHooks<AnalyticsApi>({
+  baseUrl: '/api/analytics',
+  manifest,
+  metrics: ['revenue', 'averageOrderValue'] as const,
+});
 
-**Signatures:**
+function Dashboard() {
+  const revenue = useMetric('revenue', {
+    dimensions: ['country'],
+    filters: [{ field: 'status', operator: 'eq', value: 'completed' }],
+    orderBy: [{ field: 'revenue', direction: 'desc' }],
+    limit: 10,
+  });
 
-```ts
-// No input required
-useQuery(name: Name)
-useQuery(name: Name, options: QueryOptions)
+  const orders = useDataset('orders', {
+    dimensions: ['status'],
+    measures: ['revenue', 'orderCount'],
+  });
 
-// Input required
-useQuery(name: Name, input: Input)
-useQuery(name: Name, input: Input, options: QueryOptions)
+  return (
+    <pre>
+      {JSON.stringify({ revenue: revenue.data, orders: orders.data }, null, 2)}
+    </pre>
+  );
+}
 ```
 
-**Parameters:**
+## Pagination
 
-- `name` - Query name from your API definition
-- `input` - Query input (typed from your API). Optional if query has no input schema
-- `options` - TanStack Query options (`enabled`, `staleTime`, `refetchInterval`, etc.)
-
-**Returns:** TanStack Query's `UseQueryResult<Output, HttpError>`
-
-**Examples:**
+Semantic queries that set a `limit` return `meta.pagination = { limit, offset, hasMore }`
+(`hasMore` is exact — the server over-fetches one row rather than running a count query).
+`useInfiniteQuery`, and the `useInfiniteMetric` / `useInfiniteDataset` wrappers, build on
+this to page through results. They advance the offset automatically and request meta for you.
 
 ```tsx
-// Simple query with no input
-const { data } = useQuery('healthCheck');
-
-// Query with input
-const { data, error, isLoading } = useQuery('getUser', { id: '123' });
+function OrdersTable() {
+  const orders = useInfiniteDataset('orders', {
+    dimensions: ['status'],
+    measures: ['revenue'],
+    limit: 50,
+  });
 
-// Query with options
-const { data } = useQuery('getUser', { id: '123' }, {
-  enabled: isLoggedIn,
-  staleTime: 60000,
-  refetchOnWindowFocus: false,
-});
-
-// Query without input but with options
-const { data } = useQuery('healthCheck', { refetchInterval: 5000 });
+  return (
+    <>
+      {orders.data?.pages.flatMap((page) => page.data).map((row, i) => (
+        <Row key={i} row={row} />
+      ))}
+      <button
+        onClick={() => orders.fetchNextPage()}
+        disabled={!orders.hasNextPage || orders.isFetchingNextPage}
+      >
+        Load more
+      </button>
+    </>
+  );
+}
 ```
 
----
-
-### `useMutation(name, options?)`
+`input.limit` is the page size; `input.offset`, if provided, is the starting offset.
 
-Type-safe wrapper around TanStack Query's `useMutation`.
+## Route Configuration
 
-**Parameters:**
+Hooks need to know each endpoint's HTTP method and path. There are three ways to
+supply that, in increasing precedence: a route manifest, a runtime `api` object,
+or explicit `config`.
 
-- `name` - Mutation name from your API definition
-- `options` - TanStack Query mutation options (`onSuccess`, `onError`, `retry`, etc.)
+### Route manifest (recommended)
 
-**Returns:** TanStack Query's `UseMutationResult<Output, HttpError, Input>`
+`@hypequery/serve`'s `api.manifest()` returns a serializable map of every
+query/metric/dataset key to its `{ method, path }`. Export it from a server-only
+module and pass it to the hooks — this avoids importing server code into the
+browser bundle while keeping client routes in sync with the server.
 
-**Examples:**
+```ts
+// server side (server-only module)
+export const manifest = api.manifest();
 
-```tsx
-// Basic mutation
-const createUser = useMutation('createUser');
-createUser.mutate({ name: 'Alice', email: 'alice@example.com' });
-
-// Mutation with callbacks
-const updateProfile = useMutation('updateProfile', {
-  onSuccess: (data) => {
-    console.log('Profile updated:', data);
-    queryClient.invalidateQueries(['hypequery', 'getProfile']);
-  },
-  onError: (error) => {
-    console.error('Failed to update profile:', error.message);
-  },
+// client side
+const { useQuery } = createHooks<AnalyticsApi>({
+  baseUrl: '/api/analytics',
+  manifest,
 });
-
-updateProfile.mutate({ bio: 'New bio' });
 ```
 
----
-
-### `queryOptions(options)`
-
-Helper function to explicitly mark an object as query options (not input). Useful when your query input and TanStack Query options have overlapping property names.
-
-**Parameters:**
-
-- `options` - TanStack Query options object
-
-**Returns:** The same object with an internal symbol marker
+> Metric and dataset endpoints are POST routes whose paths differ from their map
+> keys (e.g. `dataset:orders` → `POST /api/analytics/datasets/orders/query`). They
+> require a `manifest` (or explicit `config`); calling them without one throws a
+> clear error rather than hitting the wrong URL.
 
-**When to use:**
+#### Generating the manifest at build time
 
-If your API input has properties like `enabled`, `staleTime`, etc., the library might misclassify input as options. Use `queryOptions()` to disambiguate:
-
-```tsx
-// ❌ Ambiguous - could be input or options?
-useQuery('getConfig', { enabled: true, staleTime: 5000 });
-
-// ✅ Explicit - this is input
-useQuery('getConfig', { enabled: true, staleTime: 5000 });
-
-// ✅ Explicit - these are options
-import { queryOptions } from '@hypequery/react';
-useQuery('getConfig', queryOptions({ enabled: true, staleTime: 5000 }));
-```
+The cleanest way to keep server code out of the browser bundle is to generate a
+JSON file at build time and import that on the client.
 
----
-
-### `HttpError`
-
-Custom error class thrown by failed HTTP requests. Extends the standard `Error` class with additional properties.
-
-**Properties:**
-
-```ts
-class HttpError extends Error {
-  readonly status: number;  // HTTP status code (404, 500, etc.)
-  readonly body: unknown;   // Parsed response body (JSON or text)
-}
+```bash
+npx hypequery generate:manifest analytics/api.ts --output src/generated/hypequery-manifest.json
 ```
 
-**Usage:**
-
-```tsx
-const { error } = useQuery('getUser', { id: '123' });
-
-if (error) {
-  console.log(error.message);  // "GET request to /api/getUser failed with status 404"
-  console.log(error.status);   // 404
-  console.log(error.body);     // { message: "User not found" }
-
-  // Type-safe instanceof check
-  if (error instanceof HttpError) {
-    if (error.status === 404) {
-      return <NotFound />;
-    }
+```jsonc
+// package.json
+{
+  "scripts": {
+    "gen:manifest": "hypequery generate:manifest analytics/api.ts --output src/generated/hypequery-manifest.json",
+    "build": "npm run gen:manifest && <your client build>"
   }
 }
 ```
 
-**Error handling example:**
+```ts
+// client side — imports plain JSON, no server code in the bundle
+import { createAnalyticsHooks } from '@hypequery/react';
+import type { InferApiType } from '@hypequery/serve';
+import type { api } from '../analytics/api.js';
+import manifest from './generated/hypequery-manifest.json';
 
-```tsx
-import { HttpError } from '@hypequery/react';
-
-function UserProfile({ userId }: { userId: string }) {
-  const { data, error, isLoading } = useQuery('getUser', { id: userId });
-
-  if (isLoading) return <Spinner />;
-
-  if (error instanceof HttpError) {
-    switch (error.status) {
-      case 404:
-        return <NotFound message="User not found" />;
-      case 403:
-        return <Unauthorized />;
-      case 500:
-        return <ServerError details={error.body} />;
-      default:
-        return <Error message={error.message} />;
-    }
-  }
+type AnalyticsApi = InferApiType<typeof api>;
 
-  return <div>{data.name}</div>;
-}
+const { useMetric, useDataset } = createAnalyticsHooks<AnalyticsApi>({
+  baseUrl: '/api/analytics',
+  manifest,
+});
 ```
 
----
+The manifest is derived entirely from your serve config (`basePath`, route keys,
+and `semanticPaths`), so the generated file is deterministic and only changes when
+your API shape does — commit it or regenerate it on every build.
 
-## Advanced Usage
+> `baseUrl` supplies the origin/host; the per-endpoint path comes from the
+> manifest (it already includes the server's `basePath`), so there's no
+> double-prefixing. Keep `baseUrl` aligned with where the API is mounted.
 
-### Custom fetch implementation
+### Explicit config
+
+If a manifest is not available at runtime, pass route config explicitly. This
+overrides any manifest entry.
 
 ```ts
-const { useQuery } = createHooks<Api>({
-  baseUrl: '/api',
-  fetchFn: async (url, init) => {
-    // Add authentication token
-    const token = await getAuthToken();
-    return fetch(url, {
-      ...init,
-      headers: {
-        ...init?.headers,
-        Authorization: `Bearer ${token}`,
-      },
-    });
+const { useQuery } = createHooks<AnalyticsApi>({
+  baseUrl: '/api/analytics',
+  config: {
+    weeklyRevenue: { method: 'POST', path: '/weeklyRevenue' },
   },
 });
 ```
 
-### Default headers
+`path` may be relative to `baseUrl`, absolute within the same origin, or an absolute HTTP URL.
 
-```ts
-const { useQuery } = createHooks<Api>({
-  baseUrl: '/api',
-  headers: {
-    'X-API-Key': process.env.API_KEY,
-    'X-Client-Version': '1.0.0',
-  },
-});
-```
+## Headers & auth
 
-### Dynamic headers
+Pass static headers, or a function (sync or async) invoked per request — handy for
+attaching a fresh/short-lived token.
 
 ```ts
-const { useQuery } = createHooks<Api>({
-  baseUrl: '/api',
-  headers: () => {
-    const key = getTenantKey();
-    return key ? { 'x-tenant-key': key } : {};
-  },
+const hooks = createHooks<AnalyticsApi>({
+  baseUrl: '/api/analytics',
+  headers: async () => ({
+    authorization: `Bearer ${await getAccessToken()}`,
+  }),
 });
 ```
 
-### HTTP method configuration
+Provide `onUnauthorized` to refresh credentials on a `401` and retry the request once
+with freshly resolved headers:
 
 ```ts
-const { useQuery } = createHooks<Api>({
-  baseUrl: '/api',
-  config: {
-    // Override default GET for specific queries
-    refreshCache: { method: 'POST' },
-    deleteUser: { method: 'DELETE' },
+const hooks = createHooks<AnalyticsApi>({
+  baseUrl: '/api/analytics',
+  headers: () => ({ authorization: `Bearer ${tokenStore.access}` }),
+  onUnauthorized: async () => {
+    await tokenStore.refresh(); // throw to abort; resolve to retry once
   },
 });
 ```
 
-### Auto-extract methods from API object
-
-If your API definition includes HTTP method information, pass it to auto-configure:
+## Query Options
 
-```ts
-import { api } from '@/analytics/queries';
+TanStack Query options can be passed as the final argument.
 
-const { useQuery } = createHooks({
-  baseUrl: '/api',
-  api, // Automatically extracts method config from api object
-});
+```tsx
+const result = useQuery(
+  'weeklyRevenue',
+  { startDate: '2026-01-01' },
+  {
+    staleTime: 60_000,
+    refetchOnWindowFocus: false,
+  },
+);
 ```
 
----
-
-## TypeScript
+For no-input queries, use `queryOptions()` when an options object might look like input.
 
-All hooks are fully typed based on your API definition:
+```tsx
+import { queryOptions } from '@hypequery/react';
 
-```ts
-interface Api {
-  getUser: {
-    input: { id: string };
-    output: { name: string; email: string };
-  };
-  weeklyRevenue: {
-    input: { startDate: string };
-    output: { total: number };
-  };
-}
+const result = useQuery('health', queryOptions({
+  staleTime: 30_000,
+}));
+```
 
-const { useQuery } = createHooks<Api>({ baseUrl: '/api' });
+## Mutations
 
-// ✅ TypeScript infers input and output types
-const { data } = useQuery('getUser', { id: '123' });
-//    ^? { name: string; email: string } | undefined
+`useMutation(name)` uses the same endpoint typing and sends requests as `POST` by default unless route config overrides it.
 
-// ❌ TypeScript error: missing required input
-const { data } = useQuery('getUser');
+```tsx
+const refresh = useMutation('refreshReport');
 
-// ❌ TypeScript error: invalid property
-const { data } = useQuery('getUser', { userId: '123' });
+refresh.mutate({ reportId: 'revenue' });
 ```
 
----
+## Notes
+
+- This package does not define datasets. Use `@hypequery/datasets` for semantic definitions.
+- This package does not generate SQL. It calls HTTP routes exposed by `@hypequery/serve`.
+- Dataset relationship JOIN execution is not implied by the React hooks; hooks consume whatever endpoint behavior the server exposes.
 
 ## License
 
-MIT
+Apache-2.0.

package/dist/analyticsHooks.d.ts

@@ -0,0 +1,34 @@
+import type { UseQueryOptions as TanstackUseQueryOptions, UseQueryResult, UseInfiniteQueryResult, InfiniteData } from '@tanstack/react-query';
+import { type CreateHooksConfig } from './createHooks.js';
+import { HttpError } from './errors.js';
+import type { ExtractNames, QueryInput, QueryOutput, QueryOutputForInput } from './types.js';
+type DatasetKey<Name extends string> = `dataset:${Name}`;
+type DatasetNamesFromApi<Api> = ExtractNames<Api> extends infer Key ? Key extends `dataset:${infer Name}` ? Name : never : never;
+type QueryKey<Name extends string, Input> = Input extends never ? ['hypequery', Name] : ['hypequery', Name, Input];
+type QueryOptions<Api, Key extends ExtractNames<Api>> = Omit<TanstackUseQueryOptions<QueryOutput<Api, Key>, HttpError, QueryOutput<Api, Key>, QueryKey<Key, QueryInput<Api, Key>>>, 'queryKey' | 'queryFn'>;
+export interface CreateAnalyticsHooksConfig<Api extends Record<string, {
+    input: any;
+    output: any;
+}>, TMetrics extends readonly Exclude<ExtractNames<Api>, `dataset:${string}`>[] = readonly Exclude<ExtractNames<Api>, `dataset:${string}`>[]> extends CreateHooksConfig<Api> {
+    metrics?: TMetrics;
+}
+export declare function createAnalyticsHooks<Api extends Record<string, {
+    input: any;
+    output: any;
+}>, TMetrics extends readonly Exclude<ExtractNames<Api>, `dataset:${string}`>[] = readonly Exclude<ExtractNames<Api>, `dataset:${string}`>[]>(config: CreateAnalyticsHooksConfig<Api, TMetrics>): {
+    readonly useMetric: {
+        <Name extends TMetrics extends readonly (infer U)[] ? U extends string ? U : never : Exclude<ExtractNames<Api>, `dataset:${string}`>>(...args: QueryInput<Api, Name> extends never ? [name: Name, options?: QueryOptions<Api, Name>] : never): UseQueryResult<QueryOutput<Api, Name>, HttpError>;
+        <Name extends TMetrics extends readonly (infer U)[] ? U extends string ? U : never : Exclude<ExtractNames<Api>, `dataset:${string}`>, const TInput extends QueryInput<Api, Name>>(name: Name, input: TInput, options?: QueryOptions<Api, Name>): UseQueryResult<QueryOutputForInput<Api, Name, TInput>, HttpError>;
+    };
+    readonly useDataset: {
+        <Name extends DatasetNamesFromApi<Api>>(...args: QueryInput<Api, Extract<ExtractNames<Api>, DatasetKey<Name>>> extends never ? [name: Name, options?: QueryOptions<Api, Extract<ExtractNames<Api>, DatasetKey<Name>>>] : never): UseQueryResult<QueryOutput<Api, Extract<ExtractNames<Api>, DatasetKey<Name>>>, HttpError>;
+        <Name extends DatasetNamesFromApi<Api>, const TInput extends QueryInput<Api, Extract<ExtractNames<Api>, DatasetKey<Name>>>>(name: Name, input: TInput, options?: QueryOptions<Api, Extract<ExtractNames<Api>, DatasetKey<Name>>>): UseQueryResult<QueryOutputForInput<Api, Extract<ExtractNames<Api>, DatasetKey<Name>>, TInput>, HttpError>;
+    };
+    readonly useInfiniteMetric: <Name extends TMetrics extends readonly (infer U)[] ? U extends string ? U : never : Exclude<ExtractNames<Api>, `dataset:${string}`>>(name: Name, input: QueryInput<Api, Name>, options?: Parameters<(<Name_1 extends ExtractNames<Api>>(name: Name_1, input: QueryInput<Api, Name_1>, options?: Omit<import("@tanstack/react-query").UseInfiniteQueryOptions<QueryOutput<Api, Name_1>, HttpError, InfiniteData<QueryOutput<Api, Name_1>, number>, QueryInput<Api, Name_1> extends never ? ["hypequery", Name_1] : ["hypequery", Name_1, QueryInput<Api, Name_1>], number>, "queryKey" | "queryFn" | "getNextPageParam" | "initialPageParam"> | undefined) => UseInfiniteQueryResult<InfiniteData<QueryOutput<Api, Name_1>, number>, HttpError>)>[2]) => UseInfiniteQueryResult<InfiniteData<QueryOutput<Api, Name>, number>, HttpError>;
+    readonly useInfiniteDataset: <Name extends DatasetNamesFromApi<Api>>(name: Name, input: QueryInput<Api, Extract<ExtractNames<Api>, DatasetKey<Name>>>, options?: Parameters<(<Name_1 extends ExtractNames<Api>>(name: Name_1, input: QueryInput<Api, Name_1>, options?: Omit<import("@tanstack/react-query").UseInfiniteQueryOptions<QueryOutput<Api, Name_1>, HttpError, InfiniteData<QueryOutput<Api, Name_1>, number>, QueryInput<Api, Name_1> extends never ? ["hypequery", Name_1] : ["hypequery", Name_1, QueryInput<Api, Name_1>], number>, "queryKey" | "queryFn" | "getNextPageParam" | "initialPageParam"> | undefined) => UseInfiniteQueryResult<InfiniteData<QueryOutput<Api, Name_1>, number>, HttpError>)>[2]) => UseInfiniteQueryResult<InfiniteData<QueryOutput<Api, Extract<ExtractNames<Api>, DatasetKey<Name>>>, number>, HttpError>;
+    readonly useQuery: <Name extends ExtractNames<Api>>(...args: QueryInput<Api, Name> extends never ? [name: Name, options?: Omit<TanstackUseQueryOptions<QueryOutput<Api, Name>, HttpError, QueryOutput<Api, Name>, QueryInput<Api, Name> extends never ? ["hypequery", Name] : ["hypequery", Name, QueryInput<Api, Name>]>, "queryKey" | "queryFn"> | undefined] : [name: Name, input: QueryInput<Api, Name>, options?: Omit<TanstackUseQueryOptions<QueryOutput<Api, Name>, HttpError, QueryOutput<Api, Name>, QueryInput<Api, Name> extends never ? ["hypequery", Name] : ["hypequery", Name, QueryInput<Api, Name>]>, "queryKey" | "queryFn"> | undefined]) => UseQueryResult<QueryOutput<Api, Name>, HttpError>;
+    readonly useMutation: <Name extends ExtractNames<Api>>(name: Name, options?: Omit<import("@tanstack/react-query").UseMutationOptions<QueryOutput<Api, Name>, HttpError, QueryInput<Api, Name>, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<QueryOutput<Api, Name>, HttpError, QueryInput<Api, Name>>;
+    readonly useInfiniteQuery: <Name extends ExtractNames<Api>>(name: Name, input: QueryInput<Api, Name>, options?: Omit<import("@tanstack/react-query").UseInfiniteQueryOptions<QueryOutput<Api, Name>, HttpError, InfiniteData<QueryOutput<Api, Name>, number>, QueryInput<Api, Name> extends never ? ["hypequery", Name] : ["hypequery", Name, QueryInput<Api, Name>], number>, "queryKey" | "queryFn" | "getNextPageParam" | "initialPageParam"> | undefined) => UseInfiniteQueryResult<InfiniteData<QueryOutput<Api, Name>, number>, HttpError>;
+};
+export {};
+//# sourceMappingURL=analyticsHooks.d.ts.map

package/dist/analyticsHooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyticsHooks.d.ts","sourceRoot":"","sources":["../src/analyticsHooks.tsx"],"names":[],"mappings":"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"}

package/dist/analyticsHooks.js

@@ -0,0 +1,27 @@
+import { createHooks } from './createHooks.js';
+export function createAnalyticsHooks(config) {
+    const hooks = createHooks(config);
+    function useMetric(...args) {
+        const [name, ...rest] = args;
+        return hooks.useQuery(name, ...rest);
+    }
+    function useDataset(...args) {
+        const [name, ...rest] = args;
+        const key = `dataset:${String(name)}`;
+        return hooks.useQuery(key, ...rest);
+    }
+    function useInfiniteMetric(name, input, options) {
+        return hooks.useInfiniteQuery(name, input, options);
+    }
+    function useInfiniteDataset(name, input, options) {
+        const key = `dataset:${String(name)}`;
+        return hooks.useInfiniteQuery(key, input, options);
+    }
+    return {
+        ...hooks,
+        useMetric,
+        useDataset,
+        useInfiniteMetric,
+        useInfiniteDataset,
+    };
+}