@umituz/react-native-firebase 2.4.83 → 2.4.84

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "2.4.83",
+  "version": "2.4.84",
   "description": "Unified Firebase package for React Native apps - Auth and Firestore services using Firebase JS SDK (no native modules).",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/domains/auth/domain/utils/user-metadata.util.ts

@@ -67,6 +67,10 @@ export function isNewUser(input: UserCredential | User | UserMetadata): boolean
   }
 
   // Convert to timestamps for reliable comparison
-  // If creation time === last sign in time, this is the first sign-in
-  return new Date(creationTime).getTime() === new Date(lastSignInTime).getTime();
+  // If creation time === last sign in time (within 2 seconds tolerance), this is the first sign-in
+  // Tolerance handles Firebase timestamp inconsistencies across different auth providers
+  const creationTimestamp = new Date(creationTime).getTime();
+  const lastSignInTimestamp = new Date(lastSignInTime).getTime();
+  const TOLERANCE_MS = 2000; // 2 second tolerance for timestamp inconsistencies
+  return Math.abs(creationTimestamp - lastSignInTimestamp) <= TOLERANCE_MS;
 }

package/src/domains/auth/domain/utils/user-validation.util.ts

@@ -42,7 +42,7 @@ export function validateUserUnchanged(
   const currentUserId = auth?.currentUser?.uid;
 
   if (currentUserId !== originalUserId) {
-    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+    if (__DEV__) {
       console.log(
         `[validateUserUnchanged] User changed during operation. Original: ${originalUserId}, Current: ${currentUserId || 'none'}`
       );

package/src/domains/auth/infrastructure/services/apple-auth.service.ts

@@ -14,8 +14,8 @@ import { Platform } from "react-native";
 import { generateNonce, hashNonce } from "./crypto.util";
 import type { AppleAuthResult } from "./apple-auth.types";
 import {
-  isCancellationError,
-} from "./base/base-auth.service";
+  isCancelledError,
+} from "../../../../shared/domain/utils/error-handlers/error-checkers";
 import { executeAuthOperation, type Result } from "../../../../shared/domain/utils";
 import { isNewUser as checkIsNewUser } from "../../domain/utils/user-metadata.util";
 import { convertToOAuthResult } from "./utils/auth-result-converter.util";
@@ -121,7 +121,7 @@ export class AppleAuthService {
     try {
       return await this.signIn(auth);
     } catch (error) {
-      if (isCancellationError(error)) {
+      if (isCancelledError(error)) {
         return {
           success: false,
           error: "Apple Sign-In was cancelled",

package/src/domains/auth/infrastructure/services/crypto.util.ts

@@ -9,7 +9,16 @@ const NONCE_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456
 
 export async function generateNonce(length: number = 32): Promise<string> {
   const bytes = await Crypto.getRandomBytesAsync(length);
-  return Array.from(bytes).map(b => NONCE_CHARS.charAt(b % NONCE_CHARS.length)).join("");
+  const charsLength = NONCE_CHARS.length;
+  const result: string[] = [];
+
+  // Optimized: Single pass with direct character access
+  for (let i = 0; i < length; i++) {
+    const charIndex = bytes[i]! % charsLength; // Non-null assertion: index is always valid
+    result.push(NONCE_CHARS[charIndex]!); // Non-null assertion: charIndex is always within bounds
+  }
+
+  return result.join('');
 }
 
 export async function hashNonce(nonce: string): Promise<string> {

package/src/domains/auth/infrastructure/services/password.service.ts

@@ -4,7 +4,21 @@
  */
 
 import { updatePassword, type User } from 'firebase/auth';
-import { executeAuthOperation, type Result } from '../../../../shared/domain/utils';
+import { executeAuthOperation, type Result, ERROR_MESSAGES } from '../../../../shared/domain/utils';
+
+/**
+ * Validate password meets Firebase minimum requirements
+ * Firebase requires minimum 6 characters
+ */
+function validatePassword(password: string): void {
+  if (typeof password !== 'string') {
+    throw new Error(ERROR_MESSAGES.AUTH.INVALID_PASSWORD);
+  }
+  const trimmed = password.trim();
+  if (trimmed.length < 6) {
+    throw new Error(ERROR_MESSAGES.AUTH.WEAK_PASSWORD);
+  }
+}
 
 /**
  * Update the current user's password
@@ -12,6 +26,7 @@ import { executeAuthOperation, type Result } from '../../../../shared/domain/uti
  */
 export async function updateUserPassword(user: User, newPassword: string): Promise<Result<void>> {
   return executeAuthOperation(async () => {
+    validatePassword(newPassword);
     await updatePassword(user, newPassword);
   });
 }

package/src/domains/auth/infrastructure/services/user-document-builder.util.ts

@@ -17,7 +17,7 @@ function hasProviderData(user: unknown): user is { providerData: { providerId: s
     typeof user === 'object' &&
     user !== null &&
     'providerData' in user &&
-    Array.isArray((user as Record<string, unknown>).providerData)
+    Array.isArray((user as { providerData: unknown }).providerData)
   );
 }
 
@@ -54,15 +54,14 @@ export function buildBaseData(
   };
 
   if (extras) {
-    const internalFields = ["signUpMethod", "previousAnonymousUserId"];
-    Object.keys(extras).forEach((key) => {
-      if (!internalFields.includes(key)) {
-        const val = extras[key];
-        if (val !== undefined) {
-          data[key] = val;
-        }
+    const internalFields = new Set(["signUpMethod", "previousAnonymousUserId"]);
+    // Optimized: Single pass through extras, avoid multiple lookups
+    for (const [key, val] of Object.entries(extras)) {
+      // Skip internal fields (handled separately)
+      if (val !== undefined && !internalFields.has(key)) {
+        data[key] = val;
       }
-    });
+    }
   }
 
   return data;

package/src/domains/auth/infrastructure/services/user-document.service.ts

@@ -58,14 +58,14 @@ export async function ensureUserDocument(
     const historyEntry = buildLoginHistoryEntry(user, allExtras);
     const historyRef = collection(db, collectionName, user.uid, "loginHistory");
     addDoc(historyRef, historyEntry).catch((err) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
+      if (__DEV__) {
         console.warn("[UserDocumentService] Failed to write login history:", err);
       }
     });
 
     return true;
   } catch (error) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
+    if (__DEV__) {
       console.error("[UserDocumentService] Failed:", error);
     }
     return false;
@@ -85,7 +85,7 @@ export async function markUserDeleted(userId: string): Promise<boolean> {
     }, { merge: true });
     return true;
   } catch (error) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
+    if (__DEV__) {
       console.error("[UserDocumentService] Failed to mark user deleted:", error);
     }
     return false;

package/src/domains/auth/infrastructure/services/utils/auth-result-converter.util.ts

@@ -62,11 +62,11 @@ export function convertToOAuthResult(
       success: true,
       userCredential: result.data.userCredential,
       isNewUser: result.data.isNewUser,
-    } as OAuthAuthSuccessResult;
+    };
   }
   return {
     success: false,
     error: result.error?.message ?? defaultErrorMessage,
     code: result.error?.code,
-  } as OAuthAuthErrorResult;
+  };
 }

package/src/domains/auth/presentation/hooks/useGoogleOAuth.ts

@@ -4,7 +4,7 @@
  * This hook is optional and requires expo-auth-session to be installed
  */
 
-import { useState, useCallback, useEffect, useRef } from "react";
+import { useState, useCallback, useEffect, useRef, useMemo } from "react";
 import { googleOAuthService } from "../../infrastructure/services/google-oauth.service";
 import { getFirebaseAuth } from "../../infrastructure/config/FirebaseAuthClient";
 import type { GoogleOAuthConfig } from "../../infrastructure/services/google-oauth.service";
@@ -55,8 +55,9 @@ export function useGoogleOAuth(config?: GoogleOAuthConfig): UseGoogleOAuthResult
   const [isLoading, setIsLoading] = useState(false);
   const [googleError, setGoogleError] = useState<string | null>(null);
 
-  const googleAvailable = googleOAuthService.isAvailable();
-  const googleConfigured = googleOAuthService.isConfigured(config);
+  // Memoize service checks to avoid repeated calls on every render
+  const googleAvailable = useMemo(() => googleOAuthService.isAvailable(), []);
+  const googleConfigured = useMemo(() => googleOAuthService.isConfigured(config), [config]);
 
   // Keep config in a ref so the response useEffect doesn't re-run when config object reference changes
   const configRef = useRef(config);
@@ -86,7 +87,7 @@ export function useGoogleOAuth(config?: GoogleOAuthConfig): UseGoogleOAuthResult
           const auth = getFirebaseAuth();
           if (!auth) {
             setGoogleError("Firebase Auth not initialized");
-            setIsLoading(false); // FIX: Reset loading state before early return
+            setIsLoading(false);
             return;
           }
 
@@ -104,11 +105,16 @@ export function useGoogleOAuth(config?: GoogleOAuthConfig): UseGoogleOAuthResult
         }
       } else if (response.type === "error") {
         setGoogleError("Google authentication failed");
-        setIsLoading(false);
       }
     };
 
-    handleResponse();
+    // Call async function and catch errors separately
+    handleResponse().catch((err) => {
+      // Errors are already handled in handleResponse
+      if (__DEV__) {
+        console.error('[useGoogleOAuth] Unexpected error in handleResponse:', err);
+      }
+    });
   }, [response, googleAvailable]); // config read via ref to prevent re-running on reference changes
 
   const signInWithGoogle = useCallback(async (): Promise<SocialAuthResult> => {

package/src/domains/auth/presentation/hooks/useSocialAuth.ts

@@ -35,18 +35,16 @@ export function useSocialAuth(config?: SocialAuthConfig): UseSocialAuthResult {
   const [appleAvailable, setAppleAvailable] = useState(false);
 
   // Stabilize config objects to prevent unnecessary re-renders and effect re-runs
-  const googleConfig = useMemo(() => config?.google, [
-    config?.google?.webClientId,
-    config?.google?.iosClientId,
-    config?.google?.androidClientId,
-  ]);
+  // Use full object as dependency instead of individual properties
+  const googleConfig = useMemo(() => config?.google, [config?.google]);
   const appleEnabled = useMemo(() => config?.apple?.enabled, [config?.apple?.enabled]);
 
-  const googleConfigured = !!(
+  // Memoize configured check to avoid recalculation on every render
+  const googleConfigured = useMemo(() => !!(
     googleConfig?.webClientId ||
     googleConfig?.iosClientId ||
     googleConfig?.androidClientId
-  );
+  ), [googleConfig]);
 
   useEffect(() => {
     if (googleConfig) {

package/src/domains/firestore/index.ts

@@ -141,15 +141,14 @@ export {
 } from './utils/validation/date-validator.util';
 
 // Presentation — TanStack Query integration
-export {
-  useFirestoreQuery,
-  useFirestoreMutation,
-  useFirestoreSnapshot,
-  createFirestoreKeys,
-  type UseFirestoreQueryOptions,
-  type UseFirestoreMutationOptions,
-  type UseFirestoreSnapshotOptions,
-} from './presentation';
+export { useFirestoreQuery } from './presentation/hooks/useFirestoreQuery';
+export { useFirestoreMutation } from './presentation/hooks/useFirestoreMutation';
+export { useFirestoreSnapshot } from './presentation/hooks/useFirestoreSnapshot';
+export { createFirestoreKeys } from './presentation/query-keys/createFirestoreKeys';
+
+export type { UseFirestoreQueryOptions } from './presentation/hooks/useFirestoreQuery';
+export type { UseFirestoreMutationOptions } from './presentation/hooks/useFirestoreMutation';
+export type { UseFirestoreSnapshotOptions } from './presentation/hooks/useFirestoreSnapshot';
 
 export { Timestamp } from 'firebase/firestore';
 export type {

package/src/domains/firestore/infrastructure/middleware/QueryDeduplicationMiddleware.ts

@@ -51,9 +51,8 @@ export class QueryDeduplicationMiddleware {
       try {
         return await queryFn();
       } finally {
-        // Cleanup after completion (success or error)
-        // Note: PendingQueryManager also has cleanup via finally, but we keep
-        // this for extra safety and immediate cleanup
+        // Immediate cleanup after completion (success or error)
+        // PendingQueryManager will also cleanup via its finally handler
         this.queryManager.remove(key);
       }
     })();

package/src/domains/firestore/infrastructure/services/RequestLoggerService.ts

@@ -4,12 +4,23 @@
  */
 
 import type { RequestLog, RequestStats, RequestType } from '../../domain/entities/RequestLog';
-import { generateUniqueId } from '../../../../shared/domain/utils/id-generator.util';
+import { generateUUID } from '@umituz/react-native-design-system/uuid';
+
+/**
+ * Maximum number of logs to keep in memory
+ * Prevents unbounded memory growth
+ */
+export const DEFAULT_MAX_LOGS = 1000;
 
 export class RequestLoggerService {
   private logs: RequestLog[] = [];
-  private readonly MAX_LOGS = 1000;
+  private readonly maxLogs: number;
   private listeners: Set<(log: RequestLog) => void> = new Set();
+  private static readonly LISTENER_ERROR_PREFIX = '[RequestLoggerService] Listener error:';
+
+  constructor(maxLogs: number = DEFAULT_MAX_LOGS) {
+    this.maxLogs = maxLogs;
+  }
 
   /**
    * Log a request
@@ -17,13 +28,13 @@ export class RequestLoggerService {
   logRequest(log: Omit<RequestLog, 'id' | 'timestamp'>): void {
     const fullLog: RequestLog = {
       ...log,
-      id: generateUniqueId(),
+      id: generateUUID(),
       timestamp: Date.now(),
     };
 
     this.logs.push(fullLog);
 
-    if (this.logs.length > this.MAX_LOGS) {
+    if (this.logs.length > this.maxLogs) {
       this.logs.shift();
     }
 
@@ -39,40 +50,62 @@ export class RequestLoggerService {
 
   /**
    * Get logs by type
+   * Optimized: Return empty array early if no logs
    */
   getLogsByType(type: RequestType): RequestLog[] {
+    if (this.logs.length === 0) return [];
     return this.logs.filter((log) => log.type === type);
   }
 
   /**
    * Get request statistics
+   * Optimized: Single-pass calculation O(n) instead of O(7n)
    */
   getStats(): RequestStats {
-    const totalRequests = this.logs.length;
-    const readRequests = this.logs.filter((l) => l.type === 'read').length;
-    const writeRequests = this.logs.filter((l) => l.type === 'write').length;
-    const deleteRequests = this.logs.filter((l) => l.type === 'delete').length;
-    const listenerRequests = this.logs.filter((l) => l.type === 'listener').length;
-    const cachedRequests = this.logs.filter((l) => l.cached).length;
-    const failedRequests = this.logs.filter((l) => !l.success).length;
-
-    const durations = this.logs
-      .map((l) => l.duration)
-      .filter((d): d is number => d !== undefined);
-    const averageDuration =
-      durations.length > 0
-        ? durations.reduce((sum, d) => sum + d, 0) / durations.length
-        : 0;
+    let readRequests = 0;
+    let writeRequests = 0;
+    let deleteRequests = 0;
+    let listenerRequests = 0;
+    let cachedRequests = 0;
+    let failedRequests = 0;
+    let durationSum = 0;
+    let durationCount = 0;
+
+    // Single pass through logs for all statistics
+    for (const log of this.logs) {
+      switch (log.type) {
+        case 'read':
+          readRequests++;
+          break;
+        case 'write':
+          writeRequests++;
+          break;
+        case 'delete':
+          deleteRequests++;
+          break;
+        case 'listener':
+          listenerRequests++;
+          break;
+      }
+
+      if (log.cached) cachedRequests++;
+      if (!log.success) failedRequests++;
+
+      if (log.duration !== undefined) {
+        durationSum += log.duration;
+        durationCount++;
+      }
+    }
 
     return {
-      totalRequests,
+      totalRequests: this.logs.length,
       readRequests,
       writeRequests,
       deleteRequests,
       listenerRequests,
       cachedRequests,
       failedRequests,
-      averageDuration,
+      averageDuration: durationCount > 0 ? durationSum / durationCount : 0,
     };
   }
 
@@ -116,8 +149,13 @@ export class RequestLoggerService {
     this.listeners.forEach((listener) => {
       try {
         listener(log);
-      } catch {
-        // Silently ignore listener errors
+      } catch (error) {
+        // Log listener errors in development to help debugging
+        // In production, silently ignore to prevent crashing the app
+        if (__DEV__) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          console.warn(`${RequestLoggerService.LISTENER_ERROR_PREFIX} ${errorMessage}`);
+        }
       }
     });
   }

package/src/domains/firestore/presentation/hooks/useFirestoreSnapshot.ts

@@ -47,6 +47,7 @@ export function useFirestoreSnapshot<TData>(
   const queryClient = useQueryClient();
   const unsubscribeRef = useRef<(() => void) | null>(null);
   const dataPromiseRef = useRef<{ resolve: (value: TData) => void; reject: (error: Error) => void } | null>(null);
+  const timeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
 
   // Stabilize queryKey to prevent unnecessary listener re-subscriptions
   const stableKeyString = JSON.stringify(queryKey);
@@ -57,10 +58,14 @@ export function useFirestoreSnapshot<TData>(
 
     unsubscribeRef.current = subscribe((data) => {
       queryClient.setQueryData(stableQueryKey, data);
-      // Resolve any pending promise from queryFn
+      // Resolve any pending promise from queryFn and clear timeout
       if (dataPromiseRef.current) {
         dataPromiseRef.current.resolve(data);
         dataPromiseRef.current = null;
+        if (timeoutRef.current) {
+          clearTimeout(timeoutRef.current);
+          timeoutRef.current = null;
+        }
       }
     });
 
@@ -72,6 +77,11 @@ export function useFirestoreSnapshot<TData>(
         dataPromiseRef.current.reject(new Error('Snapshot listener cleanup'));
         dataPromiseRef.current = null;
       }
+      // Clear timeout on cleanup
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+        timeoutRef.current = null;
+      }
     };
   }, [enabled, queryClient, stableQueryKey, subscribe]);
 
@@ -89,9 +99,10 @@ export function useFirestoreSnapshot<TData>(
         dataPromiseRef.current = { resolve, reject };
 
         // Timeout to prevent infinite waiting (memory leak protection)
-        const timeoutId = setTimeout(() => {
+        timeoutRef.current = setTimeout(() => {
           if (dataPromiseRef.current) {
             dataPromiseRef.current = null;
+            timeoutRef.current = null;
             if (initialData !== undefined) {
               resolve(initialData);
             } else {
@@ -99,9 +110,6 @@ export function useFirestoreSnapshot<TData>(
             }
           }
         }, 30000); // 30 second timeout
-
-        // Clear timeout on promise resolution
-        return () => clearTimeout(timeoutId);
       });
     },
     enabled,

package/src/domains/firestore/utils/deduplication/pending-query-manager.util.ts

@@ -46,17 +46,15 @@ export class PendingQueryManager {
    * Also attaches cleanup handlers to prevent memory leaks.
    */
   add(key: string, promise: Promise<unknown>): void {
-    // Attach cleanup handlers to ensure promise is removed from map
+    // Attach cleanup handler to ensure query is removed from map
     // even if caller's finally block doesn't execute (e.g., unhandled rejection)
-    const cleanupPromise = promise.finally(() => {
-      // Small delay to allow immediate retry if needed
-      setTimeout(() => {
-        this.pendingQueries.delete(key);
-      }, 100);
+    promise.finally(() => {
+      // Immediate cleanup - no delay needed for better performance
+      this.pendingQueries.delete(key);
     });
 
     this.pendingQueries.set(key, {
-      promise: cleanupPromise,
+      promise,
       timestamp: Date.now(),
     });
   }

package/src/domains/firestore/utils/pagination.helper.ts

@@ -44,13 +44,13 @@ export class PaginationHelper<T> {
     const resultCount = getResultCount(items.length, pageLimit);
     const resultItems = safeSlice(items, 0, resultCount);
 
-    // Safe access: check array is not empty before accessing last item
+    // Extract next cursor from last item
+    // Safe: resultItems is guaranteed to have at least one item when hasMoreValue is true
     let nextCursor: string | null = null;
     if (hasMoreValue && resultItems.length > 0) {
-      const lastItem = resultItems[resultItems.length - 1];
-      if (lastItem) {
-        nextCursor = getCursor(lastItem);
-      }
+      // Access is safe because we checked length > 0
+      const lastItem = resultItems[resultItems.length - 1]!;
+      nextCursor = getCursor(lastItem);
     }
 
     return {

package/src/domains/firestore/utils/query/filters.util.ts

@@ -11,26 +11,7 @@ import {
   type WhereFilterOp,
   type Query,
 } from "firebase/firestore";
-
-/**
- * Chunk array into smaller arrays (local copy for this module)
- * Inlined here to avoid circular dependencies
- */
-function chunkArray(array: readonly (string | number)[], chunkSize: number): (string | number)[][] {
-  if (chunkSize <= 0) {
-    throw new Error('chunkSize must be greater than 0');
-  }
-
-  const chunks: (string | number)[][] = [];
-  const len = array.length;
-
-  for (let i = 0; i < len; i += chunkSize) {
-    const end = Math.min(i + chunkSize, len);
-    chunks.push(array.slice(i, end));
-  }
-
-  return chunks;
-}
+import { chunkArray } from "../../../../shared/domain/utils/calculation.util";
 
 export interface FieldFilter {
   field: string;
@@ -38,7 +19,11 @@ export interface FieldFilter {
   value: string | number | boolean | string[] | number[];
 }
 
-const MAX_IN_OPERATOR_VALUES = 10;
+/**
+ * Maximum number of values in a single 'in' query
+ * Firestore limits 'in' queries to 10 values
+ */
+export const MAX_IN_OPERATOR_VALUES = 10;
 
 /**
  * Apply field filter with 'in' operator and chunking support
@@ -53,8 +38,8 @@ export function applyFieldFilter(q: Query, filter: FieldFilter): Query {
     }
 
     // Split into chunks of 10 and use 'or' operator
-    // Optimized: Uses local chunkArray utility
-    const chunks = chunkArray(value, MAX_IN_OPERATOR_VALUES);
+    // Optimized: Uses centralized chunkArray utility
+    const chunks = chunkArray(value as readonly (string | number)[], MAX_IN_OPERATOR_VALUES);
     const orConditions = chunks.map((chunk) => where(field, "in", chunk));
     return query(q, or(...orConditions));
   }

package/src/shared/domain/utils/error-handlers/error-checkers.ts

@@ -33,10 +33,13 @@ const RETRYABLE_ERROR_CODES = ['unavailable', 'deadline-exceeded', 'aborted'];
 /**
  * Check if error is a cancelled/auth cancelled error
  */
-export function isCancelledError(error: { code: string; message: string }): boolean {
+export function isCancelledError(error: unknown): boolean {
+  if (!error || typeof error !== 'object') return false;
+  if (!('code' in error) || !('message' in error)) return false;
+  const err = error as { code: string; message: string };
   return (
-    error.code === 'auth/cancelled' ||
-    error.message.includes('ERR_CANCELED')
+    err.code === 'auth/cancelled' ||
+    err.message.includes('ERR_CANCELED')
   );
 }
 

package/src/domains/auth/infrastructure/services/base/base-auth.service.ts

@@ -1,15 +0,0 @@
-/**
- * Base Auth Service
- *
- * Provides common authentication service functionality
- */
-
-/**
- * Check if error is a cancellation error
- */
-export function isCancellationError(error: unknown): boolean {
-  if (error instanceof Error) {
-    return error.message.includes('ERR_CANCELED');
-  }
-  return false;
-}

package/src/domains/firestore/presentation/index.ts

@@ -1,2 +0,0 @@
-export * from './hooks';
-export * from './query-keys';

package/src/shared/domain/utils/id-generator.util.ts

@@ -1,17 +0,0 @@
-/**
- * ID Generator Utility
- * Centralized ID generation utilities for unique identifiers
- */
-
-import * as Crypto from "expo-crypto";
-
-/**
- * Generate a unique ID using timestamp and cryptographically secure random string
- * Format: timestamp-randomstring
- * @returns Unique identifier string
- */
-export function generateUniqueId(): string {
-  const randomBytes = Crypto.getRandomBytes(8);
-  const hex = Array.from(randomBytes).map(b => b.toString(16).padStart(2, "0")).join("");
-  return `${Date.now()}-${hex}`;
-}