@umituz/web-firebase 2.1.1 → 3.0.0

package/dist/infrastructure/index.js

@@ -1,856 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/infrastructure/index.ts
-var infrastructure_exports = {};
-__export(infrastructure_exports, {
-  AuthAdapter: () => AuthAdapter,
-  FirestoreAdapter: () => FirestoreAdapter,
-  StorageAdapter: () => StorageAdapter,
-  analytics: () => analytics,
-  app: () => app,
-  auth: () => auth,
-  db: () => db,
-  deleteFile: () => deleteFile,
-  functions: () => functions,
-  getFirebaseAnalytics: () => getFirebaseAnalytics,
-  getFirebaseApp: () => getFirebaseApp,
-  getFirebaseAuth: () => getFirebaseAuth,
-  getFirebaseDB: () => getFirebaseDB,
-  getFirebaseFunctions: () => getFirebaseFunctions,
-  getFirebaseInstances: () => getFirebaseInstances,
-  getFirebaseStorage: () => getFirebaseStorage,
-  initializeFirebase: () => initializeFirebase,
-  storage: () => storage,
-  uploadBase64: () => uploadBase64,
-  uploadFile: () => uploadFile
-});
-module.exports = __toCommonJS(infrastructure_exports);
-
-// src/infrastructure/firebase/client.ts
-var import_app = require("firebase/app");
-var import_auth = require("firebase/auth");
-var import_firestore = require("firebase/firestore");
-var import_storage = require("firebase/storage");
-var import_analytics = require("firebase/analytics");
-var import_functions = require("firebase/functions");
-var firebaseConfig = {
-  apiKey: process.env.VITE_FIREBASE_API_KEY,
-  authDomain: process.env.VITE_FIREBASE_AUTH_DOMAIN,
-  projectId: process.env.VITE_FIREBASE_PROJECT_ID,
-  storageBucket: process.env.VITE_FIREBASE_STORAGE_BUCKET,
-  messagingSenderId: process.env.VITE_FIREBASE_MESSAGING_SENDER_ID,
-  appId: process.env.VITE_FIREBASE_APP_ID,
-  measurementId: process.env.VITE_FIREBASE_MEASUREMENT_ID
-};
-var app;
-var auth;
-var db;
-var storage;
-var functions;
-var analytics = null;
-function initializeFirebase() {
-  if (!(0, import_app.getApps)().length) {
-    app = (0, import_app.initializeApp)(firebaseConfig);
-  } else {
-    app = (0, import_app.getApps)()[0];
-  }
-  return app;
-}
-function getFirebaseApp() {
-  return app || initializeFirebase();
-}
-function getFirebaseAuth() {
-  if (!auth) {
-    const firebaseApp = getFirebaseApp();
-    if (typeof window !== "undefined") {
-      try {
-        auth = (0, import_auth.getAuth)(firebaseApp);
-      } catch (e) {
-        console.warn("getAuth failed, trying initializeAuth...", e);
-        auth = (0, import_auth.initializeAuth)(firebaseApp, {
-          persistence: import_auth.browserLocalPersistence
-        });
-      }
-    } else {
-      auth = (0, import_auth.getAuth)(firebaseApp);
-    }
-  }
-  return auth;
-}
-function getFirebaseDB() {
-  if (!db) {
-    db = (0, import_firestore.getFirestore)(getFirebaseApp());
-  }
-  return db;
-}
-function getFirebaseStorage() {
-  if (!storage) {
-    storage = (0, import_storage.getStorage)(getFirebaseApp());
-  }
-  return storage;
-}
-function getFirebaseFunctions() {
-  if (!functions) {
-    functions = (0, import_functions.getFunctions)(getFirebaseApp());
-  }
-  return functions;
-}
-function getFirebaseAnalytics() {
-  if (!analytics && typeof window !== "undefined") {
-    analytics = (0, import_analytics.getAnalytics)(getFirebaseApp());
-  }
-  return analytics;
-}
-function getFirebaseInstances() {
-  return {
-    app: getFirebaseApp(),
-    auth: getFirebaseAuth(),
-    db: getFirebaseDB(),
-    storage: getFirebaseStorage(),
-    functions: getFirebaseFunctions(),
-    analytics: getFirebaseAnalytics()
-  };
-}
-
-// src/infrastructure/firebase/auth.adapter.ts
-var import_auth2 = require("firebase/auth");
-var import_auth3 = require("firebase/auth");
-
-// src/domain/errors/auth.errors.ts
-var AuthError = class extends Error {
-  constructor(message, code, originalError) {
-    super(message);
-    this.code = code;
-    this.originalError = originalError;
-    this.name = "AuthError";
-  }
-};
-function createAuthError(code, message, originalError) {
-  const defaultMessage = getAuthErrorMessage(code);
-  return new AuthError(message || defaultMessage, code, originalError);
-}
-function getAuthErrorMessage(code) {
-  switch (code) {
-    case "USER_NOT_FOUND" /* USER_NOT_FOUND */:
-      return "User not found";
-    case "USER_ALREADY_EXISTS" /* USER_ALREADY_EXISTS */:
-      return "User already exists";
-    case "INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */:
-      return "Invalid credentials";
-    case "WEAK_PASSWORD" /* WEAK_PASSWORD */:
-      return "Password is too weak";
-    case "EMAIL_NOT_VERIFIED" /* EMAIL_NOT_VERIFIED */:
-      return "Email not verified";
-    case "SESSION_EXPIRED" /* SESSION_EXPIRED */:
-      return "Session expired";
-    case "UNAUTHENTICATED" /* UNAUTHENTICATED */:
-      return "User not authenticated";
-    case "TOO_MANY_REQUESTS" /* TOO_MANY_REQUESTS */:
-      return "Too many requests";
-    case "OAUTH_ERROR" /* OAUTH_ERROR */:
-      return "OAuth error occurred";
-    case "OAUTH_CANCELLED" /* OAUTH_CANCELLED */:
-      return "OAuth cancelled by user";
-    case "OAUTH_ACCOUNT_EXISTS" /* OAUTH_ACCOUNT_EXISTS */:
-      return "Account already exists with this provider";
-    case "SIGN_IN_FAILED" /* SIGN_IN_FAILED */:
-      return "Sign in failed";
-    case "SIGN_UP_FAILED" /* SIGN_UP_FAILED */:
-      return "Sign up failed";
-    case "SIGN_OUT_FAILED" /* SIGN_OUT_FAILED */:
-      return "Sign out failed";
-    case "PASSWORD_RESET_FAILED" /* PASSWORD_RESET_FAILED */:
-      return "Password reset failed";
-    case "EMAIL_VERIFICATION_FAILED" /* EMAIL_VERIFICATION_FAILED */:
-      return "Email verification failed";
-    case "PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */:
-      return "Profile update failed";
-    case "EMAIL_UPDATE_FAILED" /* EMAIL_UPDATE_FAILED */:
-      return "Email update failed";
-    case "PASSWORD_UPDATE_FAILED" /* PASSWORD_UPDATE_FAILED */:
-      return "Password update failed";
-    case "ACCOUNT_DELETE_FAILED" /* ACCOUNT_DELETE_FAILED */:
-      return "Account deletion failed";
-    case "REAUTHENTICATION_REQUIRED" /* REAUTHENTICATION_REQUIRED */:
-      return "Reauthentication required";
-    case "REAUTHENTICATION_FAILED" /* REAUTHENTICATION_FAILED */:
-      return "Reauthentication failed";
-    case "UNKNOWN" /* UNKNOWN */:
-    default:
-      return "An unknown error occurred";
-  }
-}
-
-// src/infrastructure/firebase/auth.adapter.ts
-var AuthAdapter = class {
-  get auth() {
-    return getFirebaseAuth();
-  }
-  // Authentication Methods
-  async signIn(email, password) {
-    try {
-      return await (0, import_auth2.signInWithEmailAndPassword)(this.auth, email, password);
-    } catch (error) {
-      throw this.handleAuthError(error);
-    }
-  }
-  async signUp(email, password, displayName) {
-    try {
-      const result = await (0, import_auth2.createUserWithEmailAndPassword)(this.auth, email, password);
-      await (0, import_auth2.updateProfile)(result.user, { displayName });
-      await (0, import_auth2.sendEmailVerification)(result.user);
-      return result;
-    } catch (error) {
-      throw this.handleAuthError(error);
-    }
-  }
-  async signInWithGoogle() {
-    try {
-      const provider = new import_auth3.GoogleAuthProvider();
-      provider.addScope("profile");
-      provider.addScope("email");
-      return await (0, import_auth2.signInWithPopup)(this.auth, provider);
-    } catch (error) {
-      throw this.handleAuthError(error);
-    }
-  }
-  async signOut() {
-    try {
-      await (0, import_auth2.signOut)(this.auth);
-    } catch (error) {
-      throw createAuthError("SIGN_OUT_FAILED" /* SIGN_OUT_FAILED */, "Sign out failed", error);
-    }
-  }
-  async sendPasswordReset(email) {
-    try {
-      await (0, import_auth2.sendPasswordResetEmail)(this.auth, email);
-    } catch (error) {
-      throw this.handleAuthError(error);
-    }
-  }
-  async resendEmailVerification() {
-    try {
-      const user = this.auth.currentUser;
-      if (!user) {
-        throw createAuthError("UNAUTHENTICATED" /* UNAUTHENTICATED */, "No user logged in");
-      }
-      await (0, import_auth2.sendEmailVerification)(user);
-    } catch (error) {
-      throw createAuthError("EMAIL_VERIFICATION_FAILED" /* EMAIL_VERIFICATION_FAILED */, "Failed to resend verification", error);
-    }
-  }
-  // Profile Management
-  async updateProfile(updates) {
-    try {
-      const user = this.auth.currentUser;
-      if (!user) {
-        throw createAuthError("UNAUTHENTICATED" /* UNAUTHENTICATED */, "No user logged in");
-      }
-      await (0, import_auth2.updateProfile)(user, updates);
-    } catch (error) {
-      throw createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "Profile update failed", error);
-    }
-  }
-  async updateEmail(newEmail, password) {
-    try {
-      const user = this.auth.currentUser;
-      if (!user || !user.email) {
-        throw createAuthError("UNAUTHENTICATED" /* UNAUTHENTICATED */, "No user logged in");
-      }
-      const credential = import_auth2.EmailAuthProvider.credential(user.email, password);
-      await (0, import_auth2.reauthenticateWithCredential)(user, credential);
-      await (0, import_auth2.updateEmail)(user, newEmail);
-    } catch (error) {
-      throw createAuthError("EMAIL_UPDATE_FAILED" /* EMAIL_UPDATE_FAILED */, "Email update failed", error);
-    }
-  }
-  async updatePassword(currentPassword, newPassword) {
-    try {
-      const user = this.auth.currentUser;
-      if (!user || !user.email) {
-        throw createAuthError("UNAUTHENTICATED" /* UNAUTHENTICATED */, "No user logged in");
-      }
-      const credential = import_auth2.EmailAuthProvider.credential(user.email, currentPassword);
-      await (0, import_auth2.reauthenticateWithCredential)(user, credential);
-      await (0, import_auth2.updatePassword)(user, newPassword);
-    } catch (error) {
-      throw createAuthError("PASSWORD_UPDATE_FAILED" /* PASSWORD_UPDATE_FAILED */, "Password update failed", error);
-    }
-  }
-  async deleteAccount(password) {
-    try {
-      const user = this.auth.currentUser;
-      if (!user || !user.email) {
-        throw createAuthError("UNAUTHENTICATED" /* UNAUTHENTICATED */, "No user logged in");
-      }
-      const credential = import_auth2.EmailAuthProvider.credential(user.email, password);
-      await (0, import_auth2.reauthenticateWithCredential)(user, credential);
-      await user.delete();
-    } catch (error) {
-      throw createAuthError("ACCOUNT_DELETE_FAILED" /* ACCOUNT_DELETE_FAILED */, "Account deletion failed", error);
-    }
-  }
-  // State Management
-  getCurrentUser() {
-    return this.auth.currentUser;
-  }
-  onAuthStateChanged(callback) {
-    return this.auth.onAuthStateChanged(callback);
-  }
-  // Note: User document operations should be handled by UserAdapter
-  // These methods are part of IAuthRepository interface but should be implemented separately
-  async createUserDocument(_userId, _data) {
-    throw new Error("createUserDocument should be handled by UserAdapter");
-  }
-  async updateLastLogin(_userId) {
-    throw new Error("updateLastLogin should be handled by UserAdapter");
-  }
-  /**
-   * Handle Firebase Auth errors
-   */
-  handleAuthError(error) {
-    if (error instanceof Error && "code" in error) {
-      const code = error.code;
-      switch (code) {
-        case "auth/user-not-found":
-          return createAuthError("USER_NOT_FOUND" /* USER_NOT_FOUND */, "User not found", error);
-        case "auth/wrong-password":
-        case "auth/invalid-credential":
-          return createAuthError("INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */, "Invalid credentials", error);
-        case "auth/email-already-in-use":
-          return createAuthError("USER_ALREADY_EXISTS" /* USER_ALREADY_EXISTS */, "Email already in use", error);
-        case "auth/weak-password":
-          return createAuthError("WEAK_PASSWORD" /* WEAK_PASSWORD */, "Password is too weak", error);
-        case "auth/invalid-email":
-          return createAuthError("INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */, "Invalid email", error);
-        case "auth/user-disabled":
-          return createAuthError("USER_NOT_FOUND" /* USER_NOT_FOUND */, "Account disabled", error);
-        case "auth/too-many-requests":
-          return createAuthError("TOO_MANY_REQUESTS" /* TOO_MANY_REQUESTS */, "Too many requests", error);
-        case "auth/popup-closed-by-user":
-          return createAuthError("OAUTH_CANCELLED" /* OAUTH_CANCELLED */, "Sign in cancelled", error);
-        case "auth/account-exists-with-different-credential":
-          return createAuthError("OAUTH_ACCOUNT_EXISTS" /* OAUTH_ACCOUNT_EXISTS */, "Account exists with different provider", error);
-        case "auth/requires-recent-login":
-          return createAuthError("REAUTHENTICATION_REQUIRED" /* REAUTHENTICATION_REQUIRED */, "Please reauthenticate", error);
-        default:
-          return createAuthError("UNKNOWN" /* UNKNOWN */, `Auth error: ${code}`, error);
-      }
-    }
-    return createAuthError("UNKNOWN" /* UNKNOWN */, "Unknown auth error", error);
-  }
-};
-
-// src/infrastructure/firebase/firestore.adapter.ts
-var import_firestore2 = require("firebase/firestore");
-
-// src/domain/errors/repository.errors.ts
-var RepositoryError = class extends Error {
-  constructor(message, code, originalError) {
-    super(message);
-    this.code = code;
-    this.originalError = originalError;
-    this.name = "RepositoryError";
-  }
-};
-function createRepositoryError(code, message, originalError) {
-  const defaultMessage = getRepositoryErrorMessage(code);
-  return new RepositoryError(message || defaultMessage, code, originalError);
-}
-function getRepositoryErrorMessage(code) {
-  switch (code) {
-    case "DOCUMENT_NOT_FOUND" /* DOCUMENT_NOT_FOUND */:
-      return "Document not found";
-    case "DOCUMENT_ALREADY_EXISTS" /* DOCUMENT_ALREADY_EXISTS */:
-      return "Document already exists";
-    case "DOCUMENT_INVALID" /* DOCUMENT_INVALID */:
-      return "Document is invalid";
-    case "COLLECTION_NOT_FOUND" /* COLLECTION_NOT_FOUND */:
-      return "Collection not found";
-    case "COLLECTION_INVALID" /* COLLECTION_INVALID */:
-      return "Collection is invalid";
-    case "QUERY_INVALID" /* QUERY_INVALID */:
-      return "Query is invalid";
-    case "QUERY_FAILED" /* QUERY_FAILED */:
-      return "Query failed";
-    case "TRANSACTION_FAILED" /* TRANSACTION_FAILED */:
-      return "Transaction failed";
-    case "TRANSACTION_ABORTED" /* TRANSACTION_ABORTED */:
-      return "Transaction aborted";
-    case "NETWORK_ERROR" /* NETWORK_ERROR */:
-      return "Network error";
-    case "TIMEOUT" /* TIMEOUT */:
-      return "Request timeout";
-    case "OFFLINE" /* OFFLINE */:
-      return "Client is offline";
-    case "PERMISSION_DENIED" /* PERMISSION_DENIED */:
-      return "Permission denied";
-    case "UNAUTHORIZED" /* UNAUTHORIZED */:
-      return "Unauthorized";
-    case "VALIDATION_FAILED" /* VALIDATION_FAILED */:
-      return "Validation failed";
-    case "INVALID_DATA" /* INVALID_DATA */:
-      return "Invalid data";
-    case "CONFLICT" /* CONFLICT */:
-      return "Conflict occurred";
-    case "VERSION_MISMATCH" /* VERSION_MISMATCH */:
-      return "Version mismatch";
-    case "STORAGE_ERROR" /* STORAGE_ERROR */:
-      return "Storage error";
-    case "FILE_NOT_FOUND" /* FILE_NOT_FOUND */:
-      return "File not found";
-    case "FILE_TOO_LARGE" /* FILE_TOO_LARGE */:
-      return "File is too large";
-    case "INVALID_FILE_TYPE" /* INVALID_FILE_TYPE */:
-      return "Invalid file type";
-    case "UNKNOWN" /* UNKNOWN */:
-    default:
-      return "An unknown error occurred";
-  }
-}
-
-// src/infrastructure/firebase/firestore.adapter.ts
-var FirestoreAdapter = class {
-  get db() {
-    return getFirebaseDB();
-  }
-  USERS_COLLECTION = "users";
-  async getUser(userId) {
-    try {
-      const docRef = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
-      const snap = await (0, import_firestore2.getDoc)(docRef);
-      if (!snap.exists()) {
-        return null;
-      }
-      return snap.data();
-    } catch (error) {
-      throw createRepositoryError("DOCUMENT_NOT_FOUND" /* DOCUMENT_NOT_FOUND */, "User not found", error);
-    }
-  }
-  async getUserByEmail(email) {
-    try {
-      const q = (0, import_firestore2.query)((0, import_firestore2.collection)(this.db, this.USERS_COLLECTION), (0, import_firestore2.where)("profile.email", "==", email));
-      const snap = await (0, import_firestore2.getDocs)(q);
-      if (snap.empty) {
-        return null;
-      }
-      const doc2 = snap.docs[0];
-      return doc2.data();
-    } catch (error) {
-      throw createRepositoryError("QUERY_FAILED" /* QUERY_FAILED */, "Failed to query user", error);
-    }
-  }
-  async createUser(userId, data) {
-    try {
-      const docRef = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
-      await (0, import_firestore2.setDoc)(docRef, data, { merge: true });
-    } catch (error) {
-      throw createRepositoryError("DOCUMENT_INVALID" /* DOCUMENT_INVALID */, "Failed to create user", error);
-    }
-  }
-  async updateUser(userId, data) {
-    try {
-      const docRef = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
-      await (0, import_firestore2.updateDoc)(docRef, {
-        ...data,
-        "profile.updatedAt": Date.now()
-      });
-    } catch (error) {
-      throw createRepositoryError("DOCUMENT_NOT_FOUND" /* DOCUMENT_NOT_FOUND */, "Failed to update user", error);
-    }
-  }
-  async deleteUser(userId) {
-    try {
-      const docRef = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
-      await (0, import_firestore2.deleteDoc)(docRef);
-    } catch (error) {
-      throw createRepositoryError("DOCUMENT_NOT_FOUND" /* DOCUMENT_NOT_FOUND */, "Failed to delete user", error);
-    }
-  }
-  async updateProfile(userId, updates) {
-    try {
-      const docRef = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
-      const updateData = {
-        "profile.updatedAt": Date.now()
-      };
-      if (updates.displayName !== void 0) {
-        updateData["profile.displayName"] = updates.displayName;
-      }
-      if (updates.photoURL !== void 0) {
-        updateData["profile.photoURL"] = updates.photoURL;
-      }
-      if (updates.phoneNumber !== void 0) {
-        updateData["profile.phoneNumber"] = updates.phoneNumber;
-      }
-      await (0, import_firestore2.updateDoc)(docRef, updateData);
-    } catch (error) {
-      throw createRepositoryError("DOCUMENT_NOT_FOUND" /* DOCUMENT_NOT_FOUND */, "Failed to update profile", error);
-    }
-  }
-  async updateSettings(userId, settings) {
-    try {
-      const docRef = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
-      await (0, import_firestore2.updateDoc)(docRef, {
-        settings: {
-          ...settings,
-          updatedAt: Date.now()
-        }
-      });
-    } catch (error) {
-      throw createRepositoryError("DOCUMENT_NOT_FOUND" /* DOCUMENT_NOT_FOUND */, "Failed to update settings", error);
-    }
-  }
-  async updateSubscription(userId, subscription) {
-    try {
-      const docRef = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
-      await (0, import_firestore2.updateDoc)(docRef, {
-        subscription: {
-          ...subscription,
-          updatedAt: Date.now()
-        }
-      });
-    } catch (error) {
-      throw createRepositoryError("DOCUMENT_NOT_FOUND" /* DOCUMENT_NOT_FOUND */, "Failed to update subscription", error);
-    }
-  }
-  async updateLastLogin(userId) {
-    try {
-      const docRef = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
-      await (0, import_firestore2.updateDoc)(docRef, {
-        "profile.lastLoginAt": Date.now()
-      });
-    } catch (error) {
-      throw createRepositoryError("DOCUMENT_NOT_FOUND" /* DOCUMENT_NOT_FOUND */, "Failed to update last login", error);
-    }
-  }
-  async queryUsers(constraints) {
-    try {
-      const q = (0, import_firestore2.query)((0, import_firestore2.collection)(this.db, this.USERS_COLLECTION), ...constraints);
-      const snap = await (0, import_firestore2.getDocs)(q);
-      return snap.docs.map((doc2) => doc2.data());
-    } catch (error) {
-      throw createRepositoryError("QUERY_FAILED" /* QUERY_FAILED */, "Failed to query users", error);
-    }
-  }
-  subscribeToUser(userId, callback, onError) {
-    const docRef = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
-    const unsubscribe = (0, import_firestore2.onSnapshot)(
-      docRef,
-      (snap) => {
-        if (snap.exists()) {
-          callback(snap.data());
-        } else {
-          callback(null);
-        }
-      },
-      (error) => {
-        onError?.(error);
-      }
-    );
-    return unsubscribe;
-  }
-};
-
-// src/infrastructure/firebase/storage.adapter.ts
-var import_storage2 = require("firebase/storage");
-var StorageAdapter = class {
-  get storage() {
-    return getFirebaseStorage();
-  }
-  // Upload Methods
-  async uploadFile(userId, path, file, options) {
-    const storageRef = (0, import_storage2.ref)(this.storage, `users/${userId}/${path}`);
-    const uploadTask = (0, import_storage2.uploadBytesResumable)(storageRef, file);
-    return new Promise((resolve, reject) => {
-      uploadTask.on(
-        "state_changed",
-        (snapshot) => {
-          if (options?.onProgress) {
-            const progress = {
-              bytesTransferred: snapshot.bytesTransferred,
-              totalBytes: snapshot.totalBytes,
-              progress: snapshot.bytesTransferred / snapshot.totalBytes * 100,
-              state: "running"
-            };
-            options.onProgress(progress);
-          }
-        },
-        (error) => reject(createRepositoryError("STORAGE_ERROR" /* STORAGE_ERROR */, "Upload failed", error)),
-        async () => {
-          const downloadURL = await (0, import_storage2.getDownloadURL)(uploadTask.snapshot.ref);
-          const metadata = await (0, import_storage2.getMetadata)(uploadTask.snapshot.ref);
-          resolve({
-            id: uploadTask.snapshot.ref.name,
-            name: metadata.name || uploadTask.snapshot.ref.name,
-            fullPath: metadata.fullPath || uploadTask.snapshot.ref.fullPath,
-            downloadURL,
-            contentType: metadata.contentType || "",
-            size: metadata.size || 0,
-            createdAt: metadata.timeCreated ? new Date(metadata.timeCreated).getTime() : Date.now()
-          });
-        }
-      );
-    });
-  }
-  async uploadImage(userId, file, filename) {
-    const name = filename || `${Date.now()}_${file.name}`;
-    return this.uploadFile(userId, `images/${name}`, file);
-  }
-  async uploadVideo(userId, file, filename) {
-    const name = filename || `${Date.now()}_${file.name}`;
-    return this.uploadFile(userId, `videos/${name}`, file);
-  }
-  async uploadDocument(userId, file, filename) {
-    const name = filename || `${Date.now()}_${file.name}`;
-    return this.uploadFile(userId, `documents/${name}`, file);
-  }
-  async uploadProfilePicture(userId, file) {
-    const storageRef = (0, import_storage2.ref)(this.storage, `users/${userId}/profile/${Date.now()}_${file.name}`);
-    await (0, import_storage2.uploadBytes)(storageRef, file);
-    const downloadURL = await (0, import_storage2.getDownloadURL)(storageRef);
-    return {
-      id: storageRef.name,
-      name: file.name,
-      fullPath: storageRef.fullPath,
-      downloadURL,
-      contentType: file.type,
-      size: file.size,
-      createdAt: Date.now()
-    };
-  }
-  // Download Methods
-  async getDownloadURL(path) {
-    try {
-      const storageRef = (0, import_storage2.ref)(this.storage, path);
-      return await (0, import_storage2.getDownloadURL)(storageRef);
-    } catch (error) {
-      throw createRepositoryError("FILE_NOT_FOUND" /* FILE_NOT_FOUND */, "File not found", error);
-    }
-  }
-  // Delete Methods
-  async deleteFile(path) {
-    try {
-      const storageRef = (0, import_storage2.ref)(this.storage, path);
-      await (0, import_storage2.deleteObject)(storageRef);
-    } catch (error) {
-      throw createRepositoryError("FILE_NOT_FOUND" /* FILE_NOT_FOUND */, "File not found", error);
-    }
-  }
-  async deleteUserFiles(userId) {
-    try {
-      const userRef = (0, import_storage2.ref)(this.storage, `users/${userId}`);
-      const result = await (0, import_storage2.listAll)(userRef);
-      for (const prefix of result.prefixes) {
-        const prefixResult = await (0, import_storage2.listAll)(prefix);
-        await Promise.all(prefixResult.items.map((item) => (0, import_storage2.deleteObject)(item)));
-      }
-      await Promise.all(result.items.map((item) => (0, import_storage2.deleteObject)(item)));
-    } catch (error) {
-      throw createRepositoryError("STORAGE_ERROR" /* STORAGE_ERROR */, "Failed to delete user files", error);
-    }
-  }
-  async deleteImage(userId, filename) {
-    await this.deleteFile(`users/${userId}/images/${filename}`);
-  }
-  async deleteVideo(userId, filename) {
-    await this.deleteFile(`users/${userId}/videos/${filename}`);
-  }
-  async deleteProfilePicture(userId, filename) {
-    await this.deleteFile(`users/${userId}/profile/${filename}`);
-  }
-  // List Methods
-  async listUserFiles(userId, path) {
-    const userRef = (0, import_storage2.ref)(this.storage, path ? `users/${userId}/${path}` : `users/${userId}`);
-    const result = await (0, import_storage2.listAll)(userRef);
-    const urls = await Promise.all(result.items.map((item) => (0, import_storage2.getDownloadURL)(item)));
-    return urls;
-  }
-  async listUserImages(userId) {
-    return this.listUserFiles(userId, "images");
-  }
-  async listUserVideos(userId) {
-    return this.listUserFiles(userId, "videos");
-  }
-  // Metadata
-  async getFileMetadata(path) {
-    try {
-      const storageRef = (0, import_storage2.ref)(this.storage, path);
-      const metadata = await (0, import_storage2.getMetadata)(storageRef);
-      return {
-        id: storageRef.name,
-        name: metadata.name,
-        fullPath: metadata.fullPath,
-        contentType: metadata.contentType || "application/octet-stream",
-        size: metadata.size,
-        createdAt: metadata.timeCreated ? new Date(metadata.timeCreated).getTime() : Date.now(),
-        updatedAt: metadata.updated ? new Date(metadata.updated).getTime() : Date.now(),
-        userId: this.extractUserId(path) || "unknown",
-        type: this.extractFileType(metadata.contentType || "")
-      };
-    } catch (error) {
-      throw createRepositoryError("FILE_NOT_FOUND" /* FILE_NOT_FOUND */, "File not found", error);
-    }
-  }
-  async queryFiles(userId, _filters) {
-    const userRef = (0, import_storage2.ref)(this.storage, `users/${userId}`);
-    const result = await (0, import_storage2.listAll)(userRef);
-    const files = await Promise.all(
-      result.items.map(async (item) => {
-        const metadata = await (0, import_storage2.getMetadata)(item);
-        return {
-          id: item.name,
-          name: metadata.name,
-          fullPath: metadata.fullPath,
-          contentType: metadata.contentType || "application/octet-stream",
-          size: metadata.size,
-          createdAt: metadata.timeCreated ? new Date(metadata.timeCreated).getTime() : Date.now(),
-          updatedAt: metadata.updated ? new Date(metadata.updated).getTime() : Date.now(),
-          userId,
-          type: this.extractFileType(metadata.contentType || "")
-        };
-      })
-    );
-    return {
-      files,
-      totalCount: files.length,
-      hasMore: false
-    };
-  }
-  async getStorageStats(userId) {
-    const { files, totalCount } = await this.queryFiles(userId);
-    const stats = {
-      totalFiles: totalCount,
-      totalSize: files.reduce((sum, file) => sum + file.size, 0),
-      filesByType: {
-        image: 0,
-        video: 0,
-        audio: 0,
-        document: 0,
-        other: 0
-      },
-      filesByCategory: {
-        profile: 0,
-        content: 0,
-        document: 0,
-        attachment: 0,
-        backup: 0
-      }
-    };
-    files.forEach((file) => {
-      stats.filesByType[file.type]++;
-      stats.lastUploadAt = Math.max(stats.lastUploadAt || 0, file.createdAt);
-    });
-    return stats;
-  }
-  // Validation
-  validateFile(file, options) {
-    const maxSizeBytes = options?.maxSizeBytes || (options?.maxSizeMB ? options.maxSizeMB * 1024 * 1024 : 10 * 1024 * 1024);
-    if (file.size > maxSizeBytes) {
-      return false;
-    }
-    if (options?.allowedTypes && !options.allowedTypes.includes(file.type)) {
-      return false;
-    }
-    return true;
-  }
-  isImageFile(file) {
-    return file.type.startsWith("image/");
-  }
-  isVideoFile(file) {
-    return file.type.startsWith("video/");
-  }
-  isDocumentFile(file) {
-    const docTypes = [
-      "application/pdf",
-      "application/msword",
-      "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-      "application/vnd.ms-excel",
-      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-      "text/plain"
-    ];
-    return docTypes.includes(file.type);
-  }
-  // Utility Methods
-  generateUniqueFilename(originalName) {
-    const timestamp = Date.now();
-    const random = Math.random().toString(36).substring(2, 8);
-    const extension = this.getFileExtension(originalName);
-    return `${timestamp}_${random}.${extension}`;
-  }
-  getFileExtension(filename) {
-    return filename.slice((filename.lastIndexOf(".") - 1 >>> 0) + 2);
-  }
-  // Helper Methods
-  extractUserId(path) {
-    const match = path.match(/users\/([^\/]+)/);
-    return match ? match[1] : "";
-  }
-  extractFileType(contentType) {
-    if (contentType.startsWith("image/")) return "image";
-    if (contentType.startsWith("video/")) return "video";
-    if (contentType.startsWith("audio/")) return "audio";
-    if (contentType.includes("pdf") || contentType.includes("document") || contentType.includes("text")) {
-      return "document";
-    }
-    return "other";
-  }
-};
-
-// src/infrastructure/utils/storage.util.ts
-var import_storage3 = require("firebase/storage");
-async function uploadFile(storage2, path, file) {
-  const storageRef = (0, import_storage3.ref)(storage2, path);
-  await (0, import_storage3.uploadBytes)(storageRef, file);
-  const url = await (0, import_storage3.getDownloadURL)(storageRef);
-  return { url, path };
-}
-async function uploadBase64(storage2, path, base64, mimeType = "image/jpeg") {
-  const storageRef = (0, import_storage3.ref)(storage2, path);
-  const dataUrl = base64.startsWith("data:") ? base64 : `data:${mimeType};base64,${base64}`;
-  await (0, import_storage3.uploadString)(storageRef, dataUrl, "data_url");
-  const url = await (0, import_storage3.getDownloadURL)(storageRef);
-  return { url, path };
-}
-async function deleteFile(storage2, path) {
-  await (0, import_storage3.deleteObject)((0, import_storage3.ref)(storage2, path));
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AuthAdapter,
-  FirestoreAdapter,
-  StorageAdapter,
-  analytics,
-  app,
-  auth,
-  db,
-  deleteFile,
-  functions,
-  getFirebaseAnalytics,
-  getFirebaseApp,
-  getFirebaseAuth,
-  getFirebaseDB,
-  getFirebaseFunctions,
-  getFirebaseInstances,
-  getFirebaseStorage,
-  initializeFirebase,
-  storage,
-  uploadBase64,
-  uploadFile
-});