@umituz/react-native-design-system 4.23.66 → 4.23.68

package/src/services/api/types/ApiTypes.ts

@@ -0,0 +1,50 @@
+/**
+ * API Service Types
+ * Type definitions for API communication
+ */
+
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+
+export interface ApiRequestConfig {
+  url: string;
+  method: HttpMethod;
+  headers?: Record<string, string>;
+  params?: Record<string, string | number | boolean | undefined>;
+  body?: any;
+  timeout?: number;
+}
+
+export interface ApiResponse<T = any> {
+  data: T;
+  status: number;
+  statusText: string;
+  headers: Record<string, string>;
+}
+
+export interface ApiError {
+  message: string;
+  status?: number;
+  code?: string;
+  details?: any;
+}
+
+export interface RequestInterceptor {
+  (config: ApiRequestConfig): ApiRequestConfig | Promise<ApiRequestConfig>;
+}
+
+export interface ResponseInterceptor {
+  (response: ApiResponse): ApiResponse | Promise<ApiResponse>;
+}
+
+export interface ErrorInterceptor {
+  (error: ApiError): ApiError | Promise<ApiError>;
+}
+
+export interface ApiClientConfig {
+  baseURL: string;
+  timeout?: number;
+  headers?: Record<string, string>;
+  requestInterceptors?: RequestInterceptor[];
+  responseInterceptors?: ResponseInterceptor[];
+  errorInterceptors?: ErrorInterceptor[];
+}

package/src/services/api/utils/requestBuilder.ts

@@ -0,0 +1,92 @@
+/**
+ * Request Builder Utility
+ * Builds HTTP requests with proper configuration
+ */
+
+import type { ApiRequestConfig, HttpMethod } from '../types/ApiTypes';
+
+/**
+ * Builds query string from params object
+ *
+ * @param params - Query parameters
+ * @returns Query string
+ */
+export function buildQueryString(params: Record<string, string | number | boolean | undefined>): string {
+  const searchParams = new URLSearchParams();
+
+  Object.entries(params).forEach(([key, value]) => {
+    if (value !== undefined) {
+      searchParams.append(key, String(value));
+    }
+  });
+
+  const queryString = searchParams.toString();
+  return queryString ? `?${queryString}` : '';
+}
+
+/**
+ * Builds full URL with query parameters
+ *
+ * @param baseURL - Base URL
+ * @param path - Request path
+ * @param params - Query parameters
+ * @returns Full URL
+ */
+export function buildURL(
+  baseURL: string,
+  path: string,
+  params?: Record<string, string | number | boolean | undefined>
+): string {
+  const cleanPath = path.startsWith('/') ? path : `/${path}`;
+  const fullURL = `${baseURL}${cleanPath}`;
+
+  if (params) {
+    return `${fullURL}${buildQueryString(params)}`;
+  }
+
+  return fullURL;
+}
+
+/**
+ * Builds request configuration
+ *
+ * @param config - Request configuration
+ * @returns Built fetch options
+ */
+export function buildRequestConfig(config: ApiRequestConfig): RequestInit {
+  const options: RequestInit = {
+    method: config.method,
+    headers: {
+      'Content-Type': 'application/json',
+      ...config.headers,
+    },
+  };
+
+  if (config.body) {
+    options.body = JSON.stringify(config.body);
+  }
+
+  return options;
+}
+
+/**
+ * Creates a request builder function for a specific base URL
+ *
+ * @param baseURL - Base URL for all requests
+ * @returns Request builder function
+ */
+export function createRequestBuilder(baseURL: string) {
+  return (
+    path: string,
+    method: HttpMethod,
+    params?: Record<string, string | number | boolean | undefined>,
+    body?: any,
+    headers?: Record<string, string>
+  ): ApiRequestConfig => ({
+    url: buildURL(baseURL, path, params),
+    method,
+    params,
+    body,
+    headers,
+  });
+}

package/src/services/api/utils/responseHandler.ts

@@ -0,0 +1,130 @@
+/**
+ * Response Handler Utility
+ * Handles API responses and errors
+ */
+
+import type { ApiResponse, ApiError } from '../types/ApiTypes';
+
+/**
+ * Parses fetch response to ApiResponse
+ *
+ * @param response - Fetch response
+ * @returns Parsed API response
+ */
+export async function parseResponse<T>(response: Response): Promise<ApiResponse<T>> {
+  const data = await parseResponseBody<T>(response);
+
+  return {
+    data,
+    status: response.status,
+    statusText: response.statusText,
+    headers: Object.fromEntries(response.headers.entries()),
+  };
+}
+
+/**
+ * Parses response body based on content type
+ *
+ * @param response - Fetch response
+ * @returns Parsed body data
+ */
+async function parseResponseBody<T>(response: Response): Promise<T> {
+  const contentType = response.headers.get('Content-Type');
+
+  if (contentType?.includes('application/json')) {
+    const data = await response.json();
+    return data as T;
+  }
+
+  if (contentType?.includes('text/')) {
+    const text = await response.text();
+    return text as unknown as T;
+  }
+
+  const blob = await response.blob();
+  return blob as unknown as T;
+}
+
+/**
+ * Handles HTTP error and converts to ApiError
+ *
+ * @param response - Fetch response
+ * @returns ApiError object
+ */
+export async function handleHttpError(response: Response): Promise<ApiError> {
+  let details: any;
+
+  try {
+    details = await response.json();
+  } catch {
+    details = await response.text();
+  }
+
+  return {
+    message: details?.message || response.statusText || 'Request failed',
+    status: response.status,
+    code: details?.code,
+    details,
+  };
+}
+
+/**
+ * Handles network error
+ *
+ * @param error - Error object
+ * @returns ApiError object
+ */
+export function handleNetworkError(error: unknown): ApiError {
+  if (error instanceof Error) {
+    return {
+      message: error.message || 'Network error',
+      details: error,
+    };
+  }
+
+  return {
+    message: 'Unknown network error',
+    details: error,
+  };
+}
+
+/**
+ * Checks if response is successful
+ *
+ * @param response - Fetch response
+ * @returns True if response is OK
+ */
+export function isSuccessfulResponse(response: Response): boolean {
+  return response.ok && response.status >= 200 && response.status < 300;
+}
+
+/**
+ * Creates timeout promise
+ *
+ * @param ms - Timeout in milliseconds
+ * @returns Promise that rejects after timeout
+ */
+export function createTimeoutPromise(ms: number): Promise<never> {
+  return new Promise((_, reject) => {
+    setTimeout(() => reject(new Error(`Request timeout after ${ms}ms`)), ms);
+  });
+}
+
+/**
+ * Wraps fetch with timeout
+ *
+ * @param url - Request URL
+ * @param options - Fetch options
+ * @param timeout - Timeout in milliseconds
+ * @returns Fetch result with timeout
+ */
+export async function fetchWithTimeout(
+  url: string,
+  options: RequestInit,
+  timeout: number
+): Promise<Response> {
+  return Promise.race([
+    fetch(url, options),
+    createTimeoutPromise(timeout),
+  ]) as Promise<Response>;
+}

package/src/tanstack/domain/repositories/BaseRepository.ts

@@ -35,9 +35,8 @@
  * ```
  */
 
-import type { QueryClient, QueryKey } from '@tanstack/react-query';
+import type { QueryClient } from '@tanstack/react-query';
 import { getGlobalQueryClient } from '../config/QueryClientAccessor';
-import { CacheStrategies } from '../../infrastructure/config/QueryClientConfig';
 import { createQueryKeyFactory } from '../utils/QueryKeyFactory';
 import type {
   CreateParams,
@@ -45,6 +44,9 @@ import type {
   ListParams,
   RepositoryOptions,
 } from './RepositoryTypes';
+import { mergeRepositoryOptions, getCacheOptions } from './helpers/repositoryHelpers';
+import * as queryMethods from './mixins/repositoryQueryMethods';
+import * as invalidationMethods from './mixins/repositoryInvalidationMethods';
 
 /**
  * Base repository for CRUD operations
@@ -68,11 +70,7 @@ export abstract class BaseRepository<
 
   constructor(resource: string, options: RepositoryOptions = {}) {
     this.resource = resource;
-    this.options = {
-      cacheStrategy: options.cacheStrategy ?? CacheStrategies.PUBLIC_DATA,
-      ...options,
-    };
-
+    this.options = mergeRepositoryOptions(options);
     this.keys = createQueryKeyFactory(this.resource);
   }
 
@@ -87,10 +85,7 @@ export abstract class BaseRepository<
    * Get cache options for queries
    */
   protected getCacheOptions(): { staleTime: number; gcTime: number } {
-    return {
-      staleTime: this.options.staleTime ?? (this.options.cacheStrategy?.staleTime ?? CacheStrategies.PUBLIC_DATA.staleTime),
-      gcTime: this.options.gcTime ?? (this.options.cacheStrategy?.gcTime ?? CacheStrategies.PUBLIC_DATA.gcTime),
-    };
+    return getCacheOptions(this.options);
   }
 
   /**
@@ -122,120 +117,69 @@ export abstract class BaseRepository<
    * Query all items with caching
    */
   async queryAll(params?: ListParams): Promise<TData[]> {
-    const client = this.getClient();
-    const queryKey = params ? this.keys.list(params as Record<string, unknown>) : this.keys.lists();
-    const cacheOptions = this.getCacheOptions();
-
-    return client.fetchQuery({
-      queryKey: queryKey as QueryKey,
-      queryFn: () => this.fetchAll(params),
-      ...cacheOptions,
-    });
+    return queryMethods.queryAll(this, params);
   }
 
   /**
    * Query item by ID with caching
    */
   async queryById(id: string | number): Promise<TData | undefined> {
-    const client = this.getClient();
-    const queryKey = this.keys.detail(id);
-    const cacheOptions = this.getCacheOptions();
-
-    try {
-      return client.fetchQuery({
-        queryKey: queryKey as QueryKey,
-        queryFn: () => this.fetchById(id),
-        ...cacheOptions,
-      });
-    } catch {
-      return undefined;
-    }
+    return queryMethods.queryById(this, id);
   }
 
   /**
    * Prefetch all items
    */
   async prefetchAll(params?: ListParams): Promise<void> {
-    const client = this.getClient();
-    const queryKey = params ? this.keys.list(params as Record<string, unknown>) : this.keys.lists();
-    const cacheOptions = this.getCacheOptions();
-
-    await client.prefetchQuery({
-      queryKey: queryKey as QueryKey,
-      queryFn: () => this.fetchAll(params),
-      ...cacheOptions,
-    });
+    return queryMethods.prefetchAll(this, params);
   }
 
   /**
    * Prefetch item by ID
    */
   async prefetchById(id: string | number): Promise<void> {
-    const client = this.getClient();
-    const queryKey = this.keys.detail(id);
-    const cacheOptions = this.getCacheOptions();
-
-    await client.prefetchQuery({
-      queryKey: queryKey as QueryKey,
-      queryFn: () => this.fetchById(id),
-      ...cacheOptions,
-    });
+    return queryMethods.prefetchById(this, id);
   }
 
   /**
    * Invalidate all queries for this resource
    */
   invalidateAll(): Promise<void> {
-    const client = this.getClient();
-    return client.invalidateQueries({
-      predicate: (query: { queryKey: readonly unknown[] }) => {
-        const key = query.queryKey[0] as string;
-        return key === this.resource;
-      },
-    });
+    return invalidationMethods.invalidateAll(this);
   }
 
   /**
    * Invalidate list queries
    */
   invalidateLists(): Promise<void> {
-    const client = this.getClient();
-    return client.invalidateQueries({
-      queryKey: this.keys.lists(),
-    });
+    return invalidationMethods.invalidateLists(this);
   }
 
   /**
    * Invalidate detail query
    */
   invalidateDetail(id: string | number): Promise<void> {
-    const client = this.getClient();
-    return client.invalidateQueries({
-      queryKey: this.keys.detail(id),
-    });
+    return invalidationMethods.invalidateDetail(this, id);
   }
 
   /**
    * Set query data (optimistic update)
    */
   setData(id: string | number, data: TData): void {
-    const client = this.getClient();
-    client.setQueryData(this.keys.detail(id), data);
+    invalidationMethods.setData(this, id, data);
   }
 
   /**
    * Get query data from cache
    */
   getData(id: string | number): TData | undefined {
-    const client = this.getClient();
-    return client.getQueryData<TData>(this.keys.detail(id));
+    return invalidationMethods.getData(this, id);
   }
 
   /**
    * Remove query data from cache
    */
   clearData(id: string | number): void {
-    const client = this.getClient();
-    client.setQueryData(this.keys.detail(id), undefined);
+    invalidationMethods.clearData(this, id);
   }
 }

package/src/tanstack/domain/repositories/helpers/repositoryHelpers.ts

@@ -0,0 +1,58 @@
+/**
+ * Repository Helper Functions
+ * Common helper functions for repository operations
+ */
+
+import type { RepositoryOptions } from '../RepositoryTypes';
+import { CacheStrategies } from '../../../infrastructure/config/QueryClientConfig';
+
+/**
+ * Gets cache options for repository queries
+ *
+ * @param options - Repository options
+ * @returns Cache options with staleTime and gcTime
+ */
+export function getCacheOptions(
+  options: RepositoryOptions
+): { staleTime: number; gcTime: number } {
+  return {
+    staleTime:
+      options.staleTime ??
+      options.cacheStrategy?.staleTime ??
+      CacheStrategies.PUBLIC_DATA.staleTime,
+    gcTime:
+      options.gcTime ??
+      options.cacheStrategy?.gcTime ??
+      CacheStrategies.PUBLIC_DATA.gcTime,
+  };
+}
+
+/**
+ * Merges repository options with defaults
+ *
+ * @param options - User provided options
+ * @returns Merged options
+ */
+export function mergeRepositoryOptions(
+  options: RepositoryOptions = {}
+): Required<Pick<RepositoryOptions, 'cacheStrategy'>> & RepositoryOptions {
+  return {
+    cacheStrategy: options.cacheStrategy ?? CacheStrategies.PUBLIC_DATA,
+    ...options,
+  };
+}
+
+/**
+ * Checks if a query key matches a resource
+ *
+ * @param queryKey - Query key to check
+ * @param resource - Resource name to match
+ * @returns True if query key matches resource
+ */
+export function matchesResource(
+  queryKey: readonly unknown[],
+  resource: string
+): boolean {
+  const key = queryKey[0] as string;
+  return key === resource;
+}

package/src/tanstack/domain/repositories/mixins/repositoryInvalidationMethods.ts

@@ -0,0 +1,101 @@
+/**
+ * Repository Invalidation Methods
+ * Cache invalidation methods for repository operations
+ */
+
+import type { QueryClient } from '@tanstack/react-query';
+import type { BaseRepository } from '../BaseRepository';
+import { matchesResource } from '../helpers/repositoryHelpers';
+
+/**
+ * Invalidate all queries for this resource
+ *
+ * @param repository - Repository instance
+ */
+export function invalidateAll<TData>(
+  repository: BaseRepository<TData, unknown, unknown>
+): Promise<void> {
+  const client = (repository as any).getClient() as QueryClient;
+  const resource = (repository as any).resource;
+
+  return client.invalidateQueries({
+    predicate: (query: { queryKey: readonly unknown[] }) => {
+      return matchesResource(query.queryKey, resource);
+    },
+  });
+}
+
+/**
+ * Invalidate list queries
+ *
+ * @param repository - Repository instance
+ */
+export function invalidateLists<TData>(
+  repository: BaseRepository<TData, unknown, unknown>
+): Promise<void> {
+  const client = (repository as any).getClient() as QueryClient;
+  return client.invalidateQueries({
+    queryKey: repository.keys.lists(),
+  });
+}
+
+/**
+ * Invalidate detail query
+ *
+ * @param repository - Repository instance
+ * @param id - Item ID
+ */
+export function invalidateDetail<TData>(
+  repository: BaseRepository<TData, unknown, unknown>,
+  id: string | number
+): Promise<void> {
+  const client = (repository as any).getClient() as QueryClient;
+  return client.invalidateQueries({
+    queryKey: repository.keys.detail(id),
+  });
+}
+
+/**
+ * Set query data (optimistic update)
+ *
+ * @param repository - Repository instance
+ * @param id - Item ID
+ * @param data - Data to set
+ */
+export function setData<TData>(
+  repository: BaseRepository<TData, unknown, unknown>,
+  id: string | number,
+  data: TData
+): void {
+  const client = (repository as any).getClient() as QueryClient;
+  client.setQueryData(repository.keys.detail(id), data);
+}
+
+/**
+ * Get query data from cache
+ *
+ * @param repository - Repository instance
+ * @param id - Item ID
+ * @returns Cached data or undefined
+ */
+export function getData<TData>(
+  repository: BaseRepository<TData, unknown, unknown>,
+  id: string | number
+): TData | undefined {
+  const client = (repository as any).getClient() as QueryClient;
+  return client.getQueryData<TData>(repository.keys.detail(id));
+}
+
+/**
+ * Remove query data from cache
+ *
+ * @param repository - Repository instance
+ * @param id - Item ID
+ */
+export function clearData<TData>(
+  repository: BaseRepository<TData, unknown, unknown>,
+  id: string | number
+): void {
+  const client = (repository as any).getClient() as QueryClient;
+  client.setQueryData(repository.keys.detail(id), undefined);
+}

package/src/tanstack/domain/repositories/mixins/repositoryQueryMethods.ts

@@ -0,0 +1,102 @@
+/**
+ * Repository Query Methods
+ * Query methods for repository operations
+ */
+
+import type { QueryClient, QueryKey } from '@tanstack/react-query';
+import type { ListParams } from '../RepositoryTypes';
+import type { BaseRepository } from '../BaseRepository';
+
+/**
+ * Query all items with caching
+ *
+ * @param repository - Repository instance
+ * @param params - Optional list parameters
+ * @returns Promise of data array
+ */
+export async function queryAll<TData>(
+  repository: BaseRepository<TData, unknown, unknown>,
+  params?: ListParams
+): Promise<TData[]> {
+  const client = (repository as any).getClient() as QueryClient;
+  const queryKey = params
+    ? repository.keys.list(params as Record<string, unknown>)
+    : repository.keys.lists();
+  const cacheOptions = (repository as any).getCacheOptions();
+
+  return client.fetchQuery({
+    queryKey: queryKey as QueryKey,
+    queryFn: () => repository.fetchAll(params),
+    ...cacheOptions,
+  });
+}
+
+/**
+ * Query item by ID with caching
+ *
+ * @param repository - Repository instance
+ * @param id - Item ID
+ * @returns Promise of data or undefined if not found
+ */
+export async function queryById<TData>(
+  repository: BaseRepository<TData, unknown, unknown>,
+  id: string | number
+): Promise<TData | undefined> {
+  const client = (repository as any).getClient() as QueryClient;
+  const queryKey = repository.keys.detail(id);
+  const cacheOptions = (repository as any).getCacheOptions();
+
+  try {
+    return client.fetchQuery({
+      queryKey: queryKey as QueryKey,
+      queryFn: () => repository.fetchById(id),
+      ...cacheOptions,
+    });
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Prefetch all items
+ *
+ * @param repository - Repository instance
+ * @param params - Optional list parameters
+ */
+export async function prefetchAll<TData>(
+  repository: BaseRepository<TData, unknown, unknown>,
+  params?: ListParams
+): Promise<void> {
+  const client = (repository as any).getClient() as QueryClient;
+  const queryKey = params
+    ? repository.keys.list(params as Record<string, unknown>)
+    : repository.keys.lists();
+  const cacheOptions = (repository as any).getCacheOptions();
+
+  await client.prefetchQuery({
+    queryKey: queryKey as QueryKey,
+    queryFn: () => repository.fetchAll(params),
+    ...cacheOptions,
+  });
+}
+
+/**
+ * Prefetch item by ID
+ *
+ * @param repository - Repository instance
+ * @param id - Item ID
+ */
+export async function prefetchById<TData>(
+  repository: BaseRepository<TData, unknown, unknown>,
+  id: string | number
+): Promise<void> {
+  const client = (repository as any).getClient() as QueryClient;
+  const queryKey = repository.keys.detail(id);
+  const cacheOptions = (repository as any).getCacheOptions();
+
+  await client.prefetchQuery({
+    queryKey: queryKey as QueryKey,
+    queryFn: () => repository.fetchById(id),
+    ...cacheOptions,
+  });
+}