Service worker activate and push event don't get triggered even though the registration is successful and it's activated

Question

I have built a React progressive web application that makes use of service workers.
The service worker gets registered and is activated:

I have been trying to detect the "activate" event using this:

service-worker.js

navigator.serviceWorker.addEventListener("activate", function (event) {
  console.log("service worker activated");
});

I added that at the end of the service-worker file. But, this event never gets triggered and I have no idea why.

---

I also tried to implement push notifications and trigger the from the backend. For this, I needed a "push" event listener that would listen to these events from the server:

navigator.serviceWorker.addEventListener("push", async function (event) {
  const message = await event.data.json();
  let { title, description, image } = message;
  await event.waitUntil(showPushNotification(title, description, image));
});

This is how showPushNotification is defined:

export function showPushNotification(title, description, image) {
  if (!("serviceWorker" in navigator)) {
    console.log("Service Worker is not supported in this browser");
    return;
  }
  navigator.serviceWorker.ready.then(function (registration) {
    registration.showNotification(title, {
      body: description,
      icon: image,
      actions: [
        {
          title: "Say hi",
          action: "Say hi",
        },
      ],
    });
  });
}

I tested calling that function manually and it successfully triggerss a push notification.
This is the server code that triggers the push notification:

const sendPushNotification = async (user_id, title, description, image) => {
  const search_option = { user: user_id };
  const users_subscriptions = await PushNotificationSubscription.find(
    search_option
  );

  const number_of_users_subscriptions = users_subscriptions.length;

  const options = {
    vapidDetails: {
      subject: "mailto:xxxx@xxxx.com",
      publicKey: VAPID_PUBLIC_KEY,
      privateKey: VAPID_PRIVATE_KEY,
    },
  };
  let push_notif_sending_results = {};
  for (let i = 0; i < number_of_users_subscriptions; i++) {
    const user_subscription = users_subscriptions[i];

    await webPush
      .sendNotification(
        user_subscription,
        JSON.stringify({
          title,
          description,
          image,
        }),
        options
      )
      .then((notif_send_result) => {
        push_notif_sending_results[i] = { success: notif_send_result };
      })
      .catch((error) => {
        push_notif_sending_results[i] = { error: error };
      });
  }
  return push_notif_sending_results;
};

This is the part responsible for sending the push notification:

webPush
      .sendNotification(
        user_subscription,
        JSON.stringify({
          title,
          description,
          image,
        }),
        options
      )

And it's successfully executed as it returns a 201 HTTP response.
So the "push" event listener is supposed to detect it and trigger a push notification.
I think everything regarding the push notification has been successfully implementing and the problem is how the "push" event listener is added since the "activate" event listener also doesn't work.

---

So I tried moving the two event listeners here right after the registration of the service worker is successful:

function registerValidSW(swUrl, config) {
  navigator.serviceWorker.register(swUrl).then((registration) => {
    registration.addEventListener("activate", (event) => {
      console.log(
        "🚀 ~ file: serviceWorker.js:159 ~ navigator.serviceWorker.register ~ event",
        event
      );
    });
    registration.addEventListener("push", async function (event) {
      const message = await event.data.json();
      let { title, description, image } = message;
      await event.waitUntil(
        showPushNotification(title, description, image)
      );
    });
  });
}

But, it's still the same result.
Neither the "push" nor the "activate" event listeners get triggered.

Any idea what's going on?

---

Here's the whole service-worker file:

service-worker.js

import axios from "axios";

const isLocalhost = Boolean(
  window.location.hostname === "localhost" ||
    // [::1] is the IPv6 localhost address.
    window.location.hostname === "[::1]" ||
    // 127.0.0.0/8 are considered localhost for IPv4.
    window.location.hostname.match(
      /^127(?:\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$/
    )
);

export function register(config) {
  if (process.env.NODE_ENV === "production" && "serviceWorker" in navigator) {
    // The URL constructor is available in all browsers that support SW.
    const publicUrl = new URL(process.env.PUBLIC_URL, window.location.href);
    if (publicUrl.origin !== window.location.origin) {
      // Our service worker won't work if PUBLIC_URL is on a different origin
      // from what our page is served on. This might happen if a CDN is used to
      // serve assets;
      return;
    }

    window.addEventListener("load", () => {
      const swUrl = `${process.env.PUBLIC_URL}/service-worker.js`;

      if (isLocalhost) {
        // This is running on localhost. Let's check if a service worker still exists or not.
        checkValidServiceWorker(swUrl, config);

        // Add some additional logging to localhost, pointing developers to the
        // service worker/PWA documentation.
      } else {
        // Is not localhost. Just register service worker
        console.log(
          "Is not localhost. Just register a service worker, by calling registerValidSW"
        );
        registerValidSW(swUrl, config);
      }
    });
  }
}

async function subscribeToPushNotifications(serviceWorkerReg) {
  let subscription = await serviceWorkerReg.pushManager.getSubscription();
  if (subscription === null) {
    const dev_public_vapid_key = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
    const prod_public_vapid_key =
      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";

    const public_vapid_key = isLocalhost
      ? dev_public_vapid_key
      : prod_public_vapid_key;

    subscription = await serviceWorkerReg.pushManager.subscribe({
      userVisibleOnly: true,
      applicationServerKey: public_vapid_key,
    });
    axios
      .post("/api/push_notif_subscription/subscribe", subscription)
      .then((response) => {})
      .catch((error) => {});
  }
}
export function showPushNotification(title, description, image) {
  if (!("serviceWorker" in navigator)) {
    console.log("Service Worker is not supported in this browser");
    return;
  }
  navigator.serviceWorker.ready.then(function (registration) {
    registration.showNotification(title, {
      body: description,
      icon: image,
      actions: [
        {
          title: "Say hi",
          action: "Say hi",
        },
      ],
    });
  });
}

function registerValidSW(swUrl, config) {
  navigator.serviceWorker.register(swUrl).then((registration) => {
    subscribeToPushNotifications(registration);
    registration.onupdatefound = () => {
      const installingWorker = registration.installing;
      if (!installingWorker) {
        return;
      }
      installingWorker.onstatechange = () => {
        if (installingWorker.state === "installed") {
          if (navigator.serviceWorker.controller) {
            // At this point, the updated precached content has been fetched,
            // but the previous service worker will still serve the older
            // content until all client tabs are closed.

            // Execute callback
            if (config && config.onUpdate) {
              config.onUpdate(registration);
            }
          } else {
            // At this point, everything has been preached.
            // It's the perfect time to display a
            // "Content is cached for offline use." message.

            // Execute callback
            if (config && config.onSuccess) {
              config.onSuccess(registration);
            }
          }
        }
      };
    };
  });
}

function checkValidServiceWorker(swUrl, config) {
  // Check if the service worker can be found. If it can't reload the page.
  fetch(swUrl, {
    headers: { "Service-Worker": "script" },
  }).then((response) => {
    // Ensure the service worker exists, and that we really are getting a JS file.
    const contentType = response.headers.get("content-type");
    if (
      response.status === 404 ||
      (!!contentType && contentType.indexOf("javascript") === -1)
    ) {
      // No service worker found. Probably a different app. Reload the page.
      navigator.serviceWorker.ready.then((registration) => {
        registration.unregister().then(() => {
          window.location.reload();
        });
      });
    } else {
      // Service worker found. Proceed as normal.
      console.log("Service worker found, calling registerValidSW");
      registerValidSW(swUrl, config);
    }
  });
}

export function unregister() {
  if ("serviceWorker" in navigator) {
    navigator.serviceWorker.ready.then((registration) => {
      registration.unregister();
    });
  }
}

navigator.serviceWorker.addEventListener("activate", function (event) {
  console.log("service worker activated");
});

navigator.serviceWorker.addEventListener("push", async function (event) {
  const message = await event.data.json();
  let { title, description, image } = message;
  await event.waitUntil(showPushNotification(title, description, image));
});

Answer 1

The events "push" and "activate" are part of the ServiceWorkerGlobalScope as within the Service Worker API.

Push notifications must be handled within the service worker itself.
Therefore only the service worker can register an "activate" event listener. The same applies for a "push" listener.

Specially in terms of the "push" listener this makes sense.
The idea of push events is to receive them, even if the main app (in this case the website) has been closed. The service worker is an exception, as it even runs without the page being loaded.

Therefore move the "push" event into your service worker.
Your code (within the service worker) may look like this:

this.addEventListener("push", async function (event) {
  const message = await event.data.json();
  let { title, description, image } = message;
  await event.waitUntil(showPushNotification(title, description, image));
});

function showPushNotification(title, description, image) {
  registration.showNotification(title, {
   body: description,
   icon: image,
   actions: [
     {
       title: "Say hi",
       action: "Say hi",
     },
   ],
 });
}

The rest seems fine to me.

Update (Some more explanation)

I took a more careful look at your service-worker.js and it seems it contains general methods for registering the service worker.

As mentioned above the main app and the service worker are two completely separate chunks of code, running in different spaces. So this means everything which is not supposed to run in the service worker itself must be put outside of the service-worker.js. The service worker (in your case) should only contain the code for handling push notifications. It's important that you do not include the "service-worker.js" within your application.

In your case, you may seperate these functions into service-worker-register.js which contain all functions which are for managing the service worker registration but should not be executed within the service worker itself (isLocalhost, register, subscribeToPushNotifications, registerValidSW, checkValidServiceWorker, and unregister). Please note the code snippet from above and make changes accordingly to the code left within the service worker.

MDN has a pretty in depth tutorial on service workers (and there are a lot more) I recommend having a look at: developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers