@umituz/web-polar-payment 1.0.14 → 1.0.16

package/src/infrastructure/services/firebase-billing.service.ts

@@ -9,44 +9,15 @@ import type {
   SyncResult,
 } from '../../domain/entities';
 import { normalizeStatus, normalizeBillingCycle } from '../utils/normalization.util';
+import { asString, asBoolean, isTimestamp } from '../utils/firebase-helpers.util';
 
-/**
- * Type guard to safely extract string value from unknown Firestore data
- */
-function asString(value: unknown): string | undefined {
-  if (typeof value === 'string') return value;
-  return undefined;
-}
-
-/**
- * Type guard to safely extract boolean value from unknown Firestore data
- */
-function asBoolean(value: unknown): boolean | undefined {
-  if (typeof value === 'boolean') return value;
-  return undefined;
-}
-
-/**
- * Type guard to safely check if value is an object with toDate method
- */
-function isTimestamp(value: unknown): value is { toDate(): Date } {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    'toDate' in value &&
-    typeof (value as { toDate: unknown }).toDate === 'function'
-  );
-}
-
-// Internal type aliases for Firebase SDK compatibility
-// Using 'any' internally to avoid DTS build issues with external Firebase packages
-type FirebaseFunctions = any;
-type FirebaseFirestore = any;
+type FirestoreDoc = (firestore: unknown, collectionPath: string, docId: string) => unknown;
+type FirestoreGetDoc = (ref: unknown) => Promise<{ exists: boolean; data(): Record<string, unknown> }>;
+type HttpsCallableFn = <T = unknown, R = unknown>(data?: T) => Promise<{ data: R }>;
+type HttpsCallable = (name: string) => HttpsCallableFn;
 
 export interface FirebaseAdapterConfig {
-  /** Firebase Functions instance from firebase/functions */
   functions: unknown;
-  /** Firebase Firestore instance from firebase/firestore */
   firestore: unknown;
   callables?: {
     createCheckout?: string;
@@ -67,14 +38,9 @@ export interface FirebaseAdapterConfig {
   };
 }
 
-/**
- * Firebase Billing Service
- * @description Implementation of PolarAdapter for Firebase Functions and Firestore.
- */
 export function createFirebaseAdapter(config: FirebaseAdapterConfig): PolarAdapter {
-  // Cast internally to Firebase types for implementation
-  const functions = config.functions as FirebaseFunctions;
-  const firestore = config.firestore as FirebaseFirestore;
+  const functions = config.functions;
+  const firestore = config.firestore;
 
   const callables = {
     createCheckout: config.callables?.createCheckout ?? 'createCheckoutSession',
@@ -95,30 +61,28 @@ export function createFirebaseAdapter(config: FirebaseAdapterConfig): PolarAdapt
     currentPeriodEnd: config.db?.currentPeriodEndField ?? 'currentPeriodEnd',
   };
 
-  // Cache imports to avoid repeated dynamic import overhead
-  // Reduces latency on subsequent calls and GC pressure
-  let httpsCallableCache: typeof import('firebase/functions')['httpsCallable'] | null = null;
-  let firestoreCache: { doc: any; getDoc: any } | null = null;
+  let httpsCallableCache: HttpsCallable | null = null;
+  let firestoreCache: { doc: FirestoreDoc; getDoc: FirestoreGetDoc } | null = null;
 
-  async function getHttpsCallable() {
+  async function getHttpsCallable(): Promise<HttpsCallable> {
     if (!httpsCallableCache) {
       const mod = await import('firebase/functions');
-      httpsCallableCache = mod.httpsCallable;
+      httpsCallableCache = mod.httpsCallable(functions) as HttpsCallable;
     }
     return httpsCallableCache;
   }
 
-  async function getFirestore() {
+  async function getFirestore(): Promise<{ doc: FirestoreDoc; getDoc: FirestoreGetDoc }> {
     if (!firestoreCache) {
       const mod = await import('firebase/firestore');
-      firestoreCache = { doc: mod.doc, getDoc: mod.getDoc };
+      firestoreCache = { doc: mod.doc as FirestoreDoc, getDoc: mod.getDoc as FirestoreGetDoc };
     }
     return firestoreCache;
   }
 
   async function callable<T = unknown, R = unknown>(name: string, data?: T): Promise<R> {
     const httpsCallable = await getHttpsCallable();
-    const fn = (httpsCallable as any)(functions, name) as (data?: T) => Promise<{ data: R }>;
+    const fn = httpsCallable(name) as (data?: T) => Promise<{ data: R }>;
     const result = await fn(data);
     return result.data;
   }
@@ -126,13 +90,15 @@ export function createFirebaseAdapter(config: FirebaseAdapterConfig): PolarAdapt
   return {
     async getStatus(userId: string): Promise<SubscriptionStatus> {
       const { doc, getDoc } = await getFirestore();
-      const snap = await getDoc((doc as any)(firestore, db.collection, userId));
+      const docRef = doc(firestore, db.collection, userId);
+      const snap = await getDoc(docRef);
 
-      if (!snap.exists()) {
+      const exists = (snap as { exists: boolean }).exists;
+      if (!exists) {
         return { plan: 'free', subscriptionStatus: 'none' };
       }
 
-      const d = snap.data() as Record<string, unknown>;
+      const d = snap.data();
 
       let currentPeriodEnd: string | undefined;
       const rawEnd = d[db.currentPeriodEnd];
@@ -159,14 +125,14 @@ export function createFirebaseAdapter(config: FirebaseAdapterConfig): PolarAdapt
       return callable<CheckoutParams, CheckoutResult>(callables.createCheckout, params);
     },
 
-    async syncSubscription(_userId: string, _checkoutId?: string): Promise<SyncResult> {
-      return callable<Record<string, never>, SyncResult>(callables.sync, {});
+    async syncSubscription(userId: string, checkoutId?: string): Promise<SyncResult> {
+      return callable<{ userId: string; checkoutId?: string }, SyncResult>(callables.sync, { userId, checkoutId });
     },
 
-    async getBillingHistory(_userId: string): Promise<OrderItem[]> {
-      const result = await callable<Record<string, never>, { orders?: OrderItem[] }>(
+    async getBillingHistory(userId: string): Promise<OrderItem[]> {
+      const result = await callable<{ userId: string }, { orders?: OrderItem[] }>(
         callables.billing,
-        {},
+        { userId },
       );
       return result.orders ?? [];
     },
@@ -175,14 +141,12 @@ export function createFirebaseAdapter(config: FirebaseAdapterConfig): PolarAdapt
       return callable<{ reason?: string }, CancelResult>(callables.cancel, { reason });
     },
 
-    async getPortalUrl(_userId: string): Promise<string> {
-      const result = await callable<Record<string, never>, { url?: string; customerPortalUrl?: string }>(
+    async getPortalUrl(userId: string): Promise<string> {
+      const result = await callable<{ userId: string }, { url: string }>(
         callables.portal,
-        {},
+        { userId },
       );
-      const url = result.url ?? result.customerPortalUrl;
-      if (!url) throw new Error('No portal URL returned from Cloud Function');
-      return url;
+      return result.url;
     },
   };
 }

package/src/infrastructure/utils/firebase-helpers.util.ts

@@ -0,0 +1,18 @@
+export function asString(value: unknown): string | undefined {
+  if (typeof value === 'string') return value;
+  return undefined;
+}
+
+export function asBoolean(value: unknown): boolean | undefined {
+  if (typeof value === 'boolean') return value;
+  return undefined;
+}
+
+export function isTimestamp(value: unknown): value is { toDate(): Date } {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'toDate' in value &&
+    'function' === typeof (value as { toDate?: unknown }).toDate
+  );
+}

package/src/infrastructure/utils/normalization.util.ts

@@ -1,33 +1,23 @@
 import type { SubscriptionStatusValue, BillingCycle } from '../../domain/entities';
+import { SUBSCRIPTION_STATUS } from '../constants/billing.constants';
 
-// Static map outside function scope - created once, reused forever
-// Reduces GC pressure from repeated object allocations
-const STATUS_MAP: Readonly<Record<string, SubscriptionStatusValue>> = {
-  active: 'active',
-  trialing: 'trialing',
-  past_due: 'past_due',
-  incomplete: 'incomplete',
-  incomplete_expired: 'incomplete_expired',
-  unpaid: 'unpaid',
-  canceled: 'canceled',
-  cancelled: 'canceled',
-  revoked: 'revoked',
-  none: 'none',
-};
+const STATUS_MAP: Readonly<Record<string, SubscriptionStatusValue>> = Object.freeze({
+  [SUBSCRIPTION_STATUS.ACTIVE]: SUBSCRIPTION_STATUS.ACTIVE,
+  [SUBSCRIPTION_STATUS.CANCELED]: SUBSCRIPTION_STATUS.CANCELED,
+  [SUBSCRIPTION_STATUS.REVOKED]: SUBSCRIPTION_STATUS.REVOKED,
+  [SUBSCRIPTION_STATUS.TRIALING]: SUBSCRIPTION_STATUS.TRIALING,
+  [SUBSCRIPTION_STATUS.PAST_DUE]: SUBSCRIPTION_STATUS.PAST_DUE,
+  [SUBSCRIPTION_STATUS.INCOMPLETE]: SUBSCRIPTION_STATUS.INCOMPLETE,
+  [SUBSCRIPTION_STATUS.INCOMPLETE_EXPIRED]: SUBSCRIPTION_STATUS.INCOMPLETE_EXPIRED,
+  [SUBSCRIPTION_STATUS.UNPAID]: SUBSCRIPTION_STATUS.UNPAID,
+  [SUBSCRIPTION_STATUS.NONE]: SUBSCRIPTION_STATUS.NONE,
+});
 
-/**
- * Normalize a raw Polar status string to a known value.
- * @description Defaults to 'none' for unknown statuses or non-string input.
- */
 export function normalizeStatus(raw: string): SubscriptionStatusValue {
-  if (typeof raw !== 'string') return 'none';
+  if (raw == null || typeof raw !== 'string') return 'none';
   return STATUS_MAP[raw.toLowerCase()] ?? 'none';
 }
 
-/**
- * Normalize billing interval
- * @description Maps 'month'/'year' to 'monthly'/'yearly'. Defaults to 'monthly' for unknown values or non-string input.
- */
 export function normalizeBillingCycle(interval: string): BillingCycle {
   if (typeof interval !== 'string') return 'monthly';
   const normalized = interval.toLowerCase();

package/src/infrastructure/utils/validations.util.ts

@@ -0,0 +1,17 @@
+export function normalizeUserId(userId: string | undefined): string | undefined {
+  if (typeof userId !== 'string') return undefined;
+  const trimmed = userId.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+export function isValidProductId(productId: unknown): productId is string {
+  return typeof productId === 'string' && productId.trim().length > 0;
+}
+
+export function isValidCheckoutUrl(url: string): boolean {
+  return url.startsWith('https://') || url.startsWith('http://');
+}
+
+export function isProductionInsecureUrl(url: string): boolean {
+  return url.startsWith('http://') && !url.includes('localhost') && !url.includes('127.0.0.1');
+}

package/src/presentation/components/PolarProvider.tsx

@@ -16,11 +16,7 @@ import type {
   OrderItem,
 } from '../../domain/entities';
 import { PolarContext } from '../hooks/usePolarBilling';
-
-/**
- * PolarProvider Component
- * @description Context provider for Polar billing management.
- */
+import { normalizeUserId, isValidProductId, isValidCheckoutUrl, isProductionInsecureUrl } from '../../infrastructure/utils/validations.util';
 
 interface PolarProviderProps {
   adapter: PolarAdapter;
@@ -33,28 +29,19 @@ const FREE_STATUS: SubscriptionStatus = {
   subscriptionStatus: 'none',
 };
 
-function normalizeUserId(userId: string | undefined): string | undefined {
-  if (typeof userId !== 'string') return undefined;
-  const trimmed = userId.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
 export function PolarProvider({ adapter, userId, children }: PolarProviderProps) {
   const [status, setStatus] = useState<SubscriptionStatus>(FREE_STATUS);
   const [loading, setLoading] = useState(true);
 
-  // Store adapter and setters in refs to create stable callbacks
   const adapterRef = useRef(adapter);
   const statusRef = useRef({ setStatus, setLoading });
   const userIdRef = useRef(normalizeUserId(userId));
-  const refreshAbortRef = useRef<AbortController | null>(null);
+  const refreshMountedRef = useRef(true);
 
-  // Keep refs in sync
   adapterRef.current = adapter;
   statusRef.current = { setStatus, setLoading };
   userIdRef.current = normalizeUserId(userId);
 
-  // Stable refresh function with no dependencies - prevents cascading re-renders
   const refresh = useCallback(async () => {
     const uid = userIdRef.current;
     const { setStatus, setLoading } = statusRef.current;
@@ -65,37 +52,45 @@ export function PolarProvider({ adapter, userId, children }: PolarProviderProps)
       return;
     }
 
-    refreshAbortRef.current?.abort();
-    const ctrl = new AbortController();
-    refreshAbortRef.current = ctrl;
+    refreshMountedRef.current = true;
 
     try {
       setLoading(true);
       const s = await adapterRef.current.getStatus(uid);
-      if (!ctrl.signal.aborted) setStatus(s);
+      if (refreshMountedRef.current) setStatus(s);
     } catch (err) {
-      if (!ctrl.signal.aborted) {
-        console.error('[polar-billing] getStatus failed:', err);
+      if (refreshMountedRef.current) {
         setStatus(FREE_STATUS);
       }
     } finally {
-      if (!ctrl.signal.aborted) setLoading(false);
+      if (refreshMountedRef.current) setLoading(false);
     }
-  }, []); // No dependencies - completely stable
+  }, []);
 
   useEffect(() => {
+    refreshMountedRef.current = true;
     refresh();
-    return () => { refreshAbortRef.current?.abort(); };
-  }, [refresh]); // Only re-run if refresh identity changes (never)
+    return () => { refreshMountedRef.current = false; };
+  }, [userId]);
 
   const startCheckout = useCallback(async (params: CheckoutParams) => {
+    if (!isValidProductId(params.productId)) {
+      throw new Error('[polar-billing] Invalid productId: must be a non-empty string');
+    }
+
     const uid = userIdRef.current;
     const result = await adapterRef.current.createCheckout({ ...params, userId: uid ?? undefined });
-    if (!result.url.startsWith('https://')) {
-      throw new Error('[polar-billing] Invalid checkout URL returned: URL must start with https://');
+
+    if (!isValidCheckoutUrl(result.url)) {
+      throw new Error('[polar-billing] Invalid checkout URL returned: URL must start with https:// or http://');
+    }
+
+    if (isProductionInsecureUrl(result.url)) {
+      throw new Error('[polar-billing] ERROR: Using insecure http:// URL in production environment');
     }
+
     window.location.href = result.url;
-  }, []); // No dependencies - stable
+  }, []);
 
   const syncSubscription = useCallback(async (): Promise<SyncResult> => {
     const uid = userIdRef.current;
@@ -105,13 +100,13 @@ export function PolarProvider({ adapter, userId, children }: PolarProviderProps)
     const result = await adapterRef.current.syncSubscription(uid, checkoutId);
     if (result.synced) await refresh();
     return result;
-  }, [refresh]); // Only depends on stable refresh
+  }, [refresh]);
 
   const getBillingHistory = useCallback(async (): Promise<OrderItem[]> => {
     const uid = userIdRef.current;
     if (!uid) return [];
     return adapterRef.current.getBillingHistory(uid);
-  }, []); // No dependencies - stable
+  }, []);
 
   const cancelSubscription = useCallback(
     async (reason?: CancellationReason): Promise<CancelResult> => {
@@ -119,17 +114,15 @@ export function PolarProvider({ adapter, userId, children }: PolarProviderProps)
       if (result.success) await refresh();
       return result;
     },
-    [refresh], // Only depends on stable refresh
+    [refresh],
   );
 
   const getPortalUrl = useCallback(async (): Promise<string> => {
     const uid = userIdRef.current;
     if (!uid) throw new Error('[polar-billing] Cannot get portal URL: No authenticated user');
     return adapterRef.current.getPortalUrl(uid);
-  }, []); // No dependencies - stable
+  }, []);
 
-  // Memoized context value - only recreates when status/loading changes
-  // All functions are stable, so they don't trigger re-creation
   const value = useMemo(
     () => ({
       status,
@@ -141,7 +134,7 @@ export function PolarProvider({ adapter, userId, children }: PolarProviderProps)
       cancelSubscription,
       getPortalUrl,
     }),
-    [status, loading, refresh, syncSubscription], // startCheckout, getBillingHistory, cancelSubscription, getPortalUrl are stable
+    [status, loading, refresh, syncSubscription],
   );
 
   return <PolarContext.Provider value={value}>{children}</PolarContext.Provider>;

package/src/presentation/hooks/usePolarBilling.ts

@@ -21,14 +21,8 @@ export interface PolarContextValue {
 
 export const PolarContext = createContext<PolarContextValue | undefined>(undefined);
 
-/**
- * usePolarBilling Hook
- * @description Hook to access Polar billing context
- */
 export function usePolarBilling(): PolarContextValue {
   const ctx = useContext(PolarContext);
   if (!ctx) throw new Error('usePolarBilling must be used within <PolarProvider>');
   return ctx;
 }
-
-export const useSubscription = usePolarBilling;

package/src/presentation/index.ts

@@ -1,7 +1,2 @@
-/**
- * Presentation Layer
- * Subpath: @umituz/web-polar-payment/presentation
- */
-
 export * from './components/PolarProvider';
 export * from './hooks/usePolarBilling';