@umituz/react-native-ai-generation-content 1.83.9 → 1.83.11

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

@@ -1,27 +0,0 @@
-/**
- * Storage Constants
- * 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;
-
-/** Default number of creations per page */
-export const DEFAULT_CREATIONS_PAGE_SIZE = 20;
-
-/** Maximum number of logs to keep in memory */
-export const MAX_LOG_ENTRIES = 1000;
-
-/** Timeout for database operations (milliseconds) */
-export const DB_OPERATION_TIMEOUT_MS = env.storageDbOperationTimeoutMs;
-
-/** Maximum cache size for frequently accessed data */
-export const MAX_CACHE_SIZE = env.storageMaxCacheSize;
-
-/** Cache TTL for creations (milliseconds) - 5 minutes */
-export const CREATIONS_CACHE_TTL_MS = 5 * 60 * 1000;
-
-/** Cache TTL for user data (milliseconds) - 10 minutes */
-export const USER_DATA_CACHE_TTL_MS = 10 * 60 * 1000;

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

@@ -1,17 +0,0 @@
-/**
- * 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-methods.ts

@@ -1,73 +0,0 @@
-/**
- * HTTP Client Methods
- * Infrastructure: Public API for HTTP operations
- */
-
-import type { RequestOptions, ApiResponse } from "./api-client.types";
-import { fetchWithTimeout } from "./http-fetch-handler";
-import { HTTP_METHOD } from "./http-methods.constants";
-
-/**
- * Makes a GET request
- */
-export async function get<T>(
-  url: string,
-  options: Omit<RequestOptions, "method" | "body"> = {}
-): Promise<ApiResponse<T>> {
-  return fetchWithTimeout<T>(url, { ...options, method: HTTP_METHOD.GET });
-}
-
-/**
- * Makes a POST request
- */
-export async function post<T>(
-  url: string,
-  data: unknown,
-  options: Omit<RequestOptions, "method"> = {}
-): Promise<ApiResponse<T>> {
-  return fetchWithTimeout<T>(url, {
-    ...options,
-    method: HTTP_METHOD.POST,
-    body: JSON.stringify(data),
-  });
-}
-
-/**
- * Makes a PUT request
- */
-export async function put<T>(
-  url: string,
-  data: unknown,
-  options: Omit<RequestOptions, "method"> = {}
-): Promise<ApiResponse<T>> {
-  return fetchWithTimeout<T>(url, {
-    ...options,
-    method: HTTP_METHOD.PUT,
-    body: JSON.stringify(data),
-  });
-}
-
-/**
- * Makes a DELETE request
- */
-export async function del<T>(
-  url: string,
-  options: Omit<RequestOptions, "method" | "body"> = {}
-): Promise<ApiResponse<T>> {
-  return fetchWithTimeout<T>(url, { ...options, method: HTTP_METHOD.DELETE });
-}
-
-/**
- * Makes a PATCH request
- */
-export async function patch<T>(
-  url: string,
-  data: unknown,
-  options: Omit<RequestOptions, "method"> = {}
-): Promise<ApiResponse<T>> {
-  return fetchWithTimeout<T>(url, {
-    ...options,
-    method: HTTP_METHOD.PATCH,
-    body: JSON.stringify(data),
-  });
-}

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

@@ -1,12 +0,0 @@
-/**
- * HTTP Client Utilities - Barrel Export
- * Core HTTP request handling with error handling and retry logic
- *
- * Architecture:
- * - Domain: HTTP methods, content types (constants)
- * - Infrastructure: Request execution, response parsing, error handling
- */
-
-export { HTTP_METHOD, HTTP_CONTENT_TYPE, DEFAULT_HEADERS, type HttpMethod } from "./http-methods.constants";
-export { fetchWithTimeout } from "./http-fetch-handler";
-export { get, post, put, del, patch } from "./http-client-methods";

package/src/infrastructure/http/http-fetch-handler.ts

@@ -1,63 +0,0 @@
-/**
- * HTTP Fetch Handler
- * Infrastructure: Orchestrates request execution with error handling
- */
-
-import { withErrorHandling } from "../utils/error-handlers";
-import { getErrorMessage } from "../utils/message-extractor";
-import { retryWithBackoff } from "../utils/error-retry";
-import { isNetworkError } from "../utils/error-classifiers";
-import { env } from "../config/env.config";
-import type { RequestOptions, ApiResponse } from "./api-client.types";
-import { executeRequest, isSuccessResponse, extractErrorMessage } from "./http-request-executor";
-import { parseResponse, createSuccessResponse, createErrorResponse } from "./http-response-parser";
-
-
-/**
- * Fetches data with timeout, retry, and error handling
- */
-export async function fetchWithTimeout<T>(
-  url: string,
-  options: RequestOptions = {}
-): Promise<ApiResponse<T>> {
-  const { retries = 0 } = options;
-
-  const operation = async (): Promise<T> => {
-    const response = await executeRequest(url, options);
-
-    if (!isSuccessResponse(response)) {
-      const errorMessage = await extractErrorMessage(response);
-      throw new Error(errorMessage);
-    }
-
-    return parseResponse<T>(response);
-  };
-
-  const result = await withErrorHandling(
-    async () => {
-      if (retries > 0) {
-        return retryWithBackoff(operation, {
-          maxRetries: retries,
-          delayMs: env.apiRetryDelayMs,
-          shouldRetry: (error) => isNetworkError(error),
-        });
-      }
-      return operation();
-    },
-    (error) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.error("[API Client] Request failed:", error);
-      }
-    }
-  );
-
-  if (result.error) {
-    return createErrorResponse(getErrorMessage(result.error));
-  }
-
-  if (result.data === undefined) {
-    return createErrorResponse("No data received from server");
-  }
-
-  return createSuccessResponse(result.data);
-}

package/src/infrastructure/http/http-methods.constants.ts

@@ -1,23 +0,0 @@
-/**
- * HTTP Methods Constants
- * Domain knowledge: Standard HTTP methods
- */
-
-export const HTTP_METHOD = {
-  GET: "GET",
-  POST: "POST",
-  PUT: "PUT",
-  DELETE: "DELETE",
-  PATCH: "PATCH",
-} as const;
-
-export type HttpMethod = typeof HTTP_METHOD[keyof typeof HTTP_METHOD];
-
-export const HTTP_CONTENT_TYPE = {
-  JSON: "application/json",
-  TEXT: "text/plain",
-} as const;
-
-export const DEFAULT_HEADERS = {
-  "Content-Type": HTTP_CONTENT_TYPE.JSON,
-} as const;

package/src/infrastructure/http/http-request-executor.ts

@@ -1,49 +0,0 @@
-/**
- * HTTP Request Executor
- * Infrastructure: Handles low-level fetch operations
- */
-
-import { env } from "../config/env.config";
-import { createTimeoutController } from "./timeout.util";
-import { DEFAULT_HEADERS } from "./http-methods.constants";
-import type { RequestOptions } from "./api-client.types";
-
-/**
- * Executes HTTP request with timeout
- */
-export async function executeRequest(
-  url: string,
-  options: RequestOptions = {}
-): Promise<Response> {
-  const {
-    timeout = env.apiDefaultTimeoutMs,
-    headers = {},
-    ...fetchOptions
-  } = options;
-
-  const controller = createTimeoutController(timeout);
-
-  return fetch(url, {
-    ...fetchOptions,
-    headers: {
-      ...DEFAULT_HEADERS,
-      ...headers,
-    },
-    signal: controller?.signal,
-  });
-}
-
-/**
- * Checks if response is successful
- */
-export function isSuccessResponse(response: Response): boolean {
-  return response.ok;
-}
-
-/**
- * Extracts error message from failed response
- */
-export async function extractErrorMessage(response: Response): Promise<string> {
-  const errorText = await response.text().catch(() => "Unknown error");
-  return `HTTP ${response.status}: ${errorText}`;
-}

package/src/infrastructure/http/http-response-parser.ts

@@ -1,65 +0,0 @@
-/**
- * HTTP Response Parser
- * Infrastructure: Parses HTTP responses to typed data
- */
-
-import { HTTP_CONTENT_TYPE } from "./http-methods.constants";
-
-/**
- * Parses response based on content type
- * Note: Type T is not validated at runtime - caller must ensure type safety
- */
-export async function parseResponse<T>(response: Response): Promise<T> {
-  const contentType = response.headers.get("content-type");
-
-  if (contentType?.includes(HTTP_CONTENT_TYPE.JSON)) {
-    try {
-      return await response.json();
-    } catch (error) {
-      throw new Error(`Failed to parse JSON response: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-  }
-
-  // For non-JSON responses, return text
-  // WARNING: Type T is not validated - caller is responsible for type safety
-  try {
-    const text = await response.text();
-    return text as T;
-  } catch (error) {
-    throw new Error(`Failed to parse text response: ${error instanceof Error ? error.message : 'Unknown error'}`);
-  }
-}
-
-/**
- * Creates successful API response
- */
-export function createSuccessResponse<T>(data: T): {
-  data: T;
-  error: null;
-  status: number;
-  headers: Headers;
-} {
-  return {
-    data,
-    error: null,
-    status: 200,
-    headers: new Headers(),
-  };
-}
-
-/**
- * Creates error API response
- */
-export function createErrorResponse(errorMessage: string): {
-  data: null;
-  error: string;
-  status: number;
-  headers: Headers;
-} {
-  return {
-    data: null,
-    error: errorMessage,
-    status: 0,
-    headers: new Headers(),
-  };
-}

package/src/infrastructure/http/index.ts

@@ -1,16 +0,0 @@
-/**
- * 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";

package/src/infrastructure/http/query-string.util.ts

@@ -1,40 +0,0 @@
-/**
- * Query String Utilities
- * Helper functions for building and manipulating query strings
- */
-
-/**
- * Builds query string from object
- * @param params - Object with query parameters
- * @returns Query string (without leading ?)
- */
-export function buildQueryString(params: Record<string, unknown>): string {
-  const searchParams = new URLSearchParams();
-
-  Object.entries(params).forEach(([key, value]) => {
-    if (value !== null && value !== undefined) {
-      searchParams.append(key, String(value));
-    }
-  });
-
-  return searchParams.toString();
-}
-
-/**
- * Appends query parameters to URL
- * @param url - Base URL
- * @param params - Query parameters to append
- * @returns URL with query parameters
- */
-export function appendQueryParams(
-  url: string,
-  params: Record<string, unknown>
-): string {
-  const queryString = buildQueryString(params);
-  if (!queryString) {
-    return url;
-  }
-
-  const separator = url.includes("?") ? "&" : "?";
-  return `${url}${separator}${queryString}`;
-}

package/src/infrastructure/http/timeout.util.ts

@@ -1,26 +0,0 @@
-/**
- * Timeout Controller Utility
- * Creates AbortController instances with timeout support
- */
-
-/**
- * Creates an AbortController with timeout
- * @param timeout - Timeout in milliseconds
- * @returns AbortController instance or undefined if no timeout specified
- */
-export function createTimeoutController(
-  timeout?: number
-): AbortController | undefined {
-  if (!timeout) {
-    return undefined;
-  }
-
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), timeout);
-
-  controller.signal.addEventListener('abort', () => {
-    clearTimeout(timeoutId);
-  }, { once: true });
-
-  return controller;
-}

package/src/infrastructure/logging/debug.util.ts

@@ -1,51 +0,0 @@
-/**
- * Debug logging utility with __DEV__ guard
- * Centralized debug logging for development
- */
-
-type LogLevel = "log" | "warn" | "error" | "info";
-
-export interface DebugOptions {
-  readonly tag?: string;
-}
-
-/** Single source of truth for development environment detection */
-export const isDev = typeof __DEV__ !== "undefined" && __DEV__;
-
-function formatMessage(tag: string | undefined, message: string): string {
-  return tag ? `[${tag}] ${message}` : message;
-}
-
-function log(level: LogLevel, tag: string | undefined, message: string, ...args: readonly unknown[]): void {
-  if (!isDev) return;
-
-  const formattedMessage = formatMessage(tag, message);
-
-  switch (level) {
-    case "error":
-      console.error(formattedMessage, ...args);
-      break;
-    case "warn":
-      console.warn(formattedMessage, ...args);
-      break;
-    case "info":
-      console.info(formattedMessage, ...args);
-      break;
-    default:
-      console.log(formattedMessage, ...args);
-  }
-}
-
-export const debug = {
-  log: (message: string, options?: DebugOptions, ...args: readonly unknown[]): void =>
-    log("log", options?.tag, message, ...args),
-
-  warn: (message: string, options?: DebugOptions, ...args: readonly unknown[]): void =>
-    log("warn", options?.tag, message, ...args),
-
-  error: (message: string, options?: DebugOptions, ...args: readonly unknown[]): void =>
-    log("error", options?.tag, message, ...args),
-
-  info: (message: string, options?: DebugOptions, ...args: readonly unknown[]): void =>
-    log("info", options?.tag, message, ...args),
-};

package/src/infrastructure/logging/index.ts

@@ -1,6 +0,0 @@
-/**
- * Logging utilities
- */
-
-export { debug, isDev } from "./debug.util";
-export type { DebugOptions } from "./debug.util";

package/src/infrastructure/utils/content-validators.ts

@@ -1,92 +0,0 @@
-/**
- * Content Validation Utilities
- */
-
-import {
-  MAX_PROMPT_LENGTH,
-  MIN_PROMPT_LENGTH,
-  MAX_URL_LENGTH,
-  MIN_VIDEO_DURATION_SECONDS,
-  MAX_VIDEO_DURATION_SECONDS,
-} from "../constants/validation.constants";
-import type { ValidationResult } from "./validation-types";
-
-/**
- * Validates text prompt length
- */
-export function validatePrompt(prompt: string): ValidationResult {
-  if (!prompt || typeof prompt !== "string") {
-    return { isValid: false, error: "Prompt is required" };
-  }
-
-  if (prompt.length < MIN_PROMPT_LENGTH) {
-    return { isValid: false, error: "Prompt is too short" };
-  }
-
-  if (prompt.length > MAX_PROMPT_LENGTH) {
-    return { isValid: false, error: "Prompt is too long" };
-  }
-
-  return { isValid: true };
-}
-
-/**
- * Validates URL format
- */
-export function validateUrl(url: string): ValidationResult {
-  if (!url || typeof url !== "string") {
-    return { isValid: false, error: "URL is required" };
-  }
-
-  if (url.length > MAX_URL_LENGTH) {
-    return { isValid: false, error: "URL is too long" };
-  }
-
-  try {
-    new URL(url);
-    return { isValid: true };
-  } catch {
-    return { isValid: false, error: "Invalid URL format" };
-  }
-}
-
-/**
- * Validates video duration
- */
-export function validateVideoDuration(duration: number): ValidationResult {
-  if (typeof duration !== "number" || isNaN(duration)) {
-    return { isValid: false, error: "Duration must be a number" };
-  }
-
-  if (duration < MIN_VIDEO_DURATION_SECONDS) {
-    return {
-      isValid: false,
-      error: `Duration must be at least ${MIN_VIDEO_DURATION_SECONDS} seconds`,
-    };
-  }
-
-  if (duration > MAX_VIDEO_DURATION_SECONDS) {
-    return {
-      isValid: false,
-      error: `Duration must not exceed ${MAX_VIDEO_DURATION_SECONDS} seconds`,
-    };
-  }
-
-  return { isValid: true };
-}
-
-/**
- * Validates email format
- */
-export function validateEmail(email: string): ValidationResult {
-  if (!email || typeof email !== "string") {
-    return { isValid: false, error: "Email is required" };
-  }
-
-  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  if (!emailRegex.test(email)) {
-    return { isValid: false, error: "Invalid email format" };
-  }
-
-  return { isValid: true };
-}

package/src/infrastructure/utils/domain-guards.ts

@@ -1,23 +0,0 @@
-/**
- * Domain-Specific Type Guards
- */
-
-import { hasProperty } from "./structure-guards";
-import { isObject } from "./primitive-guards";
-import { isNonEmptyString } from "./primitive-guards";
-
-/**
- * Type guard for creation objects with output property
- */
-export function isCreationWithOutput(
-  value: unknown
-): value is { output: unknown } {
-  return hasProperty(value, "output") && isObject(value.output);
-}
-
-/**
- * Type guard for wizard data with id property
- */
-export function isWizardData(value: unknown): value is { id: string } {
-  return hasProperty(value, "id") && isNonEmptyString(value.id);
-}

package/src/infrastructure/utils/error-classifiers.ts

@@ -1,23 +0,0 @@
-/**
- * Error Classification Utilities
- */
-
-import { isError } from "./error-types";
-
-/**
- * Checks if error is a network error
- */
-export function isNetworkError(error: unknown): boolean {
-  if (!isError(error)) {
-    return false;
-  }
-
-  const message = error.message.toLowerCase();
-  return (
-    message.includes("network") ||
-    message.includes("fetch") ||
-    message.includes("connection") ||
-    message.includes("timeout")
-  );
-}
-

package/src/infrastructure/utils/error-handlers.ts

@@ -1,53 +0,0 @@
-/**
- * Error Handling Utilities
- */
-
-import { getErrorMessage } from "./message-extractor";
-
-/**
- * Sanitizes error message to prevent information disclosure
- * Removes sensitive data like file paths, API keys, stack traces
- */
-function sanitizeErrorMessage(message: string): string {
-  if (!message) return "An error occurred";
-
-  // Remove file paths (Unix and Windows style)
-  let sanitized = message.replace(/\/[\w\/\-.]+/g, "[PATH]");
-  sanitized = sanitized.replace(/[A-Z]:\\[\w\\\-.]+/g, "[PATH]");
-
-  // Remove potential API keys or tokens (common patterns)
-  sanitized = sanitized.replace(/[a-z0-9]{32,}/gi, "[TOKEN]");
-
-  // Remove stack trace lines
-  sanitized = sanitized.split("\n")[0];
-
-  // Limit length
-  return sanitized.slice(0, 500);
-}
-
-/**
- * Wraps an async function with error handling
- */
-export async function withErrorHandling<T>(
-  operation: () => Promise<T>,
-  onError?: (error: Error) => void
-): Promise<{ data?: T; error?: Error }> {
-  try {
-    const data = await operation();
-    return { data };
-  } catch (error) {
-    const errorMessage = getErrorMessage(error);
-    const sanitizedMessage = sanitizeErrorMessage(errorMessage);
-    const appError = new Error(sanitizedMessage);
-
-    // In production, don't expose original error details
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[withErrorHandling] Original error:", error);
-    }
-
-    onError?.(appError);
-    return { error: appError };
-  }
-}
-
-