@geekmidas/client 0.0.1

package/src/fetcher.ts

@@ -0,0 +1,173 @@
+import type {
+  EndpointString,
+  ExtractEndpointResponse,
+  FetcherOptions,
+  FilteredRequestConfig,
+  ParseEndpoint,
+  TypedEndpoint,
+} 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 queryParams = new URLSearchParams();
+
+      // Recursive function to handle nested objects and arrays
+      const appendQueryParam = (prefix: string, value: unknown) => {
+        if (value === undefined || value === null) {
+          return;
+        }
+
+        if (Array.isArray(value)) {
+          // Handle arrays by appending multiple values with the same key
+          value.forEach((item) => {
+            queryParams.append(prefix, String(item));
+          });
+        } else if (typeof value === 'object') {
+          // For objects, recursively flatten into dot notation
+          Object.entries(value as Record<string, unknown>).forEach(
+            ([subKey, subValue]) => {
+              appendQueryParam(`${prefix}.${subKey}`, subValue);
+            },
+          );
+        } else {
+          queryParams.append(prefix, String(value));
+        }
+      };
+
+      // Process all query parameters
+      Object.entries(config.query as Record<string, unknown>).forEach(
+        ([key, value]) => {
+          appendQueryParam(key, value);
+        },
+      );
+
+      const queryString = queryParams.toString();
+      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-ignore
+        await this.options.onError(error);
+      }
+      throw error;
+    }
+  }
+
+  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);
+  return <T extends TypedEndpoint<Paths>>(
+    endpoint: T,
+    config?: FilteredRequestConfig<Paths, T>,
+  ) => fetcher.request(endpoint, config);
+}
+
+export type FetchFn = typeof fetch;

package/src/openapi-hooks.ts

@@ -0,0 +1,193 @@
+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 } }
+        ? void
+        : 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
+    if (operations && operations[operationId as string]) {
+      const op = operations[operationId as string];
+      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,
+      });
+    },
+  };
+}