@geekmidas/client 9.0.1 → 10.0.0-alpha.0

package/src/react-query.ts

@@ -1,341 +0,0 @@
-import type {
-	QueryClient,
-	QueryFunctionContext,
-	UseInfiniteQueryOptions,
-	UseMutationOptions,
-	UseQueryOptions,
-} from '@tanstack/react-query';
-import {
-	useInfiniteQuery,
-	useMutation,
-	useQuery,
-	useQueryClient,
-} from '@tanstack/react-query';
-import { useMemo } from 'react';
-import { createTypedFetcher } from './fetcher';
-import type {
-	ExtractEndpointResponse,
-	FetcherOptions,
-	FilteredRequestConfig,
-	MutationEndpoint,
-	QueryEndpoint,
-	TypedEndpoint,
-} from './types';
-
-export interface TypedQueryClientOptions extends FetcherOptions {
-	queryClient?: QueryClient;
-}
-
-export class TypedQueryClient<Paths> {
-	private fetcher: ReturnType<typeof createTypedFetcher<Paths>>;
-	private queryClient?: QueryClient;
-
-	constructor(options: TypedQueryClientOptions = {}) {
-		this.fetcher = createTypedFetcher<Paths>(options);
-		this.queryClient = options.queryClient;
-	}
-
-	useQuery<T extends QueryEndpoint<Paths>>(
-		endpoint: T,
-		config?: FilteredRequestConfig<Paths, T>,
-		options?: Omit<
-			UseQueryOptions<ExtractEndpointResponse<Paths, T>, Response>,
-			'queryKey' | 'queryFn'
-		>,
-	) {
-		const queryKey = this.buildQueryKey(endpoint, config);
-
-		// Memoize the combined options to prevent unnecessary re-renders
-		const memoizedOptions = useMemo(
-			() => ({
-				queryKey,
-				queryFn: () => this.fetcher(endpoint, config),
-				...options,
-			}),
-			// Dependencies: queryKey, endpoint, config, and options
-			// Note: We stringify config and options to ensure stable references
-			// eslint-disable-next-line react-hooks/exhaustive-deps
-			[
-				queryKey.join(','),
-				endpoint,
-				JSON.stringify(config),
-				JSON.stringify(options),
-			],
-		);
-
-		return useQuery<ExtractEndpointResponse<Paths, T>, Response>(
-			memoizedOptions,
-		);
-	}
-
-	useMutation<T extends MutationEndpoint<Paths>>(
-		endpoint: T,
-		options?: Omit<
-			UseMutationOptions<
-				ExtractEndpointResponse<Paths, T>,
-				Response,
-				FilteredRequestConfig<Paths, T>
-			>,
-			'mutationFn'
-		>,
-	) {
-		// Memoize the combined options to prevent unnecessary re-renders
-		const memoizedOptions = useMemo(
-			() => ({
-				mutationFn: (config: FilteredRequestConfig<Paths, T>) =>
-					this.fetcher(endpoint, config),
-				...options,
-			}),
-			// Dependencies: endpoint and options
-			// Note: We stringify options to ensure stable reference
-			// eslint-disable-next-line react-hooks/exhaustive-deps
-			[endpoint, JSON.stringify(options)],
-		);
-
-		return useMutation<
-			ExtractEndpointResponse<Paths, T>,
-			Response,
-			FilteredRequestConfig<Paths, T>
-		>(memoizedOptions);
-	}
-
-	useInfiniteQuery<
-		T extends QueryEndpoint<Paths>,
-		TPageData = ExtractEndpointResponse<Paths, T>,
-		TPageParam = unknown,
-	>(
-		endpoint: T,
-		options: Omit<
-			UseInfiniteQueryOptions<
-				TPageData,
-				Response,
-				{ pages: TPageData[]; pageParams: TPageParam[] },
-				unknown[],
-				TPageParam
-			>,
-			'queryKey' | 'queryFn' | 'getNextPageParam' | 'initialPageParam'
-		> & {
-			getNextPageParam: (
-				lastPage: TPageData,
-				allPages: TPageData[],
-				lastPageParam: TPageParam,
-				allPageParams: TPageParam[],
-			) => TPageParam | undefined;
-			initialPageParam: TPageParam;
-		},
-		config?: FilteredRequestConfig<Paths, T>,
-	) {
-		const queryKey = this.buildQueryKey(endpoint, config);
-
-		// Memoize the combined options to prevent unnecessary re-renders
-		const memoizedOptions = useMemo(
-			() => ({
-				queryKey,
-				queryFn: ({
-					pageParam,
-				}: QueryFunctionContext<unknown[], TPageParam>) => {
-					let mergedConfig = config;
-					if (pageParam !== undefined && config) {
-						// If pageParam is an object, spread it into query
-						const pageQuery =
-							typeof pageParam === 'object' ? pageParam : { page: pageParam };
-						mergedConfig = {
-							...config,
-							query: { ...(config as any).query, ...pageQuery },
-						} as any;
-					} else if (pageParam !== undefined && !config) {
-						// If pageParam is an object, use it directly, otherwise wrap in page property
-						const pageQuery =
-							typeof pageParam === 'object' ? pageParam : { page: pageParam };
-						mergedConfig = { query: pageQuery } as any;
-					}
-					return this.fetcher(endpoint, mergedConfig) as Promise<TPageData>;
-				},
-				...options,
-			}),
-			// Dependencies: queryKey, endpoint, config, and options
-			// Note: We stringify config and options to ensure stable references
-			// eslint-disable-next-line react-hooks/exhaustive-deps
-			[
-				queryKey.join(','),
-				endpoint,
-				JSON.stringify(config),
-				JSON.stringify(options),
-			],
-		);
-
-		return useInfiniteQuery<
-			TPageData,
-			Response,
-			{ pages: TPageData[]; pageParams: TPageParam[] },
-			unknown[],
-			TPageParam
-		>(memoizedOptions);
-	}
-
-	buildQueryKey<T extends TypedEndpoint<Paths>>(
-		endpoint: T,
-		config?: FilteredRequestConfig<Paths, T>,
-	): unknown[] {
-		const key: unknown[] = [endpoint];
-
-		if (config && 'params' in config && config.params) {
-			key.push({ params: config.params });
-		}
-
-		if (config && 'query' in config && config.query) {
-			key.push({ query: config.query });
-		}
-
-		return key;
-	}
-
-	/**
-	 * Invalidate queries for a specific endpoint with optional config
-	 * @param endpoint - The endpoint to invalidate (e.g., 'GET /users')
-	 * @param config - Optional params/query to match specific queries
-	 * @returns Promise that resolves when invalidation is complete
-	 */
-	invalidateQueries<T extends QueryEndpoint<Paths>>(
-		endpoint: T,
-		config?: FilteredRequestConfig<Paths, T>,
-	): Promise<void> {
-		const queryClient = this.getQueryClient();
-		const queryKey = this.buildQueryKey(endpoint, config);
-
-		return queryClient.invalidateQueries({
-			queryKey,
-			exact: !!config, // Use exact matching if config is provided
-		});
-	}
-
-	/**
-	 * Invalidate all queries in the cache
-	 * @returns Promise that resolves when invalidation is complete
-	 */
-	invalidateAllQueries(): Promise<void> {
-		const queryClient = this.getQueryClient();
-		return queryClient.invalidateQueries();
-	}
-
-	/**
-	 * Get the underlying QueryClient instance
-	 * @returns The QueryClient instance
-	 */
-	getQueryClient(): QueryClient {
-		if (this.queryClient) {
-			return this.queryClient;
-		}
-
-		// If no query client was provided, try to get it from context
-		// This will throw if used outside of QueryClientProvider
-		throw new Error(
-			'No QueryClient set, please provide a QueryClient via the queryClient option or ensure you are within a QueryClientProvider',
-		);
-	}
-
-	/**
-	 * Set the QueryClient instance
-	 * @param queryClient - The QueryClient instance to use
-	 */
-	setQueryClient(queryClient: QueryClient): void {
-		this.queryClient = queryClient;
-	}
-}
-
-export function createTypedQueryClient<Paths>(
-	options?: TypedQueryClientOptions,
-) {
-	return new TypedQueryClient<Paths>(options);
-}
-
-// Hook exports for convenience
-export function useTypedQuery<Paths, T extends QueryEndpoint<Paths>>(
-	client: TypedQueryClient<Paths>,
-	endpoint: T,
-	config?: FilteredRequestConfig<Paths, T>,
-	options?: Omit<
-		UseQueryOptions<ExtractEndpointResponse<Paths, T>, Response>,
-		'queryKey' | 'queryFn'
-	>,
-) {
-	return client.useQuery(endpoint, config, options);
-}
-
-export function useTypedMutation<Paths, T extends MutationEndpoint<Paths>>(
-	client: TypedQueryClient<Paths>,
-	endpoint: T,
-	options?: Omit<
-		UseMutationOptions<
-			ExtractEndpointResponse<Paths, T>,
-			Response,
-			FilteredRequestConfig<Paths, T>
-		>,
-		'mutationFn'
-	>,
-) {
-	return client.useMutation(endpoint, options);
-}
-
-export function useTypedInfiniteQuery<
-	Paths,
-	T extends QueryEndpoint<Paths>,
-	TPageData = ExtractEndpointResponse<Paths, T>,
-	TPageParam = unknown,
->(
-	client: TypedQueryClient<Paths>,
-	endpoint: T,
-	options: Omit<
-		UseInfiniteQueryOptions<
-			TPageData,
-			Response,
-			{ pages: TPageData[]; pageParams: TPageParam[] },
-			unknown[],
-			TPageParam
-		>,
-		'queryKey' | 'queryFn' | 'getNextPageParam' | 'initialPageParam'
-	> & {
-		getNextPageParam: (
-			lastPage: TPageData,
-			allPages: TPageData[],
-			lastPageParam: TPageParam,
-			allPageParams: TPageParam[],
-		) => TPageParam | undefined;
-		initialPageParam: TPageParam;
-	},
-	config?: FilteredRequestConfig<Paths, T>,
-) {
-	return client.useInfiniteQuery(endpoint, options, config);
-}
-
-/**
- * Hook to invalidate queries using the current QueryClient from context
- */
-export function useTypedInvalidateQueries<Paths>(
-	client: TypedQueryClient<Paths>,
-) {
-	const queryClient = useQueryClient();
-
-	return {
-		/**
-		 * Invalidate queries for a specific endpoint
-		 */
-		invalidateQueries: <T extends QueryEndpoint<Paths>>(
-			endpoint: T,
-			config?: FilteredRequestConfig<Paths, T>,
-		) => {
-			const queryKey = client.buildQueryKey(endpoint, config);
-			return queryClient.invalidateQueries({
-				queryKey,
-				exact: !!config,
-			});
-		},
-
-		/**
-		 * Invalidate all queries
-		 */
-		invalidateAllQueries: () => {
-			return queryClient.invalidateQueries();
-		},
-	};
-}

package/src/types.ts

@@ -1,226 +0,0 @@
-export type OpenAPIRoutes<Paths> = keyof Paths;
-
-type HttpMethod =
-	| 'get'
-	| 'post'
-	| 'put'
-	| 'patch'
-	| 'delete'
-	| 'head'
-	| 'options';
-
-export type ExtractMethod<Paths, Route extends OpenAPIRoutes<Paths>> = Extract<
-	keyof Paths[Route],
-	HttpMethod
->;
-
-export type ExtractPathParams<
-	Paths,
-	Route extends OpenAPIRoutes<Paths>,
-> = Paths[Route] extends {
-	parameters?: { path?: infer P };
-}
-	? P
-	: never;
-
-export type ExtractQueryParams<
-	Paths,
-	Route extends OpenAPIRoutes<Paths>,
-	Method extends ExtractMethod<Paths, Route>,
-> = Paths[Route][Method] extends { parameters?: { query?: infer Q } }
-	? Q
-	: never;
-
-export type ExtractRequestBody<
-	Paths,
-	Route extends OpenAPIRoutes<Paths>,
-	Method extends ExtractMethod<Paths, Route>,
-> = Paths[Route][Method] extends {
-	requestBody?: { content?: { 'application/json'?: infer B } };
-}
-	? B
-	: never;
-
-export type ExtractResponse<
-	Paths,
-	Route extends OpenAPIRoutes<Paths>,
-	Method extends ExtractMethod<Paths, Route>,
-> = Paths[Route][Method] extends {
-	responses?: { 200?: { content?: { 'application/json'?: infer R } } };
-}
-	? R
-	: Paths[Route][Method] extends {
-				responses?: { 201?: { content?: { 'application/json'?: infer R } } };
-			}
-		? R
-		: never;
-
-export type RequestConfig<
-	Paths,
-	Route extends OpenAPIRoutes<Paths>,
-	Method extends ExtractMethod<Paths, Route>,
-> = {
-	params?: ExtractPathParams<Paths, Route>;
-	query?: ExtractQueryParams<Paths, Route, Method>;
-	body?: ExtractRequestBody<Paths, Route, Method>;
-	headers?: Record<string, string>;
-};
-
-export type EndpointString = `${Uppercase<string>} ${string}`;
-
-// Generate all valid endpoint strings from OpenAPI paths
-// Uses Extract with HttpMethod to filter out non-HTTP keys like 'parameters'
-export type ValidEndpoint<Paths> = {
-	[Route in keyof Paths]: {
-		[Method in Extract<keyof Paths[Route], HttpMethod>]: `${Uppercase<
-			string & Method
-		>} ${string & Route}`;
-	}[Extract<keyof Paths[Route], HttpMethod>];
-}[keyof Paths];
-
-// Helper type to get autocomplete for endpoint strings
-export type TypedEndpoint<Paths> =
-	ValidEndpoint<Paths> extends infer E ? (E extends string ? E : never) : never;
-
-// Filter endpoints by HTTP method
-export type FilterEndpointByMethod<
-	Paths,
-	Method extends string,
-> = ValidEndpoint<Paths> extends infer E
-	? E extends `${Method} ${string}`
-		? E
-		: never
-	: never;
-
-// Query endpoints (GET only)
-export type QueryEndpoint<Paths> = FilterEndpointByMethod<Paths, 'GET'>;
-
-// Mutation endpoints (POST, PATCH, PUT, DELETE)
-export type MutationEndpoint<Paths> =
-	| FilterEndpointByMethod<Paths, 'POST'>
-	| FilterEndpointByMethod<Paths, 'PATCH'>
-	| FilterEndpointByMethod<Paths, 'PUT'>
-	| FilterEndpointByMethod<Paths, 'DELETE'>;
-
-export type ParseEndpoint<T extends EndpointString> =
-	T extends `${infer Method} ${infer Route}`
-		? { method: Lowercase<Method>; route: Route }
-		: never;
-
-export type ExtractEndpointResponse<
-	Paths,
-	T extends EndpointString,
-> = T extends `${infer Method} ${infer Route}`
-	? Route extends OpenAPIRoutes<Paths>
-		? Lowercase<Method> extends ExtractMethod<Paths, Route>
-			? ExtractResponse<Paths, Route, Lowercase<Method>>
-			: never
-		: never
-	: never;
-
-export type ExtractEndpointConfig<
-	Paths,
-	T extends EndpointString,
-> = T extends `${infer Method} ${infer Route}`
-	? Route extends OpenAPIRoutes<Paths>
-		? Lowercase<Method> extends ExtractMethod<Paths, Route>
-			? RequestConfig<Paths, Route, Lowercase<Method>>
-			: never
-		: never
-	: never;
-
-/**
- * Build a request config type where:
- * - `params` is required if the endpoint has path parameters
- * - `body` is required if the endpoint has a request body
- * - `query` and `headers` are always optional
- */
-export type FilteredRequestConfig<
-	Paths,
-	T extends EndpointString,
-> = T extends `${infer Method} ${infer Route}`
-	? Route extends OpenAPIRoutes<Paths>
-		? Lowercase<Method> extends ExtractMethod<Paths, Route>
-			? BuildRequestConfig<
-					ExtractPathParams<Paths, Route>,
-					ExtractQueryParams<Paths, Route, Lowercase<Method>>,
-					ExtractRequestBody<Paths, Route, Lowercase<Method>>
-				>
-			: never
-		: never
-	: never;
-
-/**
- * Helper to build request config with correct required/optional fields.
- * Uses [T] extends [never] pattern to prevent distribution over union types,
- * which would cause the entire type to become `never`.
- */
-type BuildRequestConfig<TParams, TQuery, TBody> = SimplifyIntersection<
-	// params: required if not never
-	([TParams] extends [never] ? {} : { params: TParams }) &
-		// body: required if not never
-		([TBody] extends [never] ? {} : { body: TBody }) &
-		// query: optional if not never
-		([TQuery] extends [never] ? {} : { query?: TQuery }) & {
-			// headers: always optional
-			headers?: Record<string, string>;
-		}
->;
-
-/**
- * Simplify intersection types for better IDE display
- */
-type SimplifyIntersection<T> = { [K in keyof T]: T[K] };
-
-/**
- * Check if the config object is required (has any required fields)
- */
-export type IsConfigRequired<
-	Paths,
-	T extends EndpointString,
-> = T extends `${infer Method} ${infer Route}`
-	? Route extends OpenAPIRoutes<Paths>
-		? Lowercase<Method> extends ExtractMethod<Paths, Route>
-			? ExtractPathParams<Paths, Route> extends never
-				? ExtractRequestBody<Paths, Route, Lowercase<Method>> extends never
-					? false
-					: true
-				: true
-			: false
-		: false
-	: false;
-
-/**
- * Typed function signature for the API client.
- * Config is required when endpoint has path params or body.
- */
-export type TypedApiFunction<Paths> = <T extends TypedEndpoint<Paths>>(
-	endpoint: T,
-	...args: IsConfigRequired<Paths, T> extends true
-		? [config: FilteredRequestConfig<Paths, T>]
-		: [config?: FilteredRequestConfig<Paths, T>]
-) => Promise<ExtractEndpointResponse<Paths, T>>;
-
-export interface FetcherOptions {
-	baseURL?: string;
-	headers?: Record<string, string>;
-	onRequest?: (config: RequestInit) => RequestInit | Promise<RequestInit>;
-	onResponse?: (response: Response) => Response | Promise<Response>;
-	onError?: (error: Error) => void | Promise<void>;
-	fetch?: typeof fetch;
-}
-
-export type WrappedResult<T, E = unknown> =
-	| { ok: true; data: T }
-	| { ok: false; error: E };
-
-export type ErrorTransformer<E> = (error: unknown) => E | Promise<E>;
-
-export type WrappedApiFunction<Paths, E = unknown> = <
-	T extends TypedEndpoint<Paths>,
->(
-	endpoint: T,
-	...args: IsConfigRequired<Paths, T> extends true
-		? [config: FilteredRequestConfig<Paths, T>]
-		: [config?: FilteredRequestConfig<Paths, T>]
-) => Promise<WrappedResult<ExtractEndpointResponse<Paths, T>, E>>;

package/tsconfig.json

@@ -1,12 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "composite": true,
-    "lib": ["ES2023", "DOM"],
-    "jsx": "react-jsx"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["src/__tests__/**/*"]
-}