@geekmidas/client 9.0.1 → 10.0.0-alpha.0

package/src/fetcher.ts

@@ -1,171 +0,0 @@
-import qs from 'qs';
-import type {
-	EndpointString,
-	ErrorTransformer,
-	ExtractEndpointResponse,
-	FetcherOptions,
-	FilteredRequestConfig,
-	ParseEndpoint,
-	TypedEndpoint,
-	WrappedResult,
-} from './types';
-
-export type { FetcherOptions, WrappedResult } from './types';
-
-export class TypedFetcher<Paths> {
-	private baseURL: string;
-	private defaultHeaders: Record<string, string>;
-	private options: FetcherOptions;
-	private fetchFn: FetchFn;
-
-	static getFetchFn(fn?: FetchFn): FetchFn {
-		if (fn) {
-			return fn;
-		}
-
-		if (typeof window !== 'undefined' && typeof window.fetch === 'function') {
-			return window.fetch.bind(window);
-		}
-
-		if (
-			typeof globalThis !== 'undefined' &&
-			typeof globalThis.fetch === 'function'
-		) {
-			return globalThis.fetch.bind(globalThis);
-		}
-
-		throw new Error('No fetch implementation found');
-	}
-
-	constructor(options: FetcherOptions = {}) {
-		this.baseURL = options.baseURL || '';
-		this.defaultHeaders = options.headers || {};
-		this.options = options;
-		this.fetchFn = TypedFetcher.getFetchFn(options.fetch);
-	}
-
-	async request<T extends TypedEndpoint<Paths>>(
-		endpoint: T,
-		config?: FilteredRequestConfig<Paths, T>,
-	): Promise<ExtractEndpointResponse<Paths, T>> {
-		const { method, route } = this.parseEndpoint(endpoint);
-
-		// Replace path parameters
-		let url = route;
-		if (config && 'params' in config && config.params) {
-			Object.entries(config.params as Record<string, unknown>).forEach(
-				([key, value]) => {
-					url = url.replace(`{${key}}`, encodeURIComponent(String(value)));
-				},
-			);
-		}
-
-		// Add query parameters
-		if (config && 'query' in config && config.query) {
-			const queryString = qs.stringify(config.query, {
-				encode: true,
-				arrayFormat: 'brackets',
-				skipNulls: true,
-			});
-			if (queryString) {
-				url += `?${queryString}`;
-			}
-		}
-
-		// Build request configuration
-		let requestConfig: RequestInit = {
-			method: method.toUpperCase(),
-			headers: {
-				...this.defaultHeaders,
-				...((config && 'headers' in config && config.headers) || {}),
-			},
-		};
-
-		// Add body if present
-		if (config && 'body' in config && config.body) {
-			requestConfig.body = JSON.stringify(config.body);
-			requestConfig.headers = {
-				...requestConfig.headers,
-				'Content-Type': 'application/json',
-			};
-		}
-
-		// Apply request interceptor
-		if (this.options.onRequest) {
-			requestConfig = await this.options.onRequest(requestConfig);
-		}
-
-		try {
-			// Make the request
-			let response = await this.fetchFn(`${this.baseURL}${url}`, requestConfig);
-
-			// Apply response interceptor
-			if (this.options.onResponse) {
-				response = await this.options.onResponse(response);
-			}
-
-			// Handle errors
-			if (!response.ok) {
-				throw response;
-			}
-
-			// Handle empty responses (204 No Content, etc.)
-			if (
-				response.status === 204 ||
-				response.headers.get('content-length') === '0'
-			) {
-				return undefined as ExtractEndpointResponse<Paths, T>;
-			}
-
-			// Parse JSON response
-			const data = await response.json();
-			return data as ExtractEndpointResponse<Paths, T>;
-		} catch (error) {
-			// Apply error handler
-			if (this.options.onError) {
-				// @ts-expect-error
-				await this.options.onError(error);
-			}
-			throw error;
-		}
-	}
-
-	wrap<E = unknown>(onError?: ErrorTransformer<E>) {
-		return <T extends TypedEndpoint<Paths>>(
-			endpoint: T,
-			config?: FilteredRequestConfig<Paths, T>,
-		): Promise<WrappedResult<ExtractEndpointResponse<Paths, T>, E>> =>
-			this.request(endpoint, config).then(
-				(data) => ({ ok: true as const, data }),
-				async (error) => ({
-					ok: false as const,
-					error: onError ? await onError(error) : (error as E),
-				}),
-			);
-	}
-
-	private parseEndpoint<T extends EndpointString>(
-		endpoint: T,
-	): ParseEndpoint<T> {
-		const [method, ...routeParts] = endpoint.split(' ');
-		const route = routeParts.join(' ');
-		return { method: method?.toLowerCase() ?? '', route } as ParseEndpoint<T>;
-	}
-}
-
-export function createTypedFetcher<Paths>(options?: FetcherOptions) {
-	const fetcher = new TypedFetcher<Paths>(options);
-	const fn = <T extends TypedEndpoint<Paths>>(
-		endpoint: T,
-		config?: FilteredRequestConfig<Paths, T>,
-	) => fetcher.request(endpoint, config);
-
-	return Object.assign(fn, {
-		wrap: <E = unknown>(onError?: ErrorTransformer<E>) =>
-			Object.assign(fetcher.wrap(onError), fn, {
-				wrap: undefined,
-			}),
-	});
-}
-
-export type FetchFn = typeof fetch;

package/src/openapi-hooks.ts

@@ -1,193 +0,0 @@
-import type {
-	UseMutationOptions,
-	UseQueryOptions,
-} from '@tanstack/react-query';
-import { useMutation, useQuery } from '@tanstack/react-query';
-import { createTypedFetcher } from './fetcher';
-import type { FetcherOptions } from './types';
-
-// Simplified type helpers for OpenAPI paths
-type HttpMethods = 'get' | 'post' | 'put' | 'patch' | 'delete';
-
-// Extract all operations from paths
-type AllOperations<Paths> = {
-	[Path in keyof Paths]: {
-		[Method in keyof Paths[Path] & HttpMethods]: Paths[Path][Method] extends {
-			operationId: infer OpId;
-		}
-			? OpId extends string
-				? {
-						operationId: OpId;
-						path: Path;
-						method: Method;
-						spec: Paths[Path][Method] & {
-							_pathParams?: Paths[Path] extends {
-								parameters: { path: infer P };
-							}
-								? P
-								: never;
-						};
-					}
-				: never
-			: never;
-	}[keyof Paths[Path] & HttpMethods];
-}[keyof Paths];
-
-// Create operation map
-type OperationMap<Paths> = {
-	[Op in AllOperations<Paths> as Op extends {
-		operationId: infer Id extends string;
-	}
-		? Id
-		: never]: Op;
-};
-
-// Get operation IDs
-type OperationId<Paths> = keyof OperationMap<Paths>;
-
-// Get operations by method
-type OperationsByMethod<Paths, Method extends HttpMethods> = {
-	[K in OperationId<Paths>]: OperationMap<Paths>[K] extends { method: Method }
-		? K
-		: never;
-}[OperationId<Paths>];
-
-// Extract parameter types
-type OperationParams<
-	Paths,
-	OpId extends OperationId<Paths>,
-> = OperationMap<Paths>[OpId] extends {
-	path: infer Path extends keyof Paths;
-	spec: infer Spec;
-}
-	? {
-			params?: Paths[Path] extends { parameters: { path: infer P } }
-				? P
-				: Spec extends { parameters: { path: infer P } }
-					? P
-					: never;
-			query?: Spec extends { parameters?: { query?: infer Q } } ? Q : never;
-			body?: Spec extends {
-				requestBody: { content: { 'application/json': infer Body } };
-			}
-				? Body
-				: Spec extends {
-							requestBody: {
-								required: true;
-								content: { 'application/json': infer Body };
-							};
-						}
-					? Body
-					: never;
-		}
-	: never;
-
-// Extract response type
-type OperationResponse<
-	Paths,
-	OpId extends OperationId<Paths>,
-> = OperationMap<Paths>[OpId] extends { spec: infer Spec }
-	? Spec extends {
-			responses: { 200: { content: { 'application/json': infer R } } };
-		}
-		? R
-		: Spec extends {
-					responses: { 201: { content: { 'application/json': infer R } } };
-				}
-			? R
-			: Spec extends { responses: { 204: any } }
-				? undefined
-				: unknown
-	: never;
-
-// Remove never properties
-type RemoveNever<T> = Pick<
-	T,
-	{
-		[K in keyof T]: T[K] extends never ? never : K;
-	}[keyof T]
->;
-
-// Check if type is empty
-type IsEmpty<T> = keyof T extends never ? true : false;
-
-// Runtime operation registry (would be generated)
-interface OperationRegistry {
-	[operationId: string]: {
-		path: string;
-		method: string;
-	};
-}
-
-export function createOpenAPIHooks<Paths>(
-	options: FetcherOptions & { operations?: OperationRegistry } = {},
-) {
-	const { operations, ...fetcherOptions } = options;
-	const fetcher = createTypedFetcher<Paths>(fetcherOptions);
-
-	function buildEndpoint<OpId extends OperationId<Paths>>(
-		operationId: OpId,
-	): string {
-		// Runtime lookup from registry
-		const op = operations?.[operationId as string];
-		if (op) {
-			return `${op.method.toUpperCase()} ${op.path}`;
-		}
-		// Fallback for compile-time only usage
-		return operationId as string;
-	}
-
-	return {
-		useQuery: <OpId extends OperationsByMethod<Paths, 'get'>>(
-			operationId: OpId,
-			config?: RemoveNever<OperationParams<Paths, OpId>>,
-			options?: Omit<
-				UseQueryOptions<OperationResponse<Paths, OpId>, Error>,
-				'queryKey' | 'queryFn'
-			>,
-		) => {
-			const endpoint = buildEndpoint(operationId);
-			const queryKey = [operationId, ...(config ? [config] : [])];
-
-			return useQuery<OperationResponse<Paths, OpId>, Error>({
-				queryKey,
-				queryFn: async () => {
-					const response = await fetcher(endpoint as any, config as any);
-					return response as OperationResponse<Paths, OpId>;
-				},
-				...options,
-			});
-		},
-
-		useMutation: <
-			OpId extends Exclude<
-				OperationId<Paths>,
-				OperationsByMethod<Paths, 'get'>
-			>,
-		>(
-			operationId: OpId,
-			options?: Omit<
-				UseMutationOptions<
-					OperationResponse<Paths, OpId>,
-					Error,
-					RemoveNever<OperationParams<Paths, OpId>>
-				>,
-				'mutationFn'
-			>,
-		) => {
-			const endpoint = buildEndpoint(operationId);
-
-			return useMutation<
-				OperationResponse<Paths, OpId>,
-				Error,
-				RemoveNever<OperationParams<Paths, OpId>>
-			>({
-				mutationFn: async (variables) => {
-					const response = await fetcher(endpoint as any, variables as any);
-					return response as OperationResponse<Paths, OpId>;
-				},
-				...options,
-			});
-		},
-	};
-}