@umituz/react-native-ai-fal-provider 3.1.7 → 3.2.0

package/src/infrastructure/utils/job-metadata/job-metadata-format.util.ts

@@ -1,78 +0,0 @@
-/**
- * Job Metadata Formatting
- * Duration, progress calculation, and formatting utilities
- */
-
-import type { FalJobMetadata } from "./job-metadata.types";
-
-/**
- * Get job duration in milliseconds
- * Returns null if job not completed or if dates are invalid
- */
-export function getJobDuration(metadata: FalJobMetadata): number | null {
-  if (!metadata.completedAt) {
-    return null;
-  }
-
-  const completedTime = new Date(metadata.completedAt).getTime();
-  const createdTime = new Date(metadata.createdAt).getTime();
-
-  // Validate both dates parsed correctly
-  if (isNaN(completedTime) || isNaN(createdTime)) {
-    console.warn(
-      '[job-metadata] Invalid date(s) in metadata:',
-      { completedAt: metadata.completedAt, createdAt: metadata.createdAt }
-    );
-    return null;
-  }
-
-  const duration = completedTime - createdTime;
-
-  // Sanity check: duration should be positive
-  if (duration < 0) {
-    console.warn(
-      '[job-metadata] Negative duration detected (completedAt < createdAt):',
-      { duration, completedAt: metadata.completedAt, createdAt: metadata.createdAt }
-    );
-    return null;
-  }
-
-  return duration;
-}
-
-/**
- * Format job duration for display
- */
-export function formatJobDuration(metadata: FalJobMetadata): string {
-  const duration = getJobDuration(metadata);
-  if (!duration) {
-    return "In progress";
-  }
-
-  const seconds = Math.floor(duration / 1000);
-  if (seconds < 60) {
-    return `${seconds}s`;
-  }
-
-  const minutes = Math.floor(seconds / 60);
-  const remainingSeconds = seconds % 60;
-  return remainingSeconds > 0 ? `${minutes}m ${remainingSeconds}s` : `${minutes}m`;
-}
-
-/**
- * Calculate job progress percentage
- */
-export function calculateJobProgress(metadata: FalJobMetadata): number {
-  switch (metadata.status) {
-    case "IN_QUEUE":
-      return 10;
-    case "IN_PROGRESS":
-      return 50;
-    case "COMPLETED":
-      return 100;
-    case "FAILED":
-      return 0;
-    default:
-      return 0;
-  }
-}

package/src/infrastructure/utils/job-metadata/job-metadata-lifecycle.util.ts

@@ -1,66 +0,0 @@
-/**
- * Job Metadata Lifecycle
- * Create, update, and status check operations
- */
-
-import type { JobStatus } from "../../../domain/types";
-import type { FalJobMetadata } from "./job-metadata.types";
-
-/**
- * Create job metadata
- */
-export function createJobMetadata(
-  requestId: string,
-  model: string,
-  timeout?: number
-): FalJobMetadata {
-  const now = new Date().toISOString();
-  return {
-    requestId,
-    model,
-    status: "IN_QUEUE",
-    createdAt: now,
-    updatedAt: now,
-    timeout,
-  };
-}
-
-/**
- * Update job metadata status
- */
-export function updateJobMetadata(
-  metadata: FalJobMetadata,
-  status: JobStatus["status"],
-  error?: string
-): FalJobMetadata {
-  return {
-    ...metadata,
-    status,
-    updatedAt: new Date().toISOString(),
-    ...(status === "COMPLETED" || status === "FAILED" ? { completedAt: new Date().toISOString() } : {}),
-    ...(error ? { error } : {}),
-  };
-}
-
-/**
- * Check if job is completed (success or failure)
- */
-export function isJobCompleted(metadata: FalJobMetadata): boolean {
-  return metadata.status === "COMPLETED" || metadata.status === "FAILED";
-}
-
-/**
- * Check if job is running
- */
-export function isJobRunning(metadata: FalJobMetadata): boolean {
-  return metadata.status === "IN_QUEUE" || metadata.status === "IN_PROGRESS";
-}
-
-/**
- * Check if job is stale (older than specified minutes)
- */
-export function isJobStale(metadata: FalJobMetadata, maxAgeMinutes: number = 60): boolean {
-  const age = Date.now() - new Date(metadata.createdAt).getTime();
-  const maxAgeMs = maxAgeMinutes * 60 * 1000;
-  return age > maxAgeMs;
-}

package/src/infrastructure/utils/job-metadata/job-metadata-queries.util.ts

@@ -1,57 +0,0 @@
-/**
- * Job Metadata Queries
- * Serialization and array operations
- */
-
-import type { FalJobMetadata } from "./job-metadata.types";
-import { isJobStale, isJobRunning, isJobCompleted } from "./job-metadata-lifecycle.util";
-import { sortByDateDescending, filterByPredicate } from "../collections";
-import { safeJsonParseOrNull, validateObjectStructure } from "../parsers";
-
-/**
- * Serialize job metadata for storage
- */
-export function serializeJobMetadata(metadata: FalJobMetadata): string {
-  return JSON.stringify(metadata);
-}
-
-/**
- * Deserialize job metadata from storage
- */
-export function deserializeJobMetadata(data: string): FalJobMetadata | null {
-  const parsed = safeJsonParseOrNull<Record<string, unknown>>(data);
-
-  if (!parsed || !validateObjectStructure<Partial<FalJobMetadata>>(parsed, ["requestId", "model", "status"] as const)) {
-    return null;
-  }
-
-  return parsed as FalJobMetadata;
-}
-
-/**
- * Filter valid job metadata from array
- */
-export function filterValidJobs(jobs: FalJobMetadata[]): FalJobMetadata[] {
-  return filterByPredicate(jobs, (job) => !isJobStale(job));
-}
-
-/**
- * Sort jobs by creation time (newest first)
- */
-export function sortJobsByCreation(jobs: FalJobMetadata[]): FalJobMetadata[] {
-  return sortByDateDescending(jobs, "createdAt");
-}
-
-/**
- * Get active jobs (not completed and not stale)
- */
-export function getActiveJobs(jobs: FalJobMetadata[]): FalJobMetadata[] {
-  return filterByPredicate(jobs, (job) => isJobRunning(job) && !isJobStale(job));
-}
-
-/**
- * Get completed jobs
- */
-export function getCompletedJobs(jobs: FalJobMetadata[]): FalJobMetadata[] {
-  return filterByPredicate(jobs, isJobCompleted);
-}

package/src/infrastructure/utils/job-metadata/job-metadata.types.ts

@@ -1,19 +0,0 @@
-/**
- * Job Metadata Types
- */
-
-import type { JobStatus } from "../../../domain/types";
-
-/**
- * Job metadata for tracking and persistence
- */
-export interface FalJobMetadata {
-  readonly requestId: string;
-  readonly model: string;
-  readonly status: JobStatus["status"];
-  readonly createdAt: string;
-  readonly updatedAt: string;
-  readonly completedAt?: string;
-  readonly timeout?: number;
-  readonly error?: string;
-}

package/src/infrastructure/utils/job-storage/index.ts

@@ -1,19 +0,0 @@
-/**
- * Job Storage Utilities
- * Exports all job storage functionality
- */
-
-export type { IJobStorage } from "./job-storage-interface";
-export { InMemoryJobStorage } from "./job-storage-interface";
-export {
-  saveJobMetadata,
-  loadJobMetadata,
-  deleteJobMetadata,
-  updateJobStatus,
-} from "./job-storage-crud.util";
-export {
-  loadAllJobs,
-  cleanupOldJobs,
-  getJobsByModel,
-  getJobsByStatus,
-} from "./job-storage-queries.util";

package/src/infrastructure/utils/job-storage/job-storage-crud.util.ts

@@ -1,64 +0,0 @@
-/**
- * Job Storage CRUD Operations
- * Basic create, read, update, delete operations for job metadata
- */
-
-import type { FalJobMetadata } from "../job-metadata";
-import { updateJobMetadata } from "../job-metadata";
-import type { IJobStorage } from "./job-storage-interface";
-import { safeJsonParseOrNull, safeJsonStringify } from "../parsers";
-
-/**
- * Save job metadata to storage
- */
-export async function saveJobMetadata(
-  storage: IJobStorage,
-  metadata: FalJobMetadata
-): Promise<void> {
-  const key = `fal_job:${metadata.requestId}`;
-  const value = safeJsonStringify(metadata, "{}");
-  await storage.setItem(key, value);
-}
-
-/**
- * Load job metadata from storage
- */
-export async function loadJobMetadata(
-  storage: IJobStorage,
-  requestId: string
-): Promise<FalJobMetadata | null> {
-  const key = `fal_job:${requestId}`;
-  const value = await storage.getItem(key);
-  if (!value) return null;
-
-  return safeJsonParseOrNull<FalJobMetadata>(value);
-}
-
-/**
- * Delete job metadata from storage
- */
-export async function deleteJobMetadata(
-  storage: IJobStorage,
-  requestId: string
-): Promise<void> {
-  const key = `fal_job:${requestId}`;
-  await storage.removeItem(key);
-}
-
-/**
- * Update job status in storage
- */
-export async function updateJobStatus(
-  storage: IJobStorage,
-  requestId: string,
-  status: FalJobMetadata["status"],
-  error?: string
-): Promise<void> {
-  const metadata = await loadJobMetadata(storage, requestId);
-  if (!metadata) {
-    throw new Error(`Job not found: ${requestId}`);
-  }
-
-  const updated = updateJobMetadata(metadata, status, error);
-  await saveJobMetadata(storage, updated);
-}

package/src/infrastructure/utils/job-storage/job-storage-interface.ts

@@ -1,44 +0,0 @@
-/**
- * Job Storage Interface
- * Generic storage interface for job persistence
- */
-
-/**
- * Generic storage interface for job persistence
- * Implement this interface with your preferred storage backend
- */
-export interface IJobStorage {
-  setItem(key: string, value: string): Promise<void>;
-  getItem(key: string): Promise<string | null>;
-  removeItem(key: string): Promise<void>;
-  getAllKeys?(): Promise<readonly string[]>;
-}
-
-/**
- * Simple in-memory storage for testing
- */
-export class InMemoryJobStorage implements IJobStorage {
-  private store = new Map<string, string>();
-
-  setItem(key: string, value: string): Promise<void> {
-    this.store.set(key, value);
-    return Promise.resolve();
-  }
-
-  getItem(key: string): Promise<string | null> {
-    return Promise.resolve(this.store.get(key) ?? null);
-  }
-
-  removeItem(key: string): Promise<void> {
-    this.store.delete(key);
-    return Promise.resolve();
-  }
-
-  getAllKeys(): Promise<readonly string[]> {
-    return Promise.resolve(Array.from(this.store.keys()));
-  }
-
-  clear(): void {
-    this.store.clear();
-  }
-}

package/src/infrastructure/utils/job-storage/job-storage-queries.util.ts

@@ -1,81 +0,0 @@
-/**
- * Job Storage Query Operations
- * Query and batch operations for job metadata
- */
-
-import type { FalJobMetadata } from "../job-metadata";
-import type { IJobStorage } from "./job-storage-interface";
-import { deleteJobMetadata } from "./job-storage-crud.util";
-import { safeJsonParseOrNull } from "../parsers";
-
-/**
- * Load all jobs from storage
- */
-export async function loadAllJobs(
-  storage: IJobStorage
-): Promise<FalJobMetadata[]> {
-  if (!storage.getAllKeys) {
-    return [];
-  }
-
-  const keys = await storage.getAllKeys();
-  const jobKeys = keys.filter((key) => key.startsWith("fal_job:"));
-
-  const jobs: FalJobMetadata[] = [];
-  for (const key of jobKeys) {
-    const value = await storage.getItem(key);
-    if (value) {
-      const metadata = safeJsonParseOrNull<FalJobMetadata>(value);
-      if (metadata) {
-        jobs.push(metadata);
-      }
-    }
-  }
-
-  return jobs;
-}
-
-/**
- * Clean up old jobs from storage
- */
-export async function cleanupOldJobs(
-  storage: IJobStorage,
-  maxAgeMinutes: number = 60
-): Promise<number> {
-  const jobs = await loadAllJobs(storage);
-  const now = Date.now();
-  const maxAgeMs = maxAgeMinutes * 60 * 1000;
-  let cleanedCount = 0;
-
-  for (const job of jobs) {
-    const jobAge = now - new Date(job.createdAt).getTime();
-    if (jobAge > maxAgeMs) {
-      await deleteJobMetadata(storage, job.requestId);
-      cleanedCount++;
-    }
-  }
-
-  return cleanedCount;
-}
-
-/**
- * Get jobs by model
- */
-export async function getJobsByModel(
-  storage: IJobStorage,
-  model: string
-): Promise<FalJobMetadata[]> {
-  const jobs = await loadAllJobs(storage);
-  return jobs.filter((job) => job.model === model);
-}
-
-/**
- * Get jobs by status
- */
-export async function getJobsByStatus(
-  storage: IJobStorage,
-  status: FalJobMetadata["status"]
-): Promise<FalJobMetadata[]> {
-  const jobs = await loadAllJobs(storage);
-  return jobs.filter((job) => job.status === status);
-}

package/src/infrastructure/utils/number-format.util.ts

@@ -1,86 +0,0 @@
-/**
- * Number Formatting Utilities
- * Functions for formatting numbers and quantities
- */
-
-/**
- * Format number with decimal places
- */
-export function formatNumber(value: number, decimals: number = 2): string {
-  if (Number.isNaN(value) || !Number.isFinite(value)) {
-    return "0";
-  }
-
-  // Return integer if no decimal part
-  if (value % 1 === 0) {
-    return value.toString();
-  }
-
-  return value.toFixed(decimals);
-}
-
-/**
- * Format bytes to human-readable size
- * Handles edge cases: negative bytes, NaN, Infinity, extremely large values
- */
-export function formatBytes(bytes: number, decimals: number = 2): string {
-  // Handle invalid inputs
-  if (!Number.isFinite(bytes) || Number.isNaN(bytes)) {
-    return "0 Bytes";
-  }
-
-  // Handle negative bytes
-  if (bytes < 0) {
-    return `-${formatBytes(-bytes, decimals)}`;
-  }
-
-  // Handle zero
-  if (bytes === 0) {
-    return "0 Bytes";
-  }
-
-  const k = 1024;
-  const dm = decimals < 0 ? 0 : decimals;
-  const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-
-  // Clamp index to valid range
-  const index = Math.min(i, sizes.length - 1);
-
-  // For extremely large values beyond our size array
-  if (index >= sizes.length - 1 && i > sizes.length - 1) {
-    const exponent = i - (sizes.length - 1);
-    const value = bytes / Math.pow(k, sizes.length - 1);
-    return `${parseFloat(value.toFixed(dm))} ${sizes[sizes.length - 1]} × ${k}^${exponent}`;
-  }
-
-  return `${parseFloat((bytes / Math.pow(k, index)).toFixed(dm))} ${sizes[index]}`;
-}
-
-/**
- * Format duration in milliseconds to human-readable string
- */
-export function formatDuration(milliseconds: number): string {
-  if (milliseconds < 1000) {
-    return `${milliseconds}ms`;
-  }
-
-  const seconds = Math.floor(milliseconds / 1000);
-  if (seconds < 60) {
-    return `${seconds}s`;
-  }
-
-  const minutes = Math.floor(seconds / 60);
-  const remainingSeconds = seconds % 60;
-  if (minutes < 60) {
-    return remainingSeconds > 0
-      ? `${minutes}m ${remainingSeconds}s`
-      : `${minutes}m`;
-  }
-
-  const hours = Math.floor(minutes / 60);
-  const remainingMinutes = minutes % 60;
-  return remainingMinutes > 0
-    ? `${hours}h ${remainingMinutes}m`
-    : `${hours}h`;
-}

package/src/infrastructure/utils/parsers/object-validators.util.ts

@@ -1,38 +0,0 @@
-/**
- * Object Validator Utilities
- * Runtime object structure validation
- */
-
-/**
- * Validate object structure
- */
-export function validateObjectStructure<T extends Record<string, unknown>>(
-  data: unknown,
-  requiredKeys: readonly (keyof T)[]
-): data is T {
-  if (!data || typeof data !== "object") {
-    return false;
-  }
-
-  for (const key of requiredKeys) {
-    if (!(key in data)) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-/**
- * Validate array of objects
- */
-export function validateObjectArray<T>(
-  data: unknown,
-  validator: (item: unknown) => item is T
-): data is T[] {
-  if (!Array.isArray(data)) {
-    return false;
-  }
-
-  return data.every(validator);
-}

package/src/infrastructure/utils/parsers/value-parsers.util.ts

@@ -1,45 +0,0 @@
-/**
- * Value Parser Utilities
- * Parse primitive values with fallbacks
- */
-
-/**
- * Parse number with fallback
- */
-export function parseNumber(value: unknown, fallback: number): number {
-  if (typeof value === "number") {
-    return value;
-  }
-
-  if (typeof value === "string") {
-    const parsed = Number.parseFloat(value);
-    return Number.isNaN(parsed) ? fallback : parsed;
-  }
-
-  return fallback;
-}
-
-/**
- * Parse boolean with fallback
- */
-export function parseBoolean(value: unknown, fallback: boolean): boolean {
-  if (typeof value === "boolean") {
-    return value;
-  }
-
-  if (typeof value === "string") {
-    const lower = value.toLowerCase().trim();
-    if (lower === "true" || lower === "yes" || lower === "1") {
-      return true;
-    }
-    if (lower === "false" || lower === "no" || lower === "0") {
-      return false;
-    }
-  }
-
-  if (typeof value === "number") {
-    return value !== 0;
-  }
-
-  return fallback;
-}

package/src/infrastructure/utils/string-format.util.ts

@@ -1,72 +0,0 @@
-/**
- * String Formatting Utilities
- * Functions for formatting and manipulating strings
- *
- * Consolidates text truncation and prompt sanitization utilities.
- * Previously duplicated across string-format.util.ts and prompt-helpers.util.ts.
- */
-
-/**
- * Truncate text with customizable ellipsis
- *
- * @param text - The text to truncate
- * @param maxLength - Maximum length including ellipsis
- * @param ellipsis - String to append when truncating (default: "...")
- * @returns Truncated text with ellipsis or original if under max length
- *
- * @example
- * ```typescript
- * truncateText("Hello World", 8); // "Hello..."
- * truncateText("Hello World", 8, "…"); // "Hello W…"
- * ```
- */
-export function truncateText(
-  text: string,
-  maxLength: number,
-  ellipsis: string = "..."
-): string {
-  if (text.length <= maxLength) {
-    return text;
-  }
-  return text.slice(0, maxLength - ellipsis.length) + ellipsis;
-}
-
-/**
- * Truncate prompt to maximum length
- * Specialized wrapper for prompt truncation with 5000 char default
- *
- * @param prompt - The prompt text to truncate
- * @param maxLength - Maximum length (default: 5000)
- * @returns Truncated prompt
- *
- * @example
- * ```typescript
- * truncatePrompt(longPrompt); // Truncates to 5000 chars
- * truncatePrompt(longPrompt, 1000); // Truncates to 1000 chars
- * ```
- */
-export function truncatePrompt(prompt: string, maxLength: number = 5000): string {
-  return truncateText(prompt, maxLength);
-}
-
-/**
- * Sanitize prompt by removing excessive whitespace and control characters
- * Also enforces maximum length of 5000 characters
- *
- * @param prompt - The prompt text to sanitize
- * @returns Sanitized prompt
- *
- * @example
- * ```typescript
- * sanitizePrompt("Hello  \n\n  World\x00"); // "Hello World"
- * ```
- */
-export function sanitizePrompt(prompt: string): string {
-  return prompt
-    .trim()
-    .replace(/\s+/g, " ")
-    // Remove control characters except tab, newline, carriage return
-    // eslint-disable-next-line no-control-regex
-    .replace(/[\x00-\x08\x0B-\x0C\x0E-\x1F\x7F]/g, '')
-    .slice(0, 5000);
-}