@umituz/web-firebase 1.0.4 → 2.0.1

package/dist/infrastructure/index.js

@@ -0,0 +1,856 @@
+"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
+});