@umituz/react-native-ai-generation-content 1.1.0 → 1.3.0

package/package.json

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

package/src/domain/entities/index.ts

@@ -7,3 +7,4 @@ export * from "./error.types";
 export * from "./generation.types";
 export * from "./polling.types";
 export * from "./progress.types";
+export * from "./middleware.types";

package/src/domain/entities/middleware.types.ts

@@ -0,0 +1,56 @@
+/**
+ * Middleware Types
+ * Generic middleware pattern for generation workflow
+ */
+
+import type { GenerationRequest, GenerationResult } from "./generation.types";
+
+/**
+ * Context passed to middleware hooks
+ */
+export interface MiddlewareContext {
+  request: GenerationRequest;
+  userId?: string;
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * Result context passed to afterGenerate hook
+ */
+export interface MiddlewareResultContext<T> extends MiddlewareContext {
+  result: GenerationResult<T>;
+}
+
+/**
+ * Middleware hook executed before generation
+ * Can throw error to prevent generation
+ */
+export type BeforeGenerateHook = (
+  context: MiddlewareContext,
+) => Promise<void> | void;
+
+/**
+ * Middleware hook executed after generation (success or failure)
+ * Cannot modify result, used for logging/tracking
+ */
+export type AfterGenerateHook<T = unknown> = (
+  context: MiddlewareResultContext<T>,
+) => Promise<void> | void;
+
+/**
+ * Complete middleware configuration
+ */
+export interface GenerationMiddleware {
+  /** Hook executed before generation starts */
+  beforeGenerate?: BeforeGenerateHook;
+  /** Hook executed after generation completes (success or failure) */
+  afterGenerate?: AfterGenerateHook;
+}
+
+/**
+ * Middleware chain configuration
+ */
+export interface MiddlewareChain {
+  /** Array of middleware to execute in order */
+  middleware: GenerationMiddleware[];
+}

package/src/index.ts

@@ -42,6 +42,12 @@ export type {
   PollingOptions,
   ProgressStageConfig,
   ProgressConfig,
+  MiddlewareContext,
+  MiddlewareResultContext,
+  BeforeGenerateHook,
+  AfterGenerateHook,
+  GenerationMiddleware,
+  MiddlewareChain,
 } from "./domain/entities";
 
 export { DEFAULT_POLLING_CONFIG, DEFAULT_PROGRESS_STAGES } from "./domain/entities";
@@ -55,12 +61,15 @@ export {
   generationOrchestrator,
   pollJob,
   createJobPoller,
+  generationWrapper,
+  createGenerationWrapper,
 } from "./infrastructure/services";
 
 export type {
   OrchestratorConfig,
   PollJobOptions,
   PollJobResult,
+  WrapperConfig,
 } from "./infrastructure/services";
 
 // =============================================================================

package/src/infrastructure/services/generation-orchestrator.service.ts

@@ -30,6 +30,13 @@ class GenerationOrchestratorService {
   private config: OrchestratorConfig = {};
 
   configure(config: OrchestratorConfig): void {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[Orchestrator] configure() called", {
+        hasPollingConfig: !!config.polling,
+        hasStatusUpdate: !!config.onStatusUpdate,
+      });
+    }
     this.config = { ...this.config, ...config };
   }
 
@@ -139,6 +146,15 @@ class GenerationOrchestratorService {
     requestId: string,
     onProgress?: (progress: GenerationProgress) => void,
   ): Promise<T> {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[Orchestrator] pollForResult() started", {
+        provider: provider.providerId,
+        model,
+        requestId,
+      });
+    }
+
     const config = {
       ...DEFAULT_POLLING_CONFIG,
       ...this.config.polling,
@@ -149,6 +165,14 @@ class GenerationOrchestratorService {
     for (let attempt = 0; attempt < config.maxAttempts; attempt++) {
       await createPollingDelay(attempt, config);
 
+      if (typeof __DEV__ !== "undefined" && __DEV__ && attempt % 5 === 0) {
+        // eslint-disable-next-line no-console
+        console.log("[Orchestrator] pollForResult() attempt", {
+          attempt,
+          maxAttempts: config.maxAttempts,
+        });
+      }
+
       try {
         const status = await provider.getJobStatus(model, requestId);
 
@@ -157,6 +181,13 @@ class GenerationOrchestratorService {
         this.updateProgressFromStatus(status, attempt, config, onProgress);
 
         if (status.status === "COMPLETED") {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            // eslint-disable-next-line no-console
+            console.log("[Orchestrator] pollForResult() job COMPLETED", {
+              requestId,
+              attempt,
+            });
+          }
           return provider.getJobResult<T>(model, requestId);
         }
 
@@ -214,20 +245,41 @@ class GenerationOrchestratorService {
   }
 
   private getProvider(): IAIProvider {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[Orchestrator] getProvider() called");
+    }
+
     const provider = providerRegistry.getActiveProvider();
 
     if (!provider) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.error("[Orchestrator] No active provider found!");
+      }
       throw new Error(
         "No active AI provider. Register and set a provider first.",
       );
     }
 
     if (!provider.isInitialized()) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.error("[Orchestrator] Provider not initialized:", provider.providerId);
+      }
       throw new Error(
         `Provider ${provider.providerId} is not initialized.`,
       );
     }
 
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[Orchestrator] getProvider() returning:", {
+        providerId: provider.providerId,
+        isInitialized: provider.isInitialized(),
+      });
+    }
+
     return provider;
   }
 }

package/src/infrastructure/services/generation-wrapper.service.ts

@@ -0,0 +1,148 @@
+/**
+ * Generation Wrapper Service
+ * Wraps orchestrator with middleware support
+ * Enables credit checking, moderation, history via middleware pattern
+ */
+
+import type {
+  GenerationRequest,
+  GenerationResult,
+  GenerationMiddleware,
+  MiddlewareContext,
+  MiddlewareResultContext,
+} from "../../domain/entities";
+import { generationOrchestrator } from "./generation-orchestrator.service";
+import type { OrchestratorConfig } from "./generation-orchestrator.service";
+
+export interface WrapperConfig {
+  /** Middleware to execute before/after generation */
+  middleware?: GenerationMiddleware[];
+  /** Orchestrator configuration */
+  orchestratorConfig?: OrchestratorConfig;
+}
+
+class GenerationWrapperService {
+  private middleware: GenerationMiddleware[] = [];
+  private orchestratorConfig?: OrchestratorConfig;
+
+  /**
+   * Configure wrapper with middleware
+   */
+  configure(config: WrapperConfig): void {
+    this.middleware = config.middleware || [];
+    this.orchestratorConfig = config.orchestratorConfig;
+
+    if (this.orchestratorConfig) {
+      generationOrchestrator.configure(this.orchestratorConfig);
+    }
+  }
+
+  /**
+   * Add middleware to chain
+   */
+  use(middleware: GenerationMiddleware): void {
+    this.middleware.push(middleware);
+  }
+
+  /**
+   * Clear all middleware
+   */
+  clearMiddleware(): void {
+    this.middleware = [];
+  }
+
+  /**
+   * Generate with middleware support
+   */
+  async generate<T = unknown>(
+    request: GenerationRequest,
+    userId?: string,
+    metadata?: Record<string, unknown>,
+  ): Promise<GenerationResult<T>> {
+    const startTime = Date.now();
+
+    const context: MiddlewareContext = {
+      request,
+      userId,
+      metadata,
+    };
+
+    try {
+      await this.executeBeforeHooks(context);
+
+      const result = await generationOrchestrator.generate<T>(request);
+
+      const resultContext: MiddlewareResultContext<T> = {
+        ...context,
+        result,
+      };
+
+      await this.executeAfterHooks(resultContext);
+
+      return result;
+    } catch (error) {
+      const errorResult: GenerationResult<T> = {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        metadata: {
+          model: request.model || "unknown",
+          startTime,
+          endTime: Date.now(),
+          duration: Date.now() - startTime,
+        },
+      };
+
+      const resultContext: MiddlewareResultContext<T> = {
+        ...context,
+        result: errorResult,
+      };
+
+      await this.executeAfterHooks(resultContext).catch(() => {
+        // Silent fail on afterHooks error
+      });
+
+      return errorResult;
+    }
+  }
+
+  /**
+   * Execute all beforeGenerate hooks
+   */
+  private async executeBeforeHooks(
+    context: MiddlewareContext,
+  ): Promise<void> {
+    for (const mw of this.middleware) {
+      if (mw.beforeGenerate) {
+        await mw.beforeGenerate(context);
+      }
+    }
+  }
+
+  /**
+   * Execute all afterGenerate hooks
+   */
+  private async executeAfterHooks<T>(
+    context: MiddlewareResultContext<T>,
+  ): Promise<void> {
+    for (const mw of this.middleware) {
+      if (mw.afterGenerate) {
+        await mw.afterGenerate(context);
+      }
+    }
+  }
+}
+
+export const generationWrapper = new GenerationWrapperService();
+
+/**
+ * Create new wrapper instance
+ */
+export function createGenerationWrapper(
+  config?: WrapperConfig,
+): GenerationWrapperService {
+  const wrapper = new GenerationWrapperService();
+  if (config) {
+    wrapper.configure(config);
+  }
+  return wrapper;
+}

package/src/infrastructure/services/index.ts

@@ -7,3 +7,8 @@ export { generationOrchestrator } from "./generation-orchestrator.service";
 export type { OrchestratorConfig } from "./generation-orchestrator.service";
 export { pollJob, createJobPoller } from "./job-poller.service";
 export type { PollJobOptions, PollJobResult } from "./job-poller.service";
+export {
+  generationWrapper,
+  createGenerationWrapper,
+} from "./generation-wrapper.service";
+export type { WrapperConfig } from "./generation-wrapper.service";

package/src/infrastructure/services/provider-registry.service.ts

@@ -52,10 +52,33 @@ class ProviderRegistry {
   }
 
   getActiveProvider(): IAIProvider | null {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[ProviderRegistry] getActiveProvider() called", {
+        activeProviderId: this.activeProviderId,
+        registeredProviders: Array.from(this.providers.keys()),
+      });
+    }
+
     if (!this.activeProviderId) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.warn("[ProviderRegistry] No active provider set!");
+      }
       return null;
     }
-    return this.providers.get(this.activeProviderId) ?? null;
+
+    const provider = this.providers.get(this.activeProviderId) ?? null;
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[ProviderRegistry] getActiveProvider() returning", {
+        providerId: provider?.providerId,
+        isInitialized: provider?.isInitialized(),
+      });
+    }
+
+    return provider;
   }
 
   getProvider(providerId: string): IAIProvider | null {