@umituz/web-firebase 1.0.5 → 2.1.0

package/dist/chunk-U2XI4MGO.mjs

@@ -0,0 +1,397 @@
+import {
+  createAuthError
+} from "./chunk-RZ4QR6TB.mjs";
+
+// src/application/use-cases/auth/sign-in.use-case.ts
+var SignInUseCase = class {
+  constructor(authRepository) {
+    this.authRepository = authRepository;
+  }
+  /**
+   * Execute sign in use case
+   */
+  async execute(dto) {
+    try {
+      this.validateDTO(dto);
+      const result = await this.authRepository.signIn(dto.email, dto.password);
+      return result;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+  /**
+   * Validate DTO
+   */
+  validateDTO(dto) {
+    if (!dto.email) {
+      throw createAuthError("INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */, "Email is required");
+    }
+    if (!dto.password) {
+      throw createAuthError("INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */, "Password is required");
+    }
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!emailRegex.test(dto.email)) {
+      throw createAuthError("INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */, "Invalid email format");
+    }
+  }
+  /**
+   * Handle errors
+   */
+  handleError(error) {
+    if (error instanceof Error) {
+      const message = error.message.toLowerCase();
+      if (message.includes("user-not-found") || message.includes("invalid-email")) {
+        return createAuthError("USER_NOT_FOUND" /* USER_NOT_FOUND */, "User not found", error);
+      }
+      if (message.includes("wrong-password") || message.includes("invalid-credential")) {
+        return createAuthError("INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */, "Invalid credentials", error);
+      }
+      if (message.includes("too-many-requests")) {
+        return createAuthError("TOO_MANY_REQUESTS" /* TOO_MANY_REQUESTS */, "Too many attempts", error);
+      }
+      if (message.includes("user-disabled")) {
+        return createAuthError("USER_NOT_FOUND" /* USER_NOT_FOUND */, "Account disabled", error);
+      }
+    }
+    return createAuthError("SIGN_IN_FAILED" /* SIGN_IN_FAILED */, "Sign in failed", error);
+  }
+};
+
+// src/application/use-cases/auth/sign-up.use-case.ts
+var SignUpUseCase = class {
+  constructor(authRepository, userRepository) {
+    this.authRepository = authRepository;
+    this.userRepository = userRepository;
+  }
+  /**
+   * Execute sign up use case
+   */
+  async execute(dto) {
+    try {
+      this.validateDTO(dto);
+      const existingUser = await this.userRepository.getUserByEmail(dto.email);
+      if (existingUser) {
+        throw createAuthError("USER_ALREADY_EXISTS" /* USER_ALREADY_EXISTS */, "User already exists");
+      }
+      const result = await this.authRepository.signUp(dto.email, dto.password, dto.displayName);
+      return {
+        ...result,
+        userId: result.user.uid,
+        emailVerified: result.user.emailVerified
+      };
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+  /**
+   * Validate DTO
+   */
+  validateDTO(dto) {
+    if (!dto.email) {
+      throw createAuthError("SIGN_UP_FAILED" /* SIGN_UP_FAILED */, "Email is required");
+    }
+    if (!dto.password) {
+      throw createAuthError("SIGN_UP_FAILED" /* SIGN_UP_FAILED */, "Password is required");
+    }
+    if (!dto.displayName || dto.displayName.trim().length === 0) {
+      throw createAuthError("SIGN_UP_FAILED" /* SIGN_UP_FAILED */, "Display name is required");
+    }
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!emailRegex.test(dto.email)) {
+      throw createAuthError("SIGN_UP_FAILED" /* SIGN_UP_FAILED */, "Invalid email format");
+    }
+    if (dto.password.length < 6) {
+      throw createAuthError("WEAK_PASSWORD" /* WEAK_PASSWORD */, "Password must be at least 6 characters");
+    }
+  }
+  /**
+   * Handle errors
+   */
+  handleError(error) {
+    if (error instanceof Error && "code" in error) {
+      const code = error.code;
+      if (code === "auth/email-already-in-use") {
+        return createAuthError("USER_ALREADY_EXISTS" /* USER_ALREADY_EXISTS */, "Email already in use", error);
+      }
+      if (code === "auth/invalid-email") {
+        return createAuthError("SIGN_UP_FAILED" /* SIGN_UP_FAILED */, "Invalid email", error);
+      }
+      if (code === "auth/weak-password") {
+        return createAuthError("WEAK_PASSWORD" /* WEAK_PASSWORD */, "Password is too weak", error);
+      }
+      if (code === "auth/operation-not-allowed") {
+        return createAuthError("SIGN_UP_FAILED" /* SIGN_UP_FAILED */, "Email/password accounts not enabled", error);
+      }
+    }
+    return createAuthError("SIGN_UP_FAILED" /* SIGN_UP_FAILED */, "Sign up failed", error);
+  }
+};
+
+// src/application/use-cases/auth/sign-in-with-google.use-case.ts
+var SignInWithGoogleUseCase = class {
+  constructor(authRepository, userRepository) {
+    this.authRepository = authRepository;
+    this.userRepository = userRepository;
+  }
+  /**
+   * Execute Google sign in use case
+   */
+  async execute() {
+    try {
+      const result = await this.authRepository.signInWithGoogle();
+      const existingUser = await this.userRepository.getUser(result.user.uid);
+      if (!existingUser) {
+        const createUserDTO = {
+          id: result.user.uid,
+          email: result.user.email || "",
+          displayName: result.user.displayName || "",
+          photoURL: result.user.photoURL || void 0,
+          phoneNumber: result.user.phoneNumber || void 0,
+          emailVerified: result.user.emailVerified
+        };
+        await this.authRepository.createUserDocument(result.user.uid, createUserDTO);
+      }
+      return result;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+  /**
+   * Handle errors
+   */
+  handleError(error) {
+    if (error instanceof Error && "code" in error) {
+      const code = error.code;
+      if (code === "auth/popup-closed-by-user") {
+        return createAuthError("OAUTH_CANCELLED" /* OAUTH_CANCELLED */, "Google sign in cancelled", error);
+      }
+      if (code === "auth/popup-blocked") {
+        return createAuthError("OAUTH_ERROR" /* OAUTH_ERROR */, "Popup blocked by browser", error);
+      }
+      if (code === "auth/account-exists-with-different-credential") {
+        return createAuthError(
+          "OAUTH_ACCOUNT_EXISTS" /* OAUTH_ACCOUNT_EXISTS */,
+          "Account already exists with different credential",
+          error
+        );
+      }
+      if (code === "auth/auth-domain-policy-required") {
+        return createAuthError("OAUTH_ERROR" /* OAUTH_ERROR */, "Auth domain not configured", error);
+      }
+      if (code === "auth/unauthorized-domain") {
+        return createAuthError("OAUTH_ERROR" /* OAUTH_ERROR */, "Unauthorized domain", error);
+      }
+      if (code === "auth/cancelled-popup-request") {
+        return createAuthError("OAUTH_CANCELLED" /* OAUTH_CANCELLED */, "Sign in cancelled", error);
+      }
+    }
+    return createAuthError("OAUTH_ERROR" /* OAUTH_ERROR */, "Google sign in failed", error);
+  }
+};
+
+// src/application/use-cases/auth/reset-password.use-case.ts
+var ResetPasswordUseCase = class {
+  constructor(authRepository) {
+    this.authRepository = authRepository;
+  }
+  /**
+   * Execute password reset use case
+   */
+  async execute(dto) {
+    try {
+      this.validateDTO(dto);
+      await this.authRepository.sendPasswordReset(dto.email);
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+  /**
+   * Validate DTO
+   */
+  validateDTO(dto) {
+    if (!dto.email) {
+      throw createAuthError("PASSWORD_RESET_FAILED" /* PASSWORD_RESET_FAILED */, "Email is required");
+    }
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!emailRegex.test(dto.email)) {
+      throw createAuthError("PASSWORD_RESET_FAILED" /* PASSWORD_RESET_FAILED */, "Invalid email format");
+    }
+  }
+  /**
+   * Handle errors
+   */
+  handleError(error) {
+    if (error instanceof Error && "code" in error) {
+      const code = error.code;
+      if (code === "auth/invalid-email") {
+        return createAuthError("PASSWORD_RESET_FAILED" /* PASSWORD_RESET_FAILED */, "Invalid email", error);
+      }
+      if (code === "auth/user-not-found") {
+        return createAuthError("PASSWORD_RESET_FAILED" /* PASSWORD_RESET_FAILED */, "Password reset email sent if account exists");
+      }
+      if (code === "auth/too-many-requests") {
+        return createAuthError("TOO_MANY_REQUESTS" /* TOO_MANY_REQUESTS */, "Too many requests", error);
+      }
+    }
+    return createAuthError("PASSWORD_RESET_FAILED" /* PASSWORD_RESET_FAILED */, "Password reset failed", error);
+  }
+};
+
+// src/application/use-cases/auth/sign-out.use-case.ts
+var SignOutUseCase = class {
+  constructor(authRepository) {
+    this.authRepository = authRepository;
+  }
+  /**
+   * Execute sign out use case
+   */
+  async execute() {
+    try {
+      await this.authRepository.signOut();
+    } catch (error) {
+      throw createAuthError("SIGN_OUT_FAILED" /* SIGN_OUT_FAILED */, "Sign out failed", error);
+    }
+  }
+};
+
+// src/application/use-cases/user/update-profile.use-case.ts
+var UpdateProfileUseCase = class {
+  constructor(authRepository) {
+    this.authRepository = authRepository;
+  }
+  /**
+   * Execute profile update use case
+   */
+  async execute(dto) {
+    try {
+      this.validateDTO(dto);
+      const currentUser = this.authRepository.getCurrentUser();
+      if (!currentUser) {
+        throw createAuthError("UNAUTHENTICATED" /* UNAUTHENTICATED */, "No user logged in");
+      }
+      await this.authRepository.updateProfile(dto);
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+  /**
+   * Validate DTO
+   */
+  validateDTO(dto) {
+    if (!dto.displayName && !dto.photoURL) {
+      throw createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "At least one field must be provided");
+    }
+    if (dto.displayName !== void 0) {
+      if (typeof dto.displayName !== "string") {
+        throw createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "Display name must be a string");
+      }
+      if (dto.displayName.trim().length === 0) {
+        throw createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "Display name cannot be empty");
+      }
+      if (dto.displayName.length > 100) {
+        throw createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "Display name too long (max 100 characters)");
+      }
+    }
+    if (dto.photoURL !== void 0 && dto.photoURL !== null) {
+      if (typeof dto.photoURL !== "string") {
+        throw createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "Photo URL must be a string");
+      }
+      if (dto.photoURL && !this.isValidURL(dto.photoURL)) {
+        throw createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "Invalid photo URL");
+      }
+    }
+  }
+  /**
+   * Validate URL format
+   */
+  isValidURL(url) {
+    try {
+      new URL(url);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Handle errors
+   */
+  handleError(error) {
+    if (error instanceof Error && "code" in error) {
+      const code = error.code;
+      if (code === "auth/requires-recent-login") {
+        return createAuthError("REAUTHENTICATION_REQUIRED" /* REAUTHENTICATION_REQUIRED */, "Please reauthenticate first", error);
+      }
+      if (code === "auth/invalid-photo-url") {
+        return createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "Invalid photo URL", error);
+      }
+    }
+    return createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "Profile update failed", error);
+  }
+};
+
+// src/application/use-cases/user/delete-account.use-case.ts
+var DeleteAccountUseCase = class {
+  constructor(authRepository) {
+    this.authRepository = authRepository;
+  }
+  /**
+   * Execute account deletion use case
+   */
+  async execute(dto) {
+    try {
+      this.validateDTO(dto);
+      const currentUser = this.authRepository.getCurrentUser();
+      if (!currentUser) {
+        throw createAuthError("UNAUTHENTICATED" /* UNAUTHENTICATED */, "No user logged in");
+      }
+      if (!currentUser.email) {
+        throw createAuthError("ACCOUNT_DELETE_FAILED" /* ACCOUNT_DELETE_FAILED */, "User email not available");
+      }
+      await this.authRepository.deleteAccount(dto.password);
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+  /**
+   * Validate DTO
+   */
+  validateDTO(dto) {
+    if (!dto.password) {
+      throw createAuthError("ACCOUNT_DELETE_FAILED" /* ACCOUNT_DELETE_FAILED */, "Password is required");
+    }
+    if (dto.password.length < 1) {
+      throw createAuthError("ACCOUNT_DELETE_FAILED" /* ACCOUNT_DELETE_FAILED */, "Password cannot be empty");
+    }
+  }
+  /**
+   * Handle errors
+   */
+  handleError(error) {
+    if (error instanceof Error && "code" in error) {
+      const code = error.code;
+      if (code === "auth/requires-recent-login") {
+        return createAuthError("REAUTHENTICATION_REQUIRED" /* REAUTHENTICATION_REQUIRED */, "Please reauthenticate first", error);
+      }
+      if (code === "auth/wrong-password") {
+        return createAuthError("REAUTHENTICATION_FAILED" /* REAUTHENTICATION_FAILED */, "Invalid password", error);
+      }
+      if (code === "auth/too-many-requests") {
+        return createAuthError("TOO_MANY_REQUESTS" /* TOO_MANY_REQUESTS */, "Too many requests", error);
+      }
+      if (code === "auth/user-not-found") {
+        return createAuthError("ACCOUNT_DELETE_FAILED" /* ACCOUNT_DELETE_FAILED */, "User not found", error);
+      }
+    }
+    return createAuthError("ACCOUNT_DELETE_FAILED" /* ACCOUNT_DELETE_FAILED */, "Account deletion failed", error);
+  }
+};
+
+export {
+  SignInUseCase,
+  SignUpUseCase,
+  SignInWithGoogleUseCase,
+  ResetPasswordUseCase,
+  SignOutUseCase,
+  UpdateProfileUseCase,
+  DeleteAccountUseCase
+};