@umituz/react-native-ai-generation-content 1.61.56 → 1.61.58

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.61.56",
+  "version": "1.61.58",
   "description": "Provider-agnostic AI generation orchestration for React Native with result preview components",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/domains/content-moderation/infrastructure/constants/moderation.constants.ts

@@ -3,7 +3,9 @@
  * Shared constants for content moderation validators
  */
 
+import { env } from "../../../../infrastructure/config/env.config";
+
 export const DEFAULT_PROTOCOLS = ["http:", "https:", "file:", "data:"] as const;
 export const VIDEO_PROTOCOLS = ["http:", "https:", "file:"] as const;
-export const DEFAULT_MAX_URI_LENGTH = 2048;
-export const DEFAULT_MAX_TEXT_LENGTH = 5000;
+export const DEFAULT_MAX_URI_LENGTH = env.moderationMaxUriLength;
+export const DEFAULT_MAX_TEXT_LENGTH = env.moderationMaxTextLength;

package/src/domains/content-moderation/infrastructure/services/moderators/voice.moderator.ts

@@ -7,11 +7,10 @@ import type { Violation } from "../../../domain/entities/moderation.types";
 import { patternMatcherService } from "../pattern-matcher.service";
 import { rulesRegistry } from "../../rules/rules-registry";
 import { BaseModerator, type ModerationResult } from "./base.moderator";
-
-const DEFAULT_MAX_LENGTH = 5000;
+import { env } from "../../../../../infrastructure/config/env.config";
 
 class VoiceModerator extends BaseModerator {
-  private maxLength = DEFAULT_MAX_LENGTH;
+  private maxLength = env.moderationVoiceMaxLength;
 
   setMaxLength(length: number): void {
     this.maxLength = length;

package/src/domains/content-moderation/infrastructure/services/pattern-matcher.service.ts

@@ -3,6 +3,8 @@
  * Utility service for regex pattern matching with security validations
  */
 
+import { env } from "../../../../infrastructure/config/env.config";
+
 export interface PatternMatch {
   pattern: string;
   matched: boolean;
@@ -34,8 +36,7 @@ function isValidRegexPattern(pattern: string): boolean {
   }
 
   // Limit pattern length to prevent potential attacks
-  const MAX_PATTERN_LENGTH = 1000;
-  if (pattern.length > MAX_PATTERN_LENGTH) {
+  if (pattern.length > env.validationMaxPatternLength) {
     return false;
   }
 

package/src/domains/generation/infrastructure/executors/image-executor.ts

@@ -11,6 +11,7 @@ import type {
 } from "../../domain/generation.types";
 import type { GenerationResult } from "../../../../domain/entities/generation.types";
 import { providerRegistry } from "../../../../infrastructure/services/provider-registry.service";
+import { env } from "../../../../infrastructure/config/env.config";
 
 declare const __DEV__: boolean;
 
@@ -56,7 +57,7 @@ export class ImageExecutor
       options?.onProgress?.(10);
 
       const result = await provider.subscribe(model, modelInput, {
-        timeoutMs: options?.timeoutMs ?? 300000,
+        timeoutMs: options?.timeoutMs ?? env.generationImageTimeoutMs,
         onQueueUpdate: (status) => {
           if (typeof __DEV__ !== "undefined" && __DEV__) {
             console.log("[ImageExecutor] Queue status:", status.status);

package/src/domains/generation/infrastructure/executors/video-executor.ts

@@ -11,6 +11,7 @@ import type {
 } from "../../domain/generation.types";
 import type { GenerationResult } from "../../../../domain/entities/generation.types";
 import { providerRegistry } from "../../../../infrastructure/services/provider-registry.service";
+import { env } from "../../../../infrastructure/config/env.config";
 
 declare const __DEV__: boolean;
 
@@ -48,7 +49,7 @@ export class VideoExecutor
       }
 
       const result = await provider.subscribe(model, modelInput, {
-        timeoutMs: options?.timeoutMs ?? 300000,
+        timeoutMs: options?.timeoutMs ?? env.generationVideoTimeoutMs,
         onQueueUpdate: (status) => {
           if (typeof __DEV__ !== "undefined" && __DEV__) {
             console.log("[VideoExecutor] Queue status:", status.status);

package/src/domains/generation/wizard/infrastructure/strategies/wizard-strategy.constants.ts

@@ -4,9 +4,10 @@
  */
 
 import type { VideoFeatureType } from "../../../../../domain/interfaces";
+import { env } from "../../../../../infrastructure/config/env.config";
 
-/** Generation timeout in milliseconds (2 minutes) */
-export const GENERATION_TIMEOUT_MS = 120000;
+/** Generation timeout in milliseconds */
+export const GENERATION_TIMEOUT_MS = env.generationImageTimeoutMs;
 
 /** Base64 image format prefix */
 export const BASE64_IMAGE_PREFIX = "data:image/jpeg;base64,";

package/src/domains/generation/wizard/presentation/hooks/useVideoQueueGeneration.ts

@@ -41,6 +41,7 @@ export function useVideoQueueGeneration(
   const modelRef = useRef<string | null>(null);
   const pollingRef = useRef<ReturnType<typeof setInterval> | null>(null);
   const isGeneratingRef = useRef(false);
+  const isPollingRef = useRef(false);
   const [isGenerating, setIsGenerating] = useState(false);
 
   // Cleanup polling on unmount
@@ -58,6 +59,7 @@ export function useVideoQueueGeneration(
     requestIdRef.current = null;
     modelRef.current = null;
     isGeneratingRef.current = false;
+    isPollingRef.current = false;
     setIsGenerating(false);
   }, []);
 
@@ -98,11 +100,15 @@ export function useVideoQueueGeneration(
   );
 
   const pollQueueStatus = useCallback(async () => {
+    // Guard against concurrent polls
+    if (isPollingRef.current) return;
+
     const requestId = requestIdRef.current;
     const model = modelRef.current;
     const provider = providerRegistry.getActiveProvider();
     if (!requestId || !model || !provider) return;
 
+    isPollingRef.current = true;
     try {
       const status = await provider.getJobStatus(model, requestId);
       if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[VideoQueueGeneration] Poll:", status.status);
@@ -133,6 +139,8 @@ export function useVideoQueueGeneration(
         console.error("[VideoQueueGeneration] Poll error:", errorMessage);
       }
       await handleError(errorMessage);
+    } finally {
+      isPollingRef.current = false;
     }
   }, [handleComplete, handleError]);
 
@@ -179,6 +187,7 @@ export function useVideoQueueGeneration(
       }
 
       pollingRef.current = setInterval(() => void pollQueueStatus(), DEFAULT_POLL_INTERVAL_MS);
+      // Immediate poll to avoid waiting for first interval tick
       void pollQueueStatus();
     },
     [userId, scenario, persistence, strategy, pollQueueStatus, onError],

package/src/domains/generation/wizard/presentation/hooks/useWizardFlowHandlers.ts

@@ -11,6 +11,23 @@ import type { Creation } from "../../../../creations/domain/entities/Creation";
 
 declare const __DEV__: boolean;
 
+/**
+ * Type guard to check if result is a valid Creation object
+ */
+function isCreation(result: unknown): result is Creation {
+  if (!result || typeof result !== "object") {
+    return false;
+  }
+  const creation = result as Partial<Creation>;
+  return (
+    typeof creation.id === "string" &&
+    typeof creation.uri === "string" &&
+    typeof creation.type === "string" &&
+    creation.createdAt instanceof Date &&
+    typeof creation.isShared === "boolean"
+  );
+}
+
 export interface UseWizardFlowHandlersProps {
   readonly currentStepIndex: number;
   readonly flowSteps: StepDefinition[];
@@ -64,7 +81,17 @@ export function useWizardFlowHandlers(props: UseWizardFlowHandlersProps) {
         console.log("[WizardFlowHandlers] Generation completed");
       }
       setResult(result);
-      setCurrentCreation(result as Creation);
+
+      // Use type guard to safely check if result is a Creation
+      if (isCreation(result)) {
+        setCurrentCreation(result);
+      } else {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.warn("[WizardFlowHandlers] Result is not a valid Creation object:", result);
+        }
+        setCurrentCreation(null);
+      }
+
       onGenerationComplete?.(result);
       if (!skipResultStep) nextStep();
     },

package/src/domains/generation/wizard/presentation/hooks/useWizardGeneration.ts

@@ -8,7 +8,7 @@
  * States: IDLE → PREPARING → GENERATING → COMPLETED/ERROR → IDLE
  */
 
-import { useEffect, useReducer, useMemo } from "react";
+import { useEffect, useReducer, useMemo, useRef } from "react";
 import { createWizardStrategy, buildWizardInput } from "../../infrastructure/strategies";
 import { createCreationPersistence } from "../../infrastructure/utils/creation-persistence.util";
 import { useVideoQueueGeneration } from "./useVideoQueueGeneration";
@@ -96,6 +96,16 @@ export const useWizardGeneration = (
   // State machine: replaces multiple useRef flags
   const [state, dispatch] = useReducer(generationReducer, { status: "IDLE" });
 
+  // Mounted ref to prevent state updates after unmount
+  const isMountedRef = useRef(true);
+
+  useEffect(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+    };
+  }, []);
+
   const persistence = useMemo(() => createCreationPersistence(), []);
   const strategy = useMemo(
     () => createWizardStrategy({ scenario, creditCost }),
@@ -140,6 +150,9 @@ export const useWizardGeneration = (
 
       buildWizardInput(wizardData, scenario)
         .then(async (input) => {
+          // Check if component is still mounted
+          if (!isMountedRef.current) return;
+
           if (!input) {
             dispatch({ type: "ERROR", error: "Failed to build generation input" });
             onError?.("Failed to build generation input");
@@ -161,9 +174,15 @@ export const useWizardGeneration = (
             await photoGeneration.startGeneration(input, typedInput.prompt || "");
           }
 
-          dispatch({ type: "COMPLETE" });
+          // Check again before final state update
+          if (isMountedRef.current) {
+            dispatch({ type: "COMPLETE" });
+          }
         })
         .catch((error) => {
+          // Check if component is still mounted before error handling
+          if (!isMountedRef.current) return;
+
           const errorMsg = error?.message || "error.generation.unknown";
           if (typeof __DEV__ !== "undefined" && __DEV__) {
             console.error("[WizardGeneration] Build input error:", errorMsg, error);

package/src/features/image-to-video/infrastructure/services/image-to-video-executor.ts

@@ -17,6 +17,7 @@ import type {
   ImageToVideoInputBuilder,
   ImageToVideoResultExtractor,
 } from "../../domain/types";
+import { env } from "../../../../infrastructure/config/env.config";
 
 /**
  * Options for image-to-video execution
@@ -89,7 +90,7 @@ class ImageToVideoExecutor extends BaseExecutor<
         const progress = getProgressFromJobStatus(status.status);
         onProgress?.(progress);
       },
-      timeoutMs: 300000, // 5 minutes timeout for video generation
+      timeoutMs: env.generationVideoTimeoutMs,
     });
 
     this.logInfo(

package/src/infrastructure/config/env.config.ts

@@ -0,0 +1,67 @@
+/**
+ * Environment Configuration
+ * Centralized environment variable access with fallback defaults
+ */
+
+type EnvValue = string | number | boolean;
+
+function getEnvValue(key: string, defaultValue: EnvValue): EnvValue {
+  if (typeof process !== "undefined" && process.env) {
+    const value = process.env[key];
+    if (value !== undefined && value !== "") {
+      if (typeof defaultValue === "number") {
+        const parsed = Number(value);
+        return isNaN(parsed) ? defaultValue : parsed;
+      }
+      if (typeof defaultValue === "boolean") {
+        return value === "true" || value === "1";
+      }
+      return value;
+    }
+  }
+  return defaultValue;
+}
+
+export const env = {
+  // API Configuration
+  apiDefaultTimeoutMs: getEnvValue("API_DEFAULT_TIMEOUT_MS", 30000) as number,
+  apiRetryDelayMs: getEnvValue("API_RETRY_DELAY_MS", 1000) as number,
+
+  // Generation Timeouts
+  generationImageTimeoutMs: getEnvValue("GENERATION_IMAGE_TIMEOUT_MS", 120000) as number,
+  generationVideoTimeoutMs: getEnvValue("GENERATION_VIDEO_TIMEOUT_MS", 300000) as number,
+  generationMultiImageTimeoutMs: getEnvValue("GENERATION_MULTI_IMAGE_TIMEOUT_MS", 120000) as number,
+
+  // Polling Configuration
+  pollDefaultIntervalMs: getEnvValue("POLL_DEFAULT_INTERVAL_MS", 3000) as number,
+  pollGalleryIntervalMs: getEnvValue("POLL_GALLERY_INTERVAL_MS", 5000) as number,
+  pollMaxTimeMs: getEnvValue("POLL_MAX_TIME_MS", 300000) as number,
+  pollMaxAttempts: getEnvValue("POLL_MAX_ATTEMPTS", 100) as number,
+  pollMaxConsecutiveErrors: getEnvValue("POLL_MAX_CONSECUTIVE_ERRORS", 5) as number,
+  pollMinBackoffDelayMs: getEnvValue("POLL_MIN_BACKOFF_DELAY_MS", 1000) as number,
+  pollMaxBackoffDelayMs: getEnvValue("POLL_MAX_BACKOFF_DELAY_MS", 30000) as number,
+  pollBackoffMultiplier: getEnvValue("POLL_BACKOFF_MULTIPLIER", 1.5) as number,
+
+  // Validation Limits
+  validationMaxPromptLength: getEnvValue("VALIDATION_MAX_PROMPT_LENGTH", 10000) as number,
+  validationMinPromptLength: getEnvValue("VALIDATION_MIN_PROMPT_LENGTH", 1) as number,
+  validationMaxUserIdLength: getEnvValue("VALIDATION_MAX_USER_ID_LENGTH", 128) as number,
+  validationMaxCreationIdLength: getEnvValue("VALIDATION_MAX_CREATION_ID_LENGTH", 128) as number,
+  validationMaxUrlLength: getEnvValue("VALIDATION_MAX_URL_LENGTH", 2048) as number,
+  validationMaxBase64SizeMb: getEnvValue("VALIDATION_MAX_BASE64_SIZE_MB", 20) as number,
+  validationMaxPatternLength: getEnvValue("VALIDATION_MAX_PATTERN_LENGTH", 1000) as number,
+  validationMaxImageSizeMb: getEnvValue("VALIDATION_MAX_IMAGE_SIZE_MB", 10) as number,
+  validationMaxVideoDurationSeconds: getEnvValue("VALIDATION_MAX_VIDEO_DURATION_SECONDS", 60) as number,
+  validationMinVideoDurationSeconds: getEnvValue("VALIDATION_MIN_VIDEO_DURATION_SECONDS", 3) as number,
+  validationMaxMultiImageCount: getEnvValue("VALIDATION_MAX_MULTI_IMAGE_COUNT", 10) as number,
+  validationMinMultiImageCount: getEnvValue("VALIDATION_MIN_MULTI_IMAGE_COUNT", 2) as number,
+
+  // Content Moderation
+  moderationMaxTextLength: getEnvValue("MODERATION_MAX_TEXT_LENGTH", 5000) as number,
+  moderationMaxUriLength: getEnvValue("MODERATION_MAX_URI_LENGTH", 2048) as number,
+  moderationVoiceMaxLength: getEnvValue("MODERATION_VOICE_MAX_LENGTH", 5000) as number,
+
+  // Storage Configuration
+  storageDbOperationTimeoutMs: getEnvValue("STORAGE_DB_OPERATION_TIMEOUT_MS", 10000) as number,
+  storageMaxCacheSize: getEnvValue("STORAGE_MAX_CACHE_SIZE", 100) as number,
+} as const;

package/src/infrastructure/config/index.ts

@@ -14,3 +14,5 @@ export {
   getAuthService,
   getAnalyticsService,
 } from "./app-services.config";
+
+export { env } from "./env.config";

package/src/infrastructure/constants/content.constants.ts

@@ -2,5 +2,7 @@
  * Content Related Constants
  */
 
+import { env } from "../config/env.config";
+
 /** Default maximum length for text content */
-export const DEFAULT_MAX_TEXT_LENGTH = 10000;
+export const DEFAULT_MAX_TEXT_LENGTH = env.moderationMaxTextLength;

package/src/infrastructure/constants/polling.constants.ts

@@ -3,29 +3,31 @@
  * All timeout, interval, and retry related constants
  */
 
+import { env } from "../config/env.config";
+
 /** Default polling interval for job status checks (milliseconds) */
-export const DEFAULT_POLL_INTERVAL_MS = 3000;
+export const DEFAULT_POLL_INTERVAL_MS = env.pollDefaultIntervalMs;
 
 /** Gallery polling interval (slower than wizard) */
-export const GALLERY_POLL_INTERVAL_MS = 5000;
+export const GALLERY_POLL_INTERVAL_MS = env.pollGalleryIntervalMs;
 
 /** Maximum number of polling attempts before timeout */
-export const DEFAULT_MAX_POLL_ATTEMPTS = 100;
+export const DEFAULT_MAX_POLL_ATTEMPTS = env.pollMaxAttempts;
 
 /** Maximum consecutive transient errors before aborting */
-export const DEFAULT_MAX_CONSECUTIVE_ERRORS = 5;
+export const DEFAULT_MAX_CONSECUTIVE_ERRORS = env.pollMaxConsecutiveErrors;
 
-/** Maximum total time for polling (milliseconds) - ~5 minutes */
-export const DEFAULT_MAX_POLL_TIME_MS = 5 * 60 * 1000;
+/** Maximum total time for polling (milliseconds) */
+export const DEFAULT_MAX_POLL_TIME_MS = env.pollMaxTimeMs;
 
 /** Minimum backoff delay (milliseconds) */
-export const MIN_BACKOFF_DELAY_MS = 1000;
+export const MIN_BACKOFF_DELAY_MS = env.pollMinBackoffDelayMs;
 
 /** Maximum backoff delay (milliseconds) */
-export const MAX_BACKOFF_DELAY_MS = 30000;
+export const MAX_BACKOFF_DELAY_MS = env.pollMaxBackoffDelayMs;
 
 /** Exponential backoff base multiplier */
-export const BACKOFF_MULTIPLIER = 1.5;
+export const BACKOFF_MULTIPLIER = env.pollBackoffMultiplier;
 
 /** Progress percentage to report when job completes */
 export const COMPLETION_PROGRESS = 100;

package/src/infrastructure/constants/storage.constants.ts

@@ -3,6 +3,8 @@
  * Database and storage related constants
  */
 
+import { env } from "../config/env.config";
+
 /** Maximum number of creations to fetch in one query */
 export const MAX_CREATIONS_FETCH_LIMIT = 100;
 
@@ -13,10 +15,10 @@ export const DEFAULT_CREATIONS_PAGE_SIZE = 20;
 export const MAX_LOG_ENTRIES = 1000;
 
 /** Timeout for database operations (milliseconds) */
-export const DB_OPERATION_TIMEOUT_MS = 10000;
+export const DB_OPERATION_TIMEOUT_MS = env.storageDbOperationTimeoutMs;
 
 /** Maximum cache size for frequently accessed data */
-export const MAX_CACHE_SIZE = 100;
+export const MAX_CACHE_SIZE = env.storageMaxCacheSize;
 
 /** Cache TTL for creations (milliseconds) - 5 minutes */
 export const CREATIONS_CACHE_TTL_MS = 5 * 60 * 1000;

package/src/infrastructure/constants/validation.constants.ts

@@ -3,38 +3,40 @@
  * All validation limits and constraints
  */
 
+import { env } from "../config/env.config";
+
 /** Maximum length for AI prompt text */
-export const MAX_PROMPT_LENGTH = 10000;
+export const MAX_PROMPT_LENGTH = env.validationMaxPromptLength;
 
 /** Minimum length for AI prompt text */
-export const MIN_PROMPT_LENGTH = 1;
+export const MIN_PROMPT_LENGTH = env.validationMinPromptLength;
 
 /** Maximum length for user ID */
-export const MAX_USER_ID_LENGTH = 128;
+export const MAX_USER_ID_LENGTH = env.validationMaxUserIdLength;
 
 /** Maximum length for creation ID */
-export const MAX_CREATION_ID_LENGTH = 128;
+export const MAX_CREATION_ID_LENGTH = env.validationMaxCreationIdLength;
 
 /** Maximum base64 string length (before encoding) */
-export const MAX_BASE64_SIZE_MB = 20;
+export const MAX_BASE64_SIZE_MB = env.validationMaxBase64SizeMb;
 
 /** Maximum regex pattern length for validation */
-export const MAX_PATTERN_LENGTH = 1000;
+export const MAX_PATTERN_LENGTH = env.validationMaxPatternLength;
 
 /** Maximum duration for video generation (seconds) */
-export const MAX_VIDEO_DURATION_SECONDS = 60;
+export const MAX_VIDEO_DURATION_SECONDS = env.validationMaxVideoDurationSeconds;
 
 /** Minimum duration for video generation (seconds) */
-export const MIN_VIDEO_DURATION_SECONDS = 3;
+export const MIN_VIDEO_DURATION_SECONDS = env.validationMinVideoDurationSeconds;
 
 /** Maximum image file size (MB) */
-export const MAX_IMAGE_SIZE_MB = 10;
+export const MAX_IMAGE_SIZE_MB = env.validationMaxImageSizeMb;
 
 /** Maximum URL length */
-export const MAX_URL_LENGTH = 2048;
+export const MAX_URL_LENGTH = env.validationMaxUrlLength;
 
 /** Maximum number of images in multi-image generation */
-export const MAX_MULTI_IMAGE_COUNT = 10;
+export const MAX_MULTI_IMAGE_COUNT = env.validationMaxMultiImageCount;
 
 /** Minimum number of images for multi-image generation */
-export const MIN_MULTI_IMAGE_COUNT = 2;
+export const MIN_MULTI_IMAGE_COUNT = env.validationMinMultiImageCount;

package/src/infrastructure/http/api-client.types.ts

@@ -0,0 +1,17 @@
+/**
+ * API Client Types
+ * Type definitions for HTTP client utilities
+ */
+
+export interface RequestOptions extends RequestInit {
+  timeout?: number;
+  retries?: number;
+  headers?: Record<string, string>;
+}
+
+export interface ApiResponse<T> {
+  data: T | null;
+  error: string | null;
+  status: number;
+  headers: Headers;
+}

package/src/infrastructure/http/http-client.util.ts

@@ -0,0 +1,167 @@
+/**
+ * HTTP Client Utilities
+ * Core HTTP request handling with error handling and retry logic
+ */
+
+import { withErrorHandling, getErrorMessage, retryWithBackoff, isNetworkError } from "../utils/error-handling.util";
+import { env } from "../config/env.config";
+import type { RequestOptions, ApiResponse } from "./api-client.types";
+import { createTimeoutController } from "./timeout.util";
+
+/**
+ * Makes an HTTP request with error handling and retry logic
+ * @param url - Request URL
+ * @param options - Request options
+ * @returns API response with data or error
+ */
+export async function fetchWithTimeout<T>(
+  url: string,
+  options: RequestOptions = {}
+): Promise<ApiResponse<T>> {
+  const {
+    timeout = env.apiDefaultTimeoutMs,
+    retries = 0,
+    headers = {},
+    ...fetchOptions
+  } = options;
+
+  const controller = createTimeoutController(timeout);
+
+  const operation = async (): Promise<T> => {
+    const response = await fetch(url, {
+      ...fetchOptions,
+      headers: {
+        "Content-Type": "application/json",
+        ...headers,
+      },
+      signal: controller?.signal,
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "Unknown error");
+      throw new Error(`HTTP ${response.status}: ${errorText}`);
+    }
+
+    const contentType = response.headers.get("content-type");
+    if (contentType?.includes("application/json")) {
+      return response.json();
+    }
+
+    return response.text() as T;
+  };
+
+  const result = await withErrorHandling(
+    async () => {
+      if (retries > 0) {
+        return retryWithBackoff(operation, {
+          maxRetries: retries,
+          delayMs: env.apiRetryDelayMs,
+          shouldRetry: (error) => isNetworkError(error),
+        });
+      }
+      return operation();
+    },
+    (error) => {
+      console.error("[API Client] Request failed:", error);
+    }
+  );
+
+  if (result.error) {
+    return {
+      data: null,
+      error: getErrorMessage(result.error),
+      status: 0,
+      headers: new Headers(),
+    };
+  }
+
+  return {
+    data: result.data ?? null,
+    error: null,
+    status: 200,
+    headers: new Headers(),
+  };
+}
+
+/**
+ * Makes a GET request
+ * @param url - Request URL
+ * @param options - Request options
+ * @returns API response
+ */
+export async function get<T>(
+  url: string,
+  options: Omit<RequestOptions, "method" | "body"> = {}
+): Promise<ApiResponse<T>> {
+  return fetchWithTimeout<T>(url, { ...options, method: "GET" });
+}
+
+/**
+ * Makes a POST request
+ * @param url - Request URL
+ * @param data - Request body data
+ * @param options - Request options
+ * @returns API response
+ */
+export async function post<T>(
+  url: string,
+  data: unknown,
+  options: Omit<RequestOptions, "method"> = {}
+): Promise<ApiResponse<T>> {
+  return fetchWithTimeout<T>(url, {
+    ...options,
+    method: "POST",
+    body: JSON.stringify(data),
+  });
+}
+
+/**
+ * Makes a PUT request
+ * @param url - Request URL
+ * @param data - Request body data
+ * @param options - Request options
+ * @returns API response
+ */
+export async function put<T>(
+  url: string,
+  data: unknown,
+  options: Omit<RequestOptions, "method"> = {}
+): Promise<ApiResponse<T>> {
+  return fetchWithTimeout<T>(url, {
+    ...options,
+    method: "PUT",
+    body: JSON.stringify(data),
+  });
+}
+
+/**
+ * Makes a DELETE request
+ * @param url - Request URL
+ * @param options - Request options
+ * @returns API response
+ */
+export async function del<T>(
+  url: string,
+  options: Omit<RequestOptions, "method" | "body"> = {}
+): Promise<ApiResponse<T>> {
+  return fetchWithTimeout<T>(url, { ...options, method: "DELETE" });
+}
+
+/**
+ * Makes a PATCH request
+ * @param url - Request URL
+ * @param data - Request body data
+ * @param options - Request options
+ * @returns API response
+ */
+export async function patch<T>(
+  url: string,
+  data: unknown,
+  options: Omit<RequestOptions, "method"> = {}
+): Promise<ApiResponse<T>> {
+  return fetchWithTimeout<T>(url, {
+    ...options,
+    method: "PATCH",
+    body: JSON.stringify(data),
+  });
+}

package/src/infrastructure/http/index.ts

@@ -0,0 +1,16 @@
+/**
+ * HTTP Client Module
+ * Exports all HTTP client utilities
+ */
+
+export type { RequestOptions, ApiResponse } from "./api-client.types";
+export {
+  get,
+  post,
+  put,
+  del,
+  patch,
+  fetchWithTimeout,
+} from "./http-client.util";
+export { buildQueryString, appendQueryParams } from "./query-string.util";
+export { createTimeoutController } from "./timeout.util";