strapi-plugin-firebase-authentication 1.1.8 → 1.1.10

package/dist/server/index.js

@@ -199,8 +199,8 @@ const bootstrap = async ({ strapi: strapi2 }) => {
     }
   } catch (error2) {
     strapi2.log.error("Firebase initialization failed during bootstrap:");
-    strapi2.log.error("   Error:", error2.message);
-    strapi2.log.error("   Stack:", error2.stack);
+    strapi2.log.error(`   Error: ${error2.message}`);
+    strapi2.log.error(`   Stack: ${error2.stack}`);
   }
   await strapi2.admin.services.permission.actionProvider.registerMany(actions);
   if (strapi2.plugin("users-permissions")) {
@@ -210,14 +210,14 @@ const bootstrap = async ({ strapi: strapi2 }) => {
   if (process.env.RUN_FIREBASE_MIGRATION === "true") {
     const dryRun = process.env.DRY_RUN === "true";
     strapi2.log.info("");
-    strapi2.log.info("🚀 Firebase migration triggered by RUN_FIREBASE_MIGRATION env variable");
+    strapi2.log.info("Firebase migration triggered by RUN_FIREBASE_MIGRATION env variable");
     await migrateFirebaseUserData(strapi2, dryRun);
   }
   setImmediate(async () => {
     try {
       await strapi2.plugin("firebase-authentication").service("autoLinkService").linkAllUsers(strapi2);
     } catch (error2) {
-      strapi2.log.error("Auto-linking failed:", error2);
+      strapi2.log.error(`Auto-linking failed: ${error2.message}`);
     }
   });
 };
@@ -442,7 +442,7 @@ const firebaseController = {
       const result = await strapi.plugin(pluginName).service("firebaseService").validateFirebaseToken(idToken, profileMetaData, populate2);
       ctx.body = result;
     } catch (error2) {
-      strapi.log.error("validateToken controller error:", error2.message);
+      strapi.log.error(`validateToken controller error: ${error2.message}`);
       if (error2.name === "ValidationError") {
         return ctx.badRequest(error2.message);
       }
@@ -452,9 +452,6 @@ const firebaseController = {
       throw error2;
     }
   },
-  async createAlias(ctx) {
-    ctx.body = await strapi.plugin(pluginName).service("firebaseService").createAlias(ctx);
-  },
   async deleteByEmail(email2) {
     const user = await strapi.firebase.auth().getUserByEmail(email2);
     await strapi.plugin(pluginName).service("firebaseService").delete(user.toJSON().uid);
@@ -518,7 +515,8 @@ const firebaseController = {
   async forgotPassword(ctx) {
     strapi.log.debug("forgotPassword endpoint called");
     try {
-      ctx.body = await strapi.plugin(pluginName).service("firebaseService").forgotPassword(ctx);
+      const { email: email2 } = ctx.request.body || {};
+      ctx.body = await strapi.plugin(pluginName).service("firebaseService").forgotPassword(email2);
     } catch (error2) {
       strapi.log.error("forgotPassword controller error:", error2);
       if (error2.name === "ValidationError") {
@@ -541,7 +539,10 @@ const firebaseController = {
   async resetPassword(ctx) {
     strapi.log.debug("resetPassword endpoint called");
     try {
-      ctx.body = await strapi.plugin(pluginName).service("firebaseService").resetPassword(ctx);
+      const { password } = ctx.request.body || {};
+      const token = ctx.request.headers.authorization?.replace("Bearer ", "");
+      const populate2 = ctx.request.query.populate || [];
+      ctx.body = await strapi.plugin(pluginName).service("firebaseService").resetPassword(password, token, populate2);
     } catch (error2) {
       strapi.log.error("resetPassword controller error:", error2);
       if (error2.name === "ValidationError" || error2.name === "UnauthorizedError") {
@@ -554,7 +555,8 @@ const firebaseController = {
   },
   async requestMagicLink(ctx) {
     try {
-      const result = await strapi.plugin("firebase-authentication").service("firebaseService").requestMagicLink(ctx);
+      const { email: email2 } = ctx.request.body || {};
+      const result = await strapi.plugin("firebase-authentication").service("firebaseService").requestMagicLink(email2);
       ctx.body = result;
     } catch (error2) {
       if (error2.name === "ValidationError" || error2.name === "ApplicationError") {
@@ -28937,11 +28939,12 @@ const userController = {
 };
 const settingsController = {
   setFirebaseConfigJson: async (ctx) => {
-    ctx.body = await strapi.plugin("firebase-authentication").service("settingsService").setFirebaseConfigJson(ctx);
+    const requestBody = ctx.request.body;
+    ctx.body = await strapi.plugin("firebase-authentication").service("settingsService").setFirebaseConfigJson(requestBody);
   },
   getFirebaseConfigJson: async (ctx) => {
     try {
-      const config2 = await strapi.plugin("firebase-authentication").service("settingsService").getFirebaseConfigJson(ctx);
+      const config2 = await strapi.plugin("firebase-authentication").service("settingsService").getFirebaseConfigJson();
       if (!config2) {
         return ctx.send(null);
       }
@@ -28954,7 +28957,7 @@ const settingsController = {
   },
   async delFirebaseConfigJson(ctx) {
     try {
-      const isExist = await strapi.plugin("firebase-authentication").service("settingsService").delFirebaseConfigJson(ctx);
+      const isExist = await strapi.plugin("firebase-authentication").service("settingsService").delFirebaseConfigJson();
       if (!isExist) {
         throw new NotFoundError("No Firebase configs exists for deletion");
       }
@@ -29281,7 +29284,7 @@ const settingsService = ({ strapi: strapi2 }) => {
       try {
         strapi2.log.info("Starting Firebase initialization...");
         const res = await strapi2.db.query(CONFIG_CONTENT_TYPE).findOne({ where: {} });
-        strapi2.log.debug("Found config:", !!res);
+        strapi2.log.debug(`Found config: ${!!res}`);
         if (!res) {
           strapi2.log.debug("No config found, checking for existing Firebase app...");
           if (strapi2.firebase) {
@@ -29291,7 +29294,7 @@ const settingsService = ({ strapi: strapi2 }) => {
           return;
         }
         const jsonObject = res["firebase_config_json"];
-        strapi2.log.debug("Config JSON present:", !!jsonObject?.firebaseConfigJson);
+        strapi2.log.debug(`Config JSON present: ${!!jsonObject?.firebaseConfigJson}`);
         if (!jsonObject || !jsonObject.firebaseConfigJson) {
           strapi2.log.debug("No valid JSON config, checking for existing Firebase app...");
           if (strapi2.firebase) {
@@ -29326,11 +29329,11 @@ const settingsService = ({ strapi: strapi2 }) => {
           strapi2.firebase = admin__default.default;
           strapi2.log.info("Firebase initialization complete - admin instance attached to strapi.firebase");
         } catch (initError) {
-          strapi2.log.error("Failed to initialize Firebase:", initError);
+          strapi2.log.error(`Failed to initialize Firebase: ${initError.message}`);
           throw initError;
         }
       } catch (error2) {
-        strapi2.log.error("Firebase bootstrap error:", error2);
+        strapi2.log.error(`Firebase bootstrap error: ${error2.message}`);
       }
     },
     /**
@@ -29378,7 +29381,7 @@ const settingsService = ({ strapi: strapi2 }) => {
           magicLinkExpiryHours: configObject.magicLinkExpiryHours || 1
         };
       } catch (error2) {
-        strapi2.log.error("Firebase config error:", error2);
+        strapi2.log.error(`Firebase config error: ${error2.message}`);
         throw new ApplicationError$1("Error retrieving Firebase config", {
           error: error2.message
         });
@@ -29405,10 +29408,9 @@ const settingsService = ({ strapi: strapi2 }) => {
      * The service account JSON is encrypted using AES before storage,
      * while the Web API key and password settings are stored in plain text.
      */
-    async setFirebaseConfigJson(ctx) {
+    async setFirebaseConfigJson(requestBody) {
       try {
-        strapi2.log.debug("setFirebaseConfigJson", ctx.request);
-        const { body: requestBody } = ctx.request;
+        strapi2.log.debug("setFirebaseConfigJson called");
         const firebaseConfigJsonString = requestBody.firebaseConfigJson;
         const firebaseWebApiKey = requestBody.firebaseWebApiKey || null;
         const {
@@ -29479,18 +29481,17 @@ const settingsService = ({ strapi: strapi2 }) => {
         const configData = res.firebaseConfigJson || res.firebase_config_json;
         if (!configData) {
           strapi2.log.error("Firebase config data missing from database response");
-          strapi2.log.error("Available keys in response:", Object.keys(res));
+          strapi2.log.error(`Available keys in response: ${JSON.stringify(Object.keys(res))}`);
           throw new ApplicationError2("Failed to retrieve Firebase configuration from database");
         }
         const firebaseConfigHash = configData.firebaseConfigJson;
         if (!firebaseConfigHash) {
-          strapi2.log.error("Firebase config hash missing from config data:", configData);
+          strapi2.log.error(`Firebase config hash missing from config data: ${JSON.stringify(configData)}`);
           throw new ApplicationError2("Firebase configuration hash is missing");
         }
         const firebaseConfigJsonValue = await this.decryptJson(encryptionKey, firebaseConfigHash);
-        configData.firebaseConfigJson = firebaseConfigJsonValue;
-        res.firebaseConfigJson = configData;
-        res.firebase_config_json = configData;
+        res.firebaseConfigJson = firebaseConfigJsonValue;
+        res.firebase_config_json = firebaseConfigJsonValue;
         res.firebaseWebApiKey = res.firebase_web_api_key || null;
         res.passwordRequirementsRegex = res.passwordRequirementsRegex || passwordRequirementsRegex;
         res.passwordRequirementsMessage = res.passwordRequirementsMessage || passwordRequirementsMessage;
@@ -29503,13 +29504,12 @@ const settingsService = ({ strapi: strapi2 }) => {
         return res;
       } catch (error2) {
         strapi2.log.error("=== FIREBASE CONFIG SAVE ERROR ===");
-        strapi2.log.error("Error name:", error2.name);
-        strapi2.log.error("Error message:", error2.message);
-        strapi2.log.error("Error stack:", error2.stack);
+        strapi2.log.error(`Error name: ${error2.name}`);
+        strapi2.log.error(`Error message: ${error2.message}`);
+        strapi2.log.error(`Error stack: ${error2.stack}`);
         try {
-          const { body } = ctx.request;
-          if (body) {
-            strapi2.log.error("Request body keys:", Object.keys(body));
+          if (requestBody) {
+            strapi2.log.error(`Request body keys: ${JSON.stringify(Object.keys(requestBody))}`);
           }
         } catch (e) {
           strapi2.log.error("Could not access request body");
@@ -29530,7 +29530,7 @@ const settingsService = ({ strapi: strapi2 }) => {
       try {
         strapi2.log.debug("delFirebaseConfigJson called");
         const isExist = await strapi2.db.query(CONFIG_CONTENT_TYPE).findOne({ where: {} });
-        strapi2.log.debug("Config exists:", isExist);
+        strapi2.log.debug(`Config exists: ${!!isExist}`);
         if (!isExist) {
           strapi2.log.info(ERROR_MESSAGES.DELETION_NO_CONFIG);
           return null;
@@ -29538,12 +29538,12 @@ const settingsService = ({ strapi: strapi2 }) => {
         const res = await strapi2.db.query(CONFIG_CONTENT_TYPE).delete({
           where: { id: isExist.id }
         });
-        strapi2.log.debug("Delete result:", res);
+        strapi2.log.debug(`Delete result: ${JSON.stringify(res)}`);
         await strapi2.plugin("firebase-authentication").service("settingsService").init();
         strapi2.log.info(SUCCESS_MESSAGES.FIREBASE_CONFIG_DELETED);
         return res;
       } catch (error2) {
-        strapi2.log.error("delFirebaseConfigJson error:", error2);
+        strapi2.log.error(`delFirebaseConfigJson error: ${error2.message}`);
         throw new ApplicationError2(ERROR_MESSAGES.SOMETHING_WENT_WRONG, {
           error: error2
         });
@@ -29850,9 +29850,71 @@ const userService = ({ strapi: strapi2 }) => {
     update: async (entityId, payload) => {
       try {
         ensureFirebaseInitialized();
-        const firebasePromise = strapi2.firebase.auth().updateUser(entityId, payload);
-        return Promise.allSettled([firebasePromise]);
+        const firebaseData = await strapi2.plugin("firebase-authentication").service("firebaseUserDataService").getByFirebaseUID(entityId);
+        if (!firebaseData?.user) {
+          throw new NotFoundError(`User not found for Firebase UID: ${entityId}`);
+        }
+        const firebasePayload = {};
+        if (payload.email !== void 0) firebasePayload.email = payload.email;
+        if (payload.phoneNumber !== void 0) firebasePayload.phoneNumber = payload.phoneNumber;
+        if (payload.displayName !== void 0) firebasePayload.displayName = payload.displayName;
+        if (payload.photoURL !== void 0) firebasePayload.photoURL = payload.photoURL;
+        if (payload.disabled !== void 0) firebasePayload.disabled = payload.disabled;
+        if (payload.emailVerified !== void 0) firebasePayload.emailVerified = payload.emailVerified;
+        if (payload.password !== void 0) firebasePayload.password = payload.password;
+        const firebasePromise = strapi2.firebase.auth().updateUser(entityId, firebasePayload);
+        const strapiPayload = {};
+        if (payload.email !== void 0) {
+          strapiPayload.email = payload.email;
+        }
+        if (payload.phoneNumber !== void 0) {
+          strapiPayload.phoneNumber = payload.phoneNumber;
+        }
+        if (payload.displayName !== void 0) {
+          if (payload.displayName) {
+            const nameParts = payload.displayName.trim().split(" ");
+            strapiPayload.firstName = nameParts[0] || "";
+            strapiPayload.lastName = nameParts.slice(1).join(" ") || "";
+          } else {
+            strapiPayload.firstName = "";
+            strapiPayload.lastName = "";
+          }
+        }
+        if (typeof payload.disabled === "boolean") {
+          strapiPayload.blocked = payload.disabled;
+        }
+        const strapiPromise = Object.keys(strapiPayload).length > 0 ? strapi2.db.query("plugin::users-permissions.user").update({
+          where: { documentId: firebaseData.user.documentId },
+          data: strapiPayload
+        }) : Promise.resolve(firebaseData.user);
+        const results = await Promise.allSettled([firebasePromise, strapiPromise]);
+        strapi2.log.info("User update operation", {
+          userId: entityId,
+          firebaseStatus: results[0].status,
+          strapiStatus: results[1].status,
+          updatedFields: Object.keys(firebasePayload)
+        });
+        if (results[0].status === "rejected" || results[1].status === "rejected") {
+          strapi2.log.error("Partial update failure detected", {
+            userId: entityId,
+            firebaseError: results[0].status === "rejected" ? results[0].reason : null,
+            strapiError: results[1].status === "rejected" ? results[1].reason : null
+          });
+        }
+        return results;
       } catch (e) {
+        if (e.code === "auth/email-already-exists") {
+          throw new ValidationError$1("Email address is already in use by another account");
+        }
+        if (e.code === "auth/phone-number-already-exists") {
+          throw new ValidationError$1("Phone number is already in use by another account");
+        }
+        if (e.code === "auth/invalid-email") {
+          throw new ValidationError$1("Invalid email address format");
+        }
+        if (e.code === "auth/invalid-phone-number") {
+          throw new ValidationError$1("Invalid phone number format");
+        }
         throw new ApplicationError$1(e.message.toString());
       }
     },
@@ -29870,8 +29932,8 @@ const userService = ({ strapi: strapi2 }) => {
         if (!firebaseData?.user) {
           throw new NotFoundError(`User not found for Firebase UID: ${entityId}`);
         }
-        return await strapi2.documents("plugin::users-permissions.user").update({
-          documentId: firebaseData.user.documentId,
+        return await strapi2.db.query("plugin::users-permissions.user").update({
+          where: { documentId: firebaseData.user.documentId },
           data: payload
         });
       } catch (e) {
@@ -29886,8 +29948,8 @@ const userService = ({ strapi: strapi2 }) => {
           throw new NotFoundError(`User not found for Firebase UID: ${entityId}`);
         }
         const firebasePromise = strapi2.firebase.auth().updateUser(entityId, payload);
-        const strapiPromise = strapi2.documents("plugin::users-permissions.user").update({
-          documentId: firebaseData.user.documentId,
+        const strapiPromise = strapi2.db.query("plugin::users-permissions.user").update({
+          where: { documentId: firebaseData.user.documentId },
           data: payload
         });
         return Promise.allSettled([firebasePromise, strapiPromise]);
@@ -29903,8 +29965,8 @@ const userService = ({ strapi: strapi2 }) => {
           throw new NotFoundError(`User not found for Firebase UID: ${entityId}`);
         }
         const firebasePromise = strapi2.firebase.auth().deleteUser(entityId);
-        const strapiPromise = strapi2.documents("plugin::users-permissions.user").delete({
-          documentId: firebaseData.user.documentId
+        const strapiPromise = strapi2.db.query("plugin::users-permissions.user").delete({
+          where: { documentId: firebaseData.user.documentId }
         });
         return Promise.allSettled([firebasePromise, strapiPromise]);
       } catch (e) {
@@ -29926,8 +29988,8 @@ const userService = ({ strapi: strapi2 }) => {
         if (!firebaseData?.user) {
           throw new NotFoundError(`User not found for Firebase UID: ${entityId}`);
         }
-        const response = await strapi2.documents("plugin::users-permissions.user").delete({
-          documentId: firebaseData.user.documentId
+        const response = await strapi2.db.query("plugin::users-permissions.user").delete({
+          where: { documentId: firebaseData.user.documentId }
         });
         return response;
       } catch (e) {
@@ -30466,8 +30528,8 @@ const firebaseService = ({ strapi: strapi2 }) => ({
    * Forgot password flow - sends reset email
    * Public endpoint that sends a Firebase-hosted password reset email using Firebase's secure hosted UI
    */
-  forgotPassword: async (ctx) => {
-    const { email: email2 } = ctx.request.body;
+  forgotPassword: async (email2) => {
+    strapi2.log.info(`[forgotPassword] Starting password reset for email: ${email2}`);
     if (!email2) {
       throw new ValidationError$1("Email is required");
     }
@@ -30508,8 +30570,16 @@ const firebaseService = ({ strapi: strapi2 }) => ({
         });
       }
       if (!strapiUser) {
+        strapi2.log.warn(`⚠️ [forgotPassword] User not found for email: ${email2}`);
         return { message: "If an account with that email exists, a password reset link has been sent." };
       }
+      strapi2.log.info(
+        `✅ [forgotPassword] User found: ${JSON.stringify({
+          documentId: strapiUser.documentId,
+          email: strapiUser.email,
+          firebaseUID: firebaseUser?.uid || "not in Firebase"
+        })}`
+      );
       const actionCodeSettings = {
         url: resetUrl,
         // Continue URL after reset completes on Firebase's page
@@ -30523,6 +30593,7 @@ const firebaseService = ({ strapi: strapi2 }) => ({
       });
       let resetLink;
       try {
+        strapi2.log.info(`[forgotPassword] Generating Firebase password reset link for: ${strapiUser.email}`);
         resetLink = await Promise.race([
           strapi2.firebase.auth().generatePasswordResetLink(strapiUser.email, actionCodeSettings),
           timeoutPromise
@@ -30534,12 +30605,22 @@ const firebaseService = ({ strapi: strapi2 }) => ({
         strapi2.log.error(`❌ Failed to generate password reset link for ${strapiUser.email}:`, error2);
         throw error2;
       }
+      strapi2.log.info(`[forgotPassword] Attempting to send password reset email to: ${strapiUser.email}`);
       await strapi2.plugin("firebase-authentication").service("emailService").sendPasswordResetEmail(strapiUser, resetLink);
+      strapi2.log.info(`✅ [forgotPassword] Password reset email sent successfully to: ${strapiUser.email}`);
       return {
         message: "If an account with that email exists, a password reset link has been sent."
       };
     } catch (error2) {
-      strapi2.log.error("forgotPassword error:", error2);
+      strapi2.log.error(
+        `❌ [forgotPassword] ERROR: ${JSON.stringify({
+          email: email2,
+          message: error2.message,
+          code: error2.code,
+          name: error2.name,
+          stack: error2.stack
+        })}`
+      );
       return {
         message: "If an account with that email exists, a password reset link has been sent."
       };
@@ -30559,13 +30640,10 @@ const firebaseService = ({ strapi: strapi2 }) => ({
    *
    * NOT used for forgot password email flow - that now uses Firebase's hosted UI
    */
-  resetPassword: async (ctx) => {
-    const { password } = ctx.request.body;
-    const populate2 = ctx.request.query.populate || [];
+  resetPassword: async (password, token, populate2) => {
     if (!password) {
       throw new ValidationError$1("Password is required");
     }
-    const token = ctx.request.header.authorization?.replace("Bearer ", "");
     if (!token) {
       throw new UnauthorizedError("Authorization token is required");
     }
@@ -30621,8 +30699,7 @@ const firebaseService = ({ strapi: strapi2 }) => ({
    * Generates a sign-in link using Firebase Admin SDK
    * Note: Verification requires client-side completion
    */
-  async requestMagicLink(ctx) {
-    const { email: email2 } = ctx.request.body;
+  async requestMagicLink(email2) {
     if (!email2 || typeof email2 !== "string") {
       throw new ValidationError$1("Valid email is required");
     }
@@ -30652,7 +30729,7 @@ const firebaseService = ({ strapi: strapi2 }) => ({
       };
       const magicLink = await strapi2.firebase.auth().generateSignInWithEmailLink(email2, actionCodeSettings);
       if (process.env.NODE_ENV !== "production") {
-        strapi2.log.info("🔗 Magic Link Generation Request:");
+        strapi2.log.info("Magic Link Generation Request:");
         strapi2.log.info(`   Email: ${email2}`);
         strapi2.log.info(`   Verification URL: ${magicLinkUrl}`);
         strapi2.log.info(`   Expires: ${config2.magicLinkExpiryHours || 1} hour(s)`);
@@ -31258,7 +31335,7 @@ class EmailService {
         const template = await templateService2.getTemplate("magicLink");
         const compiledSubject = _$1.template(template.subject)(completeVariables);
         strapi.log.info("\n" + "=".repeat(80));
-        strapi.log.info("🔗 MAGIC LINK EMAIL (Development Mode)");
+        strapi.log.info("MAGIC LINK EMAIL (Development Mode)");
         strapi.log.info("=".repeat(80));
         strapi.log.info(`To: ${email2}`);
         strapi.log.info(`Subject: ${compiledSubject}`);
@@ -31333,7 +31410,7 @@ const firebaseUserDataService = ({ strapi: strapi2 }) => ({
           }
         });
       } catch (error2) {
-        if (error2.code === "23505") {
+        if (error2.code === "23505" || error2.name === "ValidationError") {
           strapi2.log.warn(`Race condition detected for user ${userId}, retrying findFirst`);
           firebaseData = await strapi2.documents("plugin::firebase-authentication.firebase-user-data").findFirst({
             filters: { user: { documentId: { $eq: userId } } }
@@ -31373,7 +31450,7 @@ const autoLinkService = {
       errors: 0
     };
     try {
-      strapi2.log.info("🔗 Auto-linking Strapi users with Firebase users...");
+      strapi2.log.info("Auto-linking Strapi users with Firebase users...");
       if (!strapi2.firebase) {
         strapi2.log.warn("Firebase not initialized - skipping auto-linking");
         return result;
@@ -31412,6 +31489,7 @@ const autoLinkService = {
         }
       }
       for (const strapiUser of strapiUsers) {
+        let firebaseUser = null;
         try {
           const existing = await strapi2.db.query("plugin::firebase-authentication.firebase-user-data").findOne({
             select: ["id"],
@@ -31421,7 +31499,7 @@ const autoLinkService = {
             result.skipped++;
             continue;
           }
-          let firebaseUser = null;
+          firebaseUser = null;
           if (strapiUser.email) {
             firebaseUser = firebaseByEmail.get(strapiUser.email.toLowerCase());
           }
@@ -31432,6 +31510,23 @@ const autoLinkService = {
             result.skipped++;
             continue;
           }
+          const existingUIDLink = await strapi2.db.query("plugin::firebase-authentication.firebase-user-data").findOne({
+            where: { firebaseUserID: firebaseUser.uid },
+            populate: ["user"]
+          });
+          if (existingUIDLink && existingUIDLink.user?.documentId !== strapiUser.documentId) {
+            strapi2.log.warn(
+              `⚠️ [Auto-Link] Skipping '${strapiUser.username || strapiUser.email}' - Firebase UID already linked`
+            );
+            strapi2.log.warn(`   Strapi User: ${strapiUser.email} (documentId: ${strapiUser.documentId})`);
+            strapi2.log.warn(`   Firebase UID: ${firebaseUser.uid}`);
+            strapi2.log.warn(
+              `   Already linked to: ${existingUIDLink.user?.email} (documentId: ${existingUIDLink.user?.documentId})`
+            );
+            strapi2.log.warn(`   Action: Resolve duplicate users or manually unlink conflicting record`);
+            result.skipped++;
+            continue;
+          }
           try {
             const firebaseData = {
               firebaseUserID: firebaseUser.uid
@@ -31450,18 +31545,42 @@ const autoLinkService = {
             throw createError;
           }
         } catch (error2) {
-          result.errors++;
-          strapi2.log.error(`Error linking user ${strapiUser.username}:`, error2);
+          if (error2.message?.includes("This attribute must be unique")) {
+            strapi2.log.warn(
+              `⚠️ [Auto-Link] Unique constraint conflict for '${strapiUser.username || strapiUser.email}'`
+            );
+            strapi2.log.warn(`   Strapi User: ${strapiUser.email} (documentId: ${strapiUser.documentId})`);
+            if (firebaseUser) {
+              strapi2.log.warn(`   Firebase UID: ${firebaseUser.uid}`);
+              strapi2.log.warn(`   Cause: This Firebase UID is already linked to another Strapi user`);
+              strapi2.log.warn(
+                `   Action: Query firebase_user_data table to find conflict - WHERE firebase_user_id = '${firebaseUser.uid}'`
+              );
+            }
+            result.skipped++;
+          } else {
+            result.errors++;
+            strapi2.log.error(
+              `❌ [Auto-Link] Unexpected error linking user '${strapiUser.username || strapiUser.email}': ${error2.message}`
+            );
+          }
         }
       }
-      strapi2.log.info(
-        `✅ Auto-linking complete: ${result.linked} linked, ${result.skipped} skipped, ${result.errors} errors`
-      );
+      if (result.errors > 0) {
+        strapi2.log.error(
+          `❌ Auto-linking completed with unexpected errors: ${result.linked} linked, ${result.skipped} skipped, ${result.errors} errors`
+        );
+        strapi2.log.error(`   Review error logs above for resolution steps`);
+      } else {
+        strapi2.log.info(
+          `✅ Auto-linking complete: ${result.linked} linked, ${result.skipped} skipped, ${result.errors} errors`
+        );
+      }
       strapi2.log.info(
         `   Total: ${result.totalStrapiUsers} Strapi users, ${result.totalFirebaseUsers} Firebase users`
       );
     } catch (error2) {
-      strapi2.log.error("Fatal error during auto-linking:", error2);
+      strapi2.log.error(`❌ Fatal error during auto-linking: ${error2.message}`);
     }
     return result;
   }