@umituz/react-native-ai-generation-content 1.90.2 → 1.90.4

package/src/shared-kernel/base-types/base-feature-state.types.ts

@@ -0,0 +1,77 @@
+/**
+ * Base feature state types for AI generation features
+ * Provides consistent state management across all domains
+ */
+
+import type { GenerationProgress } from './base-generation.types';
+
+/**
+ * Base state for all generation features
+ * Used by hooks and components for consistent state management
+ */
+export interface BaseFeatureState<TOutput = string> {
+  /** Whether a generation is currently in progress */
+  isProcessing: boolean;
+  /** Current generation progress (0-1) */
+  progress: number;
+  /** Error message if operation failed */
+  error: string | null;
+  /** Generated output data */
+  output: TOutput | null;
+  /** Additional progress information */
+  progressInfo?: GenerationProgress;
+}
+
+/**
+ * Feature state with additional metadata
+ */
+export interface FeatureStateWithMetadata<TOutput = string> extends BaseFeatureState<TOutput> {
+  /** Unique ID for the current generation job */
+  jobId?: string;
+  /** Timestamp when generation started */
+  startedAt?: number;
+  /** Timestamp when generation completed */
+  completedAt?: number;
+  /** Number of retry attempts */
+  retryCount?: number;
+}
+
+/**
+ * Actions that can be performed on feature state
+ */
+export type FeatureStateAction<TOutput = string> =
+  | { type: 'START'; jobId?: string }
+  | { type: 'PROGRESS'; progress: number; status?: string }
+  | { type: 'SUCCESS'; output: TOutput; metadata?: Record<string, unknown> }
+  | { type: 'ERROR'; error: string }
+  | { type: 'RESET' };
+
+/**
+ * Initial state factory
+ */
+export function createInitialFeatureState<TOutput = string>(): BaseFeatureState<TOutput> {
+  return {
+    isProcessing: false,
+    progress: 0,
+    error: null,
+    output: null,
+  };
+}
+
+/**
+ * Check if feature state is in an error state
+ */
+export function isFeatureStateError<TOutput = string>(
+  state: BaseFeatureState<TOutput>
+): boolean {
+  return state.error !== null;
+}
+
+/**
+ * Check if feature state has output
+ */
+export function hasFeatureStateOutput<TOutput = string>(
+  state: BaseFeatureState<TOutput>
+): boolean {
+  return state.output !== null;
+}

package/src/shared-kernel/base-types/base-generation.types.ts

@@ -0,0 +1,69 @@
+/**
+ * Base types for AI generation operations
+ * Shared across all generation domains (text-to-image, text-to-video, image-to-video, etc.)
+ */
+
+/**
+ * Common aspect ratios used across all generation types
+ */
+export type AspectRatio = '16:9' | '9:16' | '1:1' | '4:3' | '3:4';
+
+/**
+ * Base generation options that are common to most generation types
+ */
+export interface BaseGenerationOptions {
+  /** Output aspect ratio */
+  aspectRatio?: AspectRatio;
+  /** Number of steps/inference iterations */
+  steps?: number;
+  /** Guidance scale for generation (0-20 typically) */
+  guidanceScale?: number;
+  /** Random seed for reproducible results */
+  seed?: number;
+  /** Number of outputs to generate */
+  numOutputs?: number;
+}
+
+/**
+ * Common generation request metadata
+ */
+export interface BaseRequestMeta {
+  /** Unique identifier for this request */
+  requestId: string;
+  /** User ID making the request */
+  userId: string;
+  /** Timestamp when request was created */
+  timestamp: number;
+  /** Request priority for queue management */
+  priority?: 'low' | 'normal' | 'high';
+}
+
+/**
+ * Standard generation result structure
+ */
+export interface BaseGenerationResult<T = string> {
+  /** Whether the generation was successful */
+  success: boolean;
+  /** Generated content URL or data */
+  data?: T;
+  /** Error message if generation failed */
+  error?: string;
+  /** Request identifier */
+  requestId: string;
+  /** Time taken to complete generation (ms) */
+  duration?: number;
+  /** Additional metadata */
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * Generation progress information
+ */
+export interface GenerationProgress {
+  /** Current progress (0-1) */
+  progress: number;
+  /** Current status message */
+  status?: string;
+  /** Estimated time remaining (ms) */
+  eta?: number;
+}

package/src/shared-kernel/base-types/index.ts

@@ -0,0 +1,30 @@
+/**
+ * Shared kernel base types
+ * Exports all base types for use across domains
+ */
+
+export type {
+  AspectRatio,
+  BaseGenerationOptions,
+  BaseRequestMeta,
+  BaseGenerationResult,
+  GenerationProgress,
+} from './base-generation.types';
+
+export type {
+  BaseFeatureState,
+  FeatureStateWithMetadata,
+  FeatureStateAction,
+  createInitialFeatureState,
+  isFeatureStateError,
+  hasFeatureStateOutput,
+} from './base-feature-state.types';
+
+export type {
+  CreditCallbacks,
+  ProgressCallbacks,
+  ResultCallbacks,
+  BaseGenerationCallbacks,
+  ValidationCallbacks,
+  LifecycleCallbacks,
+} from './base-callbacks.types';

package/src/shared-kernel/domain/base-generation-strategy.ts

@@ -0,0 +1,146 @@
+/**
+ * Base strategy pattern for generation operations
+ * Eliminates duplicate strategy implementations across domains
+ */
+
+import type {
+  BaseGenerationCallbacks,
+  BaseGenerationResult,
+  BaseRequestMeta,
+  GenerationProgress,
+} from '../base-types';
+
+/**
+ * Base strategy interface for all generation operations
+ */
+export interface IGenerationStrategy<TInput, TOutput> {
+  /** Execute the generation operation */
+  execute(input: TInput, meta: BaseRequestMeta): Promise<BaseGenerationResult<TOutput>>;
+  /** Validate input before execution */
+  validate(input: TInput): boolean | Promise<boolean>;
+  /** Get estimated cost in credits */
+  getCreditCost(input: TInput): number;
+  /** Cancel ongoing generation */
+  cancel?(): void;
+}
+
+/**
+ * Abstract base class for generation strategies
+ * Provides common implementation for all strategies
+ */
+export abstract class BaseGenerationStrategy<TInput, TOutput>
+  implements IGenerationStrategy<TInput, TOutput>
+{
+  protected callbacks?: BaseGenerationCallbacks<TOutput>;
+  protected isCancelled = false;
+
+  constructor(callbacks?: BaseGenerationCallbacks<TOutput>) {
+    this.callbacks = callbacks;
+  }
+
+  /**
+   * Execute generation with consistent error handling and callbacks
+   */
+  async execute(
+    input: TInput,
+    meta: BaseRequestMeta
+  ): Promise<BaseGenerationResult<TOutput>> {
+    const startTime = Date.now();
+
+    try {
+      this.isCancelled = false;
+      this.callbacks?.onStart?.();
+
+      // Validate input
+      const isValid = await this.validate(input);
+      if (!isValid) {
+        throw new Error('Invalid input');
+      }
+
+      // Check credits
+      const creditCost = this.getCreditCost(input);
+      if (this.callbacks?.onCreditCheck) {
+        const hasCredits = await this.callbacks.onCreditCheck();
+        if (!hasCredits) {
+          this.callbacks?.onShowPaywall?.();
+          return {
+            success: false,
+            error: 'Insufficient credits',
+            requestId: meta.requestId,
+          };
+        }
+      }
+
+      // Execute generation
+      const result = await this.doExecute(input, meta);
+
+      if (this.isCancelled) {
+        this.callbacks?.onCancel?.();
+        return {
+          success: false,
+          error: 'Generation cancelled',
+          requestId: meta.requestId,
+        };
+      }
+
+      if (result.success) {
+        this.callbacks?.onSuccess?.(result);
+        this.callbacks?.onCreditsConsumed?.(creditCost);
+      } else {
+        const error = new Error(result.error || 'Generation failed');
+        this.callbacks?.onError?.(error);
+      }
+
+      this.callbacks?.onComplete?.();
+
+      return {
+        ...result,
+        duration: Date.now() - startTime,
+      };
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error('Unknown error');
+      this.callbacks?.onError?.(err);
+      this.callbacks?.onComplete?.();
+
+      return {
+        success: false,
+        error: err.message,
+        requestId: meta.requestId,
+        duration: Date.now() - startTime,
+      };
+    }
+  }
+
+  /**
+   * Abstract method to be implemented by concrete strategies
+   */
+  protected abstract doExecute(
+    input: TInput,
+    meta: BaseRequestMeta
+  ): Promise<BaseGenerationResult<TOutput>>;
+
+  /**
+   * Abstract validation method to be implemented by concrete strategies
+   */
+  abstract validate(input: TInput): boolean | Promise<boolean>;
+
+  /**
+   * Abstract credit cost method to be implemented by concrete strategies
+   */
+  abstract getCreditCost(input: TInput): number;
+
+  /**
+   * Cancel ongoing generation
+   */
+  cancel(): void {
+    this.isCancelled = true;
+  }
+
+  /**
+   * Report progress during generation
+   */
+  protected reportProgress(progress: number, status?: string): void {
+    const progressInfo: GenerationProgress = { progress, status };
+    this.callbacks?.onProgress?.(progressInfo);
+  }
+}

package/src/shared-kernel/domain/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Shared domain layer
+ * Exports base strategy pattern for use across domains
+ */
+
+export type { IGenerationStrategy } from './base-generation-strategy';
+export { BaseGenerationStrategy } from './base-generation-strategy';

package/src/shared-kernel/index.ts

@@ -0,0 +1,17 @@
+/**
+ * Shared Kernel Module
+ * Provides base types, utilities, and patterns for all domains
+ * Following DDD principles with clean architecture
+ */
+
+// Base types
+export * from './base-types';
+
+// Application services
+export * from './application/hooks';
+
+// Domain layer
+export * from './domain';
+
+// Infrastructure utilities
+export * from './infrastructure/validation';

package/src/shared-kernel/infrastructure/validation/common-validators.ts

@@ -0,0 +1,126 @@
+/**
+ * Common validation utilities
+ * Shared validation logic across all domains
+ */
+
+import type { ValidationResult, StringValidationOptions, NumberValidationOptions } from "./common-validators.types";
+
+/**
+ * Validate a string value
+ */
+export function validateString(
+  value: string,
+  options: StringValidationOptions = {}
+): ValidationResult {
+  const errors: Record<string, string> = {};
+  let processedValue = value;
+
+  if (options.trim) {
+    processedValue = value.trim();
+  }
+
+  if (options.required && !processedValue) {
+    errors.required = 'This field is required';
+  }
+
+  if (options.minLength && processedValue.length < options.minLength) {
+    errors.minLength = `Minimum length is ${options.minLength}`;
+  }
+
+  if (options.maxLength && processedValue.length > options.maxLength) {
+    errors.maxLength = `Maximum length is ${options.maxLength}`;
+  }
+
+  if (options.pattern && !options.pattern.test(processedValue)) {
+    errors.pattern = 'Invalid format';
+  }
+
+  return {
+    isValid: Object.keys(errors).length === 0,
+    errors,
+  };
+}
+
+/**
+ * Validate a number value
+ */
+export function validateNumber(
+  value: number,
+  options: NumberValidationOptions = {}
+): ValidationResult {
+  const errors: Record<string, string> = {};
+
+  if (options.required && (value === null || value === undefined)) {
+    errors.required = 'This field is required';
+    return { isValid: false, errors };
+  }
+
+  if (value === null || value === undefined) {
+    return { isValid: true, errors: {} };
+  }
+
+  if (options.integer && !Number.isInteger(value)) {
+    errors.integer = 'Must be an integer';
+  }
+
+  if (options.min !== undefined && value < options.min) {
+    errors.min = `Minimum value is ${options.min}`;
+  }
+
+  if (options.max !== undefined && value > options.max) {
+    errors.max = `Maximum value is ${options.max}`;
+  }
+
+  return {
+    isValid: Object.keys(errors).length === 0,
+    errors,
+  };
+}
+
+/**
+ * Validate a URL
+ */
+export function validateUrl(url: string): ValidationResult {
+  const urlPattern = /^https?:\/\/.+/i;
+  return validateString(url, {
+    required: true,
+    pattern: urlPattern,
+  });
+}
+
+/**
+ * Validate an object has required fields
+ */
+export function validateRequiredFields<T extends Record<string, unknown>>(
+  obj: T,
+  requiredFields: (keyof T)[]
+): ValidationResult {
+  const errors: Record<string, string> = {};
+
+  for (const field of requiredFields) {
+    if (obj[field] === null || obj[field] === undefined) {
+      errors[field as string] = `${String(field)} is required`;
+    }
+  }
+
+  return {
+    isValid: Object.keys(errors).length === 0,
+    errors,
+  };
+}
+
+/**
+ * Combine multiple validation results
+ */
+export function combineValidationResults(
+  ...results: ValidationResult[]
+): ValidationResult {
+  const allErrors = results.reduce((acc, result) => {
+    return { ...acc, ...result.errors };
+  }, {} as Record<string, string>);
+
+  return {
+    isValid: Object.keys(allErrors).length === 0,
+    errors: allErrors,
+  };
+}

package/src/shared-kernel/infrastructure/validation/common-validators.types.ts

@@ -0,0 +1,33 @@
+/**
+ * Common validation utilities - Types
+ * Type definitions for validation
+ */
+
+/**
+ * Validation result structure
+ */
+export interface ValidationResult {
+  isValid: boolean;
+  errors: Record<string, string>;
+}
+
+/**
+ * String validation options
+ */
+export interface StringValidationOptions {
+  minLength?: number;
+  maxLength?: number;
+  pattern?: RegExp;
+  required?: boolean;
+  trim?: boolean;
+}
+
+/**
+ * Number validation options
+ */
+export interface NumberValidationOptions {
+  min?: number;
+  max?: number;
+  integer?: boolean;
+  required?: boolean;
+}

package/src/shared-kernel/infrastructure/validation/error-handler.ts

@@ -0,0 +1,52 @@
+/**
+ * Centralized error handling utilities
+ * Standardizes error handling across all domains
+ */
+
+import type { AppError, ErrorHandlerOptions } from "./error-handler.types";
+import { toAppError, getUserFriendlyMessage } from "./error-handler.utils";
+
+/**
+ * Handle error with consistent behavior
+ */
+export function handleError(
+  error: unknown,
+  options: ErrorHandlerOptions = {}
+): AppError {
+  const {
+    logErrors = true,
+    showUserMessage = true,
+    transformError,
+  } = options;
+
+  const appError = toAppError(error);
+  const finalError = transformError ? transformError(appError) : appError;
+
+  if (logErrors) {
+    console.error('[Error Handler]', finalError);
+  }
+
+  if (showUserMessage) {
+    const userMessage = getUserFriendlyMessage(finalError);
+    // Could integrate with notification system here
+    console.warn('[User Message]', userMessage);
+  }
+
+  return finalError;
+}
+
+/**
+ * Wrap async function with error handling
+ */
+export function withErrorHandling<T extends (...args: unknown[]) => Promise<unknown>>(
+  fn: T,
+  options: ErrorHandlerOptions = {}
+): T {
+  return (async (...args: Parameters<T>) => {
+    try {
+      return await fn(...args);
+    } catch (error) {
+      throw handleError(error, options);
+    }
+  }) as T;
+}

package/src/shared-kernel/infrastructure/validation/error-handler.types.ts

@@ -0,0 +1,38 @@
+/**
+ * Error Handler - Types
+ * Type definitions for error handling
+ */
+
+/**
+ * Error types for categorization
+ */
+export enum ErrorType {
+  VALIDATION = 'VALIDATION',
+  NETWORK = 'NETWORK',
+  CREDIT = 'CREDIT',
+  PROVIDER = 'PROVIDER',
+  UNKNOWN = 'UNKNOWN',
+}
+
+/**
+ * Application error structure
+ */
+export interface AppError {
+  type: ErrorType;
+  message: string;
+  code?: string;
+  details?: Record<string, unknown>;
+  originalError?: unknown;
+}
+
+/**
+ * Error handler options
+ */
+export interface ErrorHandlerOptions {
+  /** Log errors to console */
+  logErrors?: boolean;
+  /** Show user-friendly messages */
+  showUserMessage?: boolean;
+  /** Custom error transformer */
+  transformError?: (error: AppError) => AppError;
+}

package/src/shared-kernel/infrastructure/validation/error-handler.utils.ts

@@ -0,0 +1,79 @@
+/**
+ * Error Handler - Utilities
+ * Utility functions for error handling
+ */
+
+import type { AppError } from "./error-handler.types";
+import { ErrorType } from "./error-handler.types";
+
+/**
+ * Create a standardized application error
+ */
+export function createError(
+  type: ErrorType,
+  message: string,
+  code?: string,
+  details?: Record<string, unknown>,
+  originalError?: unknown
+): AppError {
+  return {
+    type,
+    message,
+    code,
+    details,
+    originalError,
+  };
+}
+
+/**
+ * Convert unknown error to AppError
+ */
+export function toAppError(error: unknown): AppError {
+  if (isAppError(error)) {
+    return error;
+  }
+
+  if (error instanceof Error) {
+    return {
+      type: ErrorType.UNKNOWN,
+      message: error.message,
+      originalError: error,
+    };
+  }
+
+  return {
+    type: ErrorType.UNKNOWN,
+    message: String(error),
+    originalError: error,
+  };
+}
+
+/**
+ * Check if error is AppError
+ */
+export function isAppError(error: unknown): error is AppError {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    'type' in error &&
+    'message' in error
+  );
+}
+
+/**
+ * Get user-friendly error message
+ */
+export function getUserFriendlyMessage(error: AppError): string {
+  switch (error.type) {
+    case ErrorType.VALIDATION:
+      return 'Please check your input and try again.';
+    case ErrorType.NETWORK:
+      return 'Network error. Please check your connection and try again.';
+    case ErrorType.CREDIT:
+      return 'Insufficient credits. Please upgrade to continue.';
+    case ErrorType.PROVIDER:
+      return 'Service temporarily unavailable. Please try again later.';
+    default:
+      return error.message || 'An unexpected error occurred.';
+  }
+}