strapi-plugin-firebase-authentication 1.1.7 → 1.1.9

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,12 +29481,12 @@ 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);
@@ -29503,13 +29505,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 +29531,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 +29539,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
         });
@@ -30466,8 +30467,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 +30509,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 +30532,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 +30544,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 +30579,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 +30638,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 +30668,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 +31274,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}`);
@@ -31373,7 +31389,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 +31428,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 +31438,7 @@ const autoLinkService = {
             result.skipped++;
             continue;
           }
-          let firebaseUser = null;
+          firebaseUser = null;
           if (strapiUser.email) {
             firebaseUser = firebaseByEmail.get(strapiUser.email.toLowerCase());
           }
@@ -31432,6 +31449,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 +31484,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;
   }