@umituz/react-native-design-system 4.23.67 → 4.23.69

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/storage/cache/domain/ErrorHandler.ts

@@ -6,6 +6,7 @@ export class CacheError extends Error {
   constructor(message: string, public readonly code: string) {
     super(message);
     this.name = 'CacheError';
+    Object.setPrototypeOf(this, CacheError.prototype);
   }
 }
 

package/src/storage/domain/errors/StorageError.ts

@@ -12,6 +12,7 @@ export class StorageError extends Error {
   constructor(message: string, public readonly key?: string) {
     super(message);
     this.name = 'StorageError';
+    Object.setPrototypeOf(this, StorageError.prototype);
   }
 }
 
@@ -25,6 +26,7 @@ export class StorageReadError extends StorageError {
     super(`Failed to read from storage: ${key}`, key);
     this.name = 'StorageReadError';
     this.cause = cause;
+    Object.setPrototypeOf(this, StorageReadError.prototype);
   }
 }
 
@@ -38,6 +40,7 @@ export class StorageWriteError extends StorageError {
     super(`Failed to write to storage: ${key}`, key);
     this.name = 'StorageWriteError';
     this.cause = cause;
+    Object.setPrototypeOf(this, StorageWriteError.prototype);
   }
 }
 
@@ -51,6 +54,7 @@ export class StorageDeleteError extends StorageError {
     super(`Failed to delete from storage: ${key}`, key);
     this.name = 'StorageDeleteError';
     this.cause = cause;
+    Object.setPrototypeOf(this, StorageDeleteError.prototype);
   }
 }
 
@@ -64,6 +68,7 @@ export class StorageSerializationError extends StorageError {
     super(`Failed to serialize data for key: ${key}`, key);
     this.name = 'StorageSerializationError';
     this.cause = cause;
+    Object.setPrototypeOf(this, StorageSerializationError.prototype);
   }
 }
 
@@ -77,5 +82,6 @@ export class StorageDeserializationError extends StorageError {
     super(`Failed to deserialize data for key: ${key}`, key);
     this.name = 'StorageDeserializationError';
     this.cause = cause;
+    Object.setPrototypeOf(this, StorageDeserializationError.prototype);
   }
 }

package/src/storage/infrastructure/repositories/AsyncStorageRepository.ts

@@ -16,63 +16,76 @@ import { BatchStorageOperations } from './BatchStorageOperations';
  * Uses composition to follow Single Responsibility Principle
  */
 export class AsyncStorageRepository implements IStorageRepository {
-  private baseOps: BaseStorageOperations;
-  private stringOps: StringStorageOperations;
-  private batchOps: BatchStorageOperations;
+  private baseOps: BaseStorageOperations | null = null;
+  private stringOps: StringStorageOperations | null = null;
+  private batchOps: BatchStorageOperations | null = null;
 
   constructor() {
-    this.baseOps = new BaseStorageOperations();
-    this.stringOps = new StringStorageOperations();
-    this.batchOps = new BatchStorageOperations();
+    // Lazy initialization - defer object creation
+  }
+
+  private ensureInitialized() {
+    if (!this.baseOps) {
+      this.baseOps = new BaseStorageOperations();
+      this.stringOps = new StringStorageOperations();
+      this.batchOps = new BatchStorageOperations();
+    }
   }
 
   /**
    * Get item from AsyncStorage with type safety
    */
   async getItem<T>(key: string, defaultValue: T): Promise<StorageResult<T>> {
-    return this.baseOps.getItem(key, defaultValue);
+    this.ensureInitialized();
+    return this.baseOps!.getItem(key, defaultValue);
   }
 
   /**
    * Set item in AsyncStorage with automatic JSON serialization
    */
   async setItem<T>(key: string, value: T): Promise<StorageResult<T>> {
-    return this.baseOps.setItem(key, value);
+    this.ensureInitialized();
+    return this.baseOps!.setItem(key, value);
   }
 
   /**
    * Get string value (no JSON parsing)
    */
   async getString(key: string, defaultValue: string): Promise<StorageResult<string>> {
-    return this.stringOps.getString(key, defaultValue);
+    this.ensureInitialized();
+    return this.stringOps!.getString(key, defaultValue);
   }
 
   /**
    * Set string value (no JSON serialization)
    */
   async setString(key: string, value: string): Promise<StorageResult<string>> {
-    return this.stringOps.setString(key, value);
+    this.ensureInitialized();
+    return this.stringOps!.setString(key, value);
   }
 
   /**
    * Remove item from AsyncStorage
    */
   async removeItem(key: string): Promise<StorageResult<void>> {
-    return this.baseOps.removeItem(key);
+    this.ensureInitialized();
+    return this.baseOps!.removeItem(key);
   }
 
   /**
    * Check if key exists in storage
    */
   async hasItem(key: string): Promise<boolean> {
-    return this.baseOps.hasItem(key);
+    this.ensureInitialized();
+    return this.baseOps!.hasItem(key);
   }
 
   /**
    * Clear all AsyncStorage data
    */
   async clearAll(): Promise<StorageResult<void>> {
-    return this.baseOps.clearAll();
+    this.ensureInitialized();
+    return this.baseOps!.clearAll();
   }
 
   /**
@@ -81,18 +94,20 @@ export class AsyncStorageRepository implements IStorageRepository {
   async getMultiple(
     keys: string[]
   ): Promise<StorageResult<Record<string, string | null>>> {
-    return this.batchOps.getMultiple(keys);
+    this.ensureInitialized();
+    return this.batchOps!.getMultiple(keys);
   }
 
   /**
    * Get all keys from storage
    */
   async getAllKeys(): Promise<StorageResult<string[]>> {
-    return this.batchOps.getAllKeys();
+    this.ensureInitialized();
+    return this.batchOps!.getAllKeys();
   }
 }
 
 /**
- * Singleton instance
+ * Singleton instance - lazy initialization
  */
 export const storageRepository = new AsyncStorageRepository();

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/IBaseRepository.ts

@@ -0,0 +1,34 @@
+/**
+ * Base Repository Interface
+ * Defines the contract for repository implementations
+ */
+
+import type { QueryClient } from '@tanstack/react-query';
+import type { QueryKeyFactory } from '../utils/QueryKeyFactory';
+import type {
+  CreateParams,
+  UpdateParams,
+  ListParams,
+  RepositoryOptions,
+} from './RepositoryTypes';
+
+export interface IBaseRepository<TData, TCreateVariables, TUpdateVariables> {
+  /** Query client instance */
+  getClient(): QueryClient;
+
+  /** Resource name */
+  readonly resource: string;
+
+  /** Query key factory */
+  readonly keys: QueryKeyFactory;
+
+  /** Cache options */
+  getCacheOptions(): RepositoryOptions;
+
+  /** Abstract methods to be implemented by subclasses */
+  fetchAll(params?: ListParams): Promise<TData[]>;
+  fetchById(id: string | number): Promise<TData>;
+  create(data: CreateParams<TCreateVariables>): Promise<TData>;
+  update(id: string | number, data: UpdateParams<TUpdateVariables>): Promise<TData>;
+  remove(id: string | number): Promise<void>;
+}

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 { IBaseRepository } from '../IBaseRepository';
+import { matchesResource } from '../helpers/repositoryHelpers';
+
+/**
+ * Invalidate all queries for this resource
+ *
+ * @param repository - Repository instance
+ */
+export function invalidateAll<TData>(
+  repository: IBaseRepository<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: IBaseRepository<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: IBaseRepository<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);
+}