@umituz/react-native-ai-generation-content 1.40.1 → 1.40.3

package/package.json

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

package/src/domains/access-control/hooks/useAIFeatureGate.ts

@@ -0,0 +1,113 @@
+/**
+ * useAIFeatureGate Hook
+ * Centralized access control for AI features
+ *
+ * Single hook that handles:
+ * 1. Authentication check
+ * 2. Premium subscription check
+ * 3. Credit balance check
+ * 4. Paywall display
+ *
+ * Usage:
+ * ```typescript
+ * const { requireFeature } = useAIFeatureGate({ creditCost: 1 });
+ *
+ * <AtomicButton onPress={() => requireFeature(handleGenerate)}>
+ *   Generate
+ * </AtomicButton>
+ * ```
+ */
+
+import { useCallback, useMemo } from "react";
+import { useAuth, useAuthModalStore } from "@umituz/react-native-auth";
+import {
+  usePremium,
+  useCredits,
+  usePaywallVisibility,
+  useFeatureGate,
+} from "@umituz/react-native-subscription";
+import type {
+  AIFeatureGateOptions,
+  AIFeatureGateReturn,
+} from "../types/access-control.types";
+
+/**
+ * Hook for AI feature access control with 3-tier gating:
+ * Auth → Premium/Credits → Paywall → Execute
+ *
+ * @param options - Configuration for feature gate
+ * @returns Access control interface with requireFeature function
+ */
+export function useAIFeatureGate(
+  options: AIFeatureGateOptions,
+): AIFeatureGateReturn {
+  const { creditCost, featureName, onSuccess, onError } = options;
+
+  // Auth state
+  const { isAuthenticated: rawIsAuthenticated, isAnonymous } = useAuth();
+  const { showAuthModal } = useAuthModalStore();
+
+  // Subscription state
+  const { isPremium } = usePremium();
+  const { credits, isLoading: isCreditsLoading } = useCredits();
+  const { openPaywall } = usePaywallVisibility();
+
+  // Derived states
+  const isCreditsLoaded = !isCreditsLoading;
+  const isAuthenticated = rawIsAuthenticated && !isAnonymous;
+  const creditBalance = credits?.credits ?? 0;
+  const hasCredits = creditBalance >= creditCost;
+
+  // Configure feature gate from subscription package
+  const { requireFeature: requireFeatureFromPackage } = useFeatureGate({
+    isAuthenticated,
+    onShowAuthModal: (cb) => showAuthModal(cb),
+    hasSubscription: isPremium,
+    creditBalance,
+    requiredCredits: creditCost,
+    onShowPaywall: () => openPaywall(),
+    isCreditsLoaded,
+  });
+
+  // Can access if: authenticated AND (premium OR has credits)
+  const canAccess = useMemo(() => {
+    if (!isAuthenticated) return false;
+    if (isPremium) return true;
+    return hasCredits;
+  }, [isAuthenticated, isPremium, hasCredits]);
+
+  // Wrapped requireFeature with error handling
+  const requireFeature = useCallback(
+    async (action: () => void | Promise<void>): Promise<void> => {
+      try {
+        requireFeatureFromPackage(async () => {
+          try {
+            await action();
+            onSuccess?.();
+          } catch (error) {
+            const errorObj =
+              error instanceof Error ? error : new Error(String(error));
+            onError?.(errorObj);
+            throw error;
+          }
+        });
+      } catch (error) {
+        const errorObj =
+          error instanceof Error ? error : new Error(String(error));
+        onError?.(errorObj);
+        throw error;
+      }
+    },
+    [requireFeatureFromPackage, onSuccess, onError],
+  );
+
+  return {
+    requireFeature,
+    canAccess,
+    isCheckingAccess: isCreditsLoading,
+    hasCredits,
+    isAuthenticated,
+    isPremium,
+    creditBalance,
+  };
+}

package/src/domains/access-control/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Access Control Domain
+ * Centralized AI feature access control
+ */
+
+export { useAIFeatureGate } from "./hooks/useAIFeatureGate";
+
+export type {
+  AIFeatureGateOptions,
+  AIFeatureGateReturn,
+  AIFeatureGateHook,
+} from "./types/access-control.types";

package/src/domains/access-control/types/access-control.types.ts

@@ -0,0 +1,71 @@
+/**
+ * Access Control Types
+ * Type definitions for AI feature access control
+ */
+
+export interface AIFeatureGateOptions {
+  /**
+   * Number of credits required for this feature
+   */
+  creditCost: number;
+
+  /**
+   * Optional feature name for analytics tracking
+   */
+  featureName?: string;
+
+  /**
+   * Callback fired when feature is successfully accessed and executed
+   */
+  onSuccess?: () => void;
+
+  /**
+   * Callback fired when feature access fails or execution errors
+   */
+  onError?: (error: Error) => void;
+}
+
+export interface AIFeatureGateReturn {
+  /**
+   * Function to execute protected feature
+   * Handles all access control checks (auth, premium, credits, paywall)
+   */
+  requireFeature: (action: () => void | Promise<void>) => Promise<void>;
+
+  /**
+   * Whether user can access this feature (all checks passed)
+   */
+  canAccess: boolean;
+
+  /**
+   * Whether access checks are currently loading
+   */
+  isCheckingAccess: boolean;
+
+  /**
+   * Whether user has sufficient credits
+   */
+  hasCredits: boolean;
+
+  /**
+   * Whether user is authenticated (not anonymous)
+   */
+  isAuthenticated: boolean;
+
+  /**
+   * Whether user has premium subscription
+   */
+  isPremium: boolean;
+
+  /**
+   * Current credit balance
+   */
+  creditBalance: number;
+}
+
+/**
+ * Hook type definition for useAIFeatureGate
+ */
+export type AIFeatureGateHook = (
+  options: AIFeatureGateOptions,
+) => AIFeatureGateReturn;

package/src/index.ts

@@ -135,6 +135,7 @@ export * from "./domains/content-moderation";
 export * from "./domains/creations";
 export * from "./domains/face-detection";
 export * from "./domains/scenarios";
+export * from "./domains/access-control";
 export * from "./infrastructure/orchestration";
 
 export {