@adobe/alloy 2.32.1-beta.0 → 2.33.0-beta.2

package/src/components/PushNotifications/helpers/saveToIndexedDb.js

@@ -0,0 +1,64 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/** @import { Logger } from '@adobe/alloy-core/core/types.js' */
+
+import {
+  openIndexedDb,
+  getFromIndexedDbStore,
+  putToIndexedDbStore,
+} from "@adobe/alloy-core/utils/indexedDb.js";
+
+import { DB_NAME, DB_VERSION, STORE_NAME, INDEX_KEY } from "./constants.js";
+
+/**
+ * @param {Object} data
+ * @param {Logger} logger
+ *
+ * @returns {Promise<void>}
+ */
+export default async function saveToIndexedDB(data, logger) {
+  try {
+    const db = await openIndexedDb(
+      DB_NAME,
+      DB_VERSION,
+      (/** @type {IDBDatabase} */ db) => {
+        if (!db.objectStoreNames.contains(STORE_NAME)) {
+          db.createObjectStore(STORE_NAME, { keyPath: "id" });
+        }
+      },
+    );
+
+    const existingConfigData = await getFromIndexedDbStore(
+      db,
+      STORE_NAME,
+      INDEX_KEY,
+    );
+
+    const updatedConfigData = {
+      ...(existingConfigData || {}),
+      ...data,
+      id: INDEX_KEY,
+      timestamp: Date.now(),
+    };
+
+    await putToIndexedDbStore(db, STORE_NAME, updatedConfigData);
+    db.close();
+
+    logger.info(
+      "Successfully saved web SDK config to IndexedDB",
+      updatedConfigData,
+    );
+  } catch (error) {
+    logger.error("Failed to save config to IndexedDB", { error });
+  }
+}

package/src/components/PushNotifications/helpers/serviceWorkerNotificationClickListener.js

@@ -0,0 +1,84 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+// @ts-check
+/// <reference lib="webworker" />
+
+/** @import { ServiceWorkerLogger } from '../types.js' */
+
+/**
+ * @param {string} type
+ * @returns {boolean}
+ */
+const canHandleUrl = (type) => ["DEEPLINK", "WEBURL"].includes(type);
+
+/**
+ * @param {Object} dependencies
+ * @param {(options: { xdm: Object, actionLabel?: string, applicationLaunches?: number }) => Promise<boolean>} dependencies.makeSendServiceWorkerTrackingData
+ * @param {ServiceWorkerGlobalScope} dependencies.sw
+ * @param {ServiceWorkerLogger} dependencies.logger
+ */
+export default ({ makeSendServiceWorkerTrackingData, sw, logger }) => {
+  /**
+   * @function
+   *
+   * @param {Object} options
+   * @param {NotificationEvent} options.event
+   */
+  return ({ event }) => {
+    event.notification.close();
+
+    const data = event.notification.data;
+    let targetUrl = null;
+    let actionLabel = null;
+
+    if (event.action) {
+      const actionIndex = parseInt(event.action.replace("action_", ""), 10);
+      if (data?.actions?.buttons[actionIndex]) {
+        const button = data.actions.buttons[actionIndex];
+        actionLabel = button.label;
+        if (canHandleUrl(button.type) && button.uri) {
+          targetUrl = button.uri;
+        }
+      }
+    } else if (
+      canHandleUrl(data?.interaction?.type) &&
+      data?.interaction?.uri
+    ) {
+      targetUrl = data.interaction.uri;
+    }
+
+    makeSendServiceWorkerTrackingData({
+      // eslint-disable-next-line no-underscore-dangle
+      xdm: data._xdm.mixins,
+      actionLabel,
+      applicationLaunches: 1,
+    }).catch((error) => {
+      logger.error("Failed to send tracking call:", error);
+    });
+
+    if (targetUrl) {
+      event.waitUntil(
+        sw.clients.matchAll({ type: "window" }).then((clientList) => {
+          for (const client of clientList) {
+            if (client.url === targetUrl && "focus" in client) {
+              return client.focus();
+            }
+          }
+          if (sw.clients.openWindow) {
+            return sw.clients.openWindow(targetUrl);
+          }
+        }),
+      );
+    }
+  };
+};

package/src/components/PushNotifications/helpers/serviceWorkerPushListener.js

@@ -0,0 +1,72 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+// @ts-check
+/// <reference lib="webworker" />
+
+/** @import {  PushNotificationData  } from '../types.js' */
+/** @import { ServiceWorkerLogger } from '../types.js' */
+
+/**
+ * @async
+ * @function
+ *
+ * @param {Object} options
+ * @param {ServiceWorkerGlobalScope} options.sw
+ * @param {PushEvent} options.event
+ * @param {ServiceWorkerLogger} options.logger
+ * @returns {Promise<void>}
+ */
+export default async ({ sw, event, logger }) => {
+  if (!event.data) {
+    return;
+  }
+
+  /** @type {PushNotificationData} */
+  let notificationData;
+  try {
+    notificationData = event.data.json();
+  } catch (error) {
+    logger.error("Error decoding notification JSON data:", error);
+    return;
+  }
+
+  const webData = notificationData.web;
+  if (!webData?.title) {
+    return;
+  }
+
+  const notificationOptions = {
+    body: webData.body,
+    icon: webData.media,
+    image: webData.media,
+    data: webData,
+    actions: [],
+  };
+
+  Object.keys(notificationOptions).forEach((k) => {
+    if (notificationOptions[k] == null) {
+      delete notificationOptions[k];
+    }
+  });
+
+  if (webData.actions && webData.actions.buttons) {
+    notificationOptions.actions = webData.actions.buttons.map(
+      (button, index) => ({
+        action: `action_${index}`,
+        title: button.label,
+      }),
+    );
+  }
+
+  return sw.registration.showNotification(webData.title, notificationOptions);
+};

package/src/components/PushNotifications/index.js

@@ -0,0 +1,128 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/** @import { StorageCreator } from '@adobe/alloy-core/utils/types.js' */
+/** @import { EventManager, Logger } from '@adobe/alloy-core/core/types.js' */
+/** @import { IdentityManager } from '@adobe/alloy-core/core/identity/types.js' */
+/** @import { ConsentManager } from '@adobe/alloy-core/core/consent/types.js' */
+/** @import { EdgeRequestExecutor } from '@adobe/alloy-core/core/edgeNetwork/types.js' */
+
+import { objectOf, string } from "@adobe/alloy-core/utils/validation";
+import { sanitizeOrgIdForCookieName } from "@adobe/alloy-core/utils";
+import makeSendPushSubscriptionRequest from "./request/makeSendPushSubscriptionRequest.js";
+import saveToIndexedDb from "./helpers/saveToIndexedDb.js";
+
+const isComponentConfigured = ({
+  orgId,
+  pushNotifications: { vapidPublicKey, appId, trackingDatasetId } = {
+    vapidPublicKey: undefined,
+    appId: undefined,
+    trackingDatasetId: undefined,
+  },
+}) => orgId && vapidPublicKey && appId && trackingDatasetId;
+
+/**
+ * @function
+ *
+ * @param {Object} options
+ * @param {{ orgId: string, datastreamId: string, edgeDomain: string, edgeBasePath: string, pushNotifications: { vapidPublicKey: string, appId: string, trackingDatasetId: string }}} options.config
+ * @param {StorageCreator} options.createNamespacedStorage
+ * @param {EventManager} options.eventManager
+ * @param {Logger} options.logger
+ * @param {ConsentManager} options.consent
+ * @param {IdentityManager} options.identity
+ * @param {function(): string} options.getBrowser
+ * @param {EdgeRequestExecutor} options.sendEdgeNetworkRequest
+ * @returns {{ lifecycle: object, commands: { sendPushSubscription: object } }}
+ */
+const createPushNotifications = ({
+  createNamespacedStorage,
+  eventManager,
+  config,
+  logger,
+  consent,
+  identity,
+  getBrowser,
+  sendEdgeNetworkRequest,
+}) => {
+  return {
+    lifecycle: {
+      async onComponentsRegistered() {
+        if (isComponentConfigured(config)) {
+          const {
+            datastreamId,
+            edgeDomain,
+            edgeBasePath,
+            pushNotifications: { trackingDatasetId },
+          } = config;
+          await saveToIndexedDb(
+            {
+              datastreamId,
+              edgeDomain,
+              edgeBasePath,
+              datasetId: trackingDatasetId,
+              browser: getBrowser(),
+            },
+            logger,
+          );
+        }
+      },
+    },
+    commands: {
+      sendPushSubscription: {
+        run: async () => {
+          if (!isComponentConfigured(config)) {
+            throw new Error("Push notifications module is not configured.");
+          }
+
+          const {
+            orgId,
+            pushNotifications: { vapidPublicKey, appId } = {
+              vapidPublicKey: undefined,
+              appId: undefined,
+            },
+          } = config || {};
+
+          const storage = createNamespacedStorage(
+            `${sanitizeOrgIdForCookieName(orgId)}.pushNotifications.`,
+          );
+
+          return makeSendPushSubscriptionRequest({
+            config: {
+              vapidPublicKey,
+              appId,
+            },
+            storage: storage.persistent,
+            logger,
+            sendEdgeNetworkRequest,
+            consent,
+            eventManager,
+            identity,
+            window,
+          });
+        },
+        optionsValidator: objectOf({}).noUnknownFields(),
+      },
+    },
+  };
+};
+
+createPushNotifications.namespace = "Push Notifications";
+createPushNotifications.configValidators = objectOf({
+  pushNotifications: objectOf({
+    vapidPublicKey: string().required(),
+    appId: string().required(),
+    trackingDatasetId: string().required(),
+  }).noUnknownFields(),
+});
+
+export default createPushNotifications;

package/src/components/PushNotifications/request/createSendPushSubscriptionPayload.js

@@ -0,0 +1,66 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/** @import { EventManager } from "@adobe/alloy-core/core/types.js" */
+/** @import { DataCollectionRequestPayload } from "@adobe/alloy-core/utils/request/types.js" */
+
+import createDataCollectionRequestPayload from "@adobe/alloy-core/utils/request/createDataCollectionRequestPayload.js";
+
+/**
+ * Creates a data collection request payload for sending push subscription details to Adobe Experience Platform.
+ *
+ * This function constructs an event containing push notification subscription information,
+ * including the subscription details, platform information, and identity data. The event
+ * is then packaged into a data collection request payload for transmission to the edge network.
+ *
+ * @async
+ * @function
+ *
+ * @param {Object} options
+ * @param {string} options.ecid
+ * @param {EventManager} options.eventManager
+ * @param {string} options.serializedPushSubscriptionDetails
+ * @param {string} options.appId
+ *
+ * @returns {Promise<DataCollectionRequestPayload>}
+ */
+export default async ({
+  ecid,
+  eventManager,
+  serializedPushSubscriptionDetails,
+  appId,
+}) => {
+  const event = eventManager.createEvent();
+
+  event.setUserData({
+    pushNotificationDetails: [
+      {
+        appID: appId,
+        token: serializedPushSubscriptionDetails,
+        platform: "web",
+        denylisted: false,
+        identity: {
+          namespace: {
+            code: "ECID",
+          },
+          id: ecid,
+        },
+      },
+    ],
+  });
+  event.finalize();
+
+  const payload = createDataCollectionRequestPayload();
+  payload.addEvent(event);
+
+  return payload;
+};

package/src/components/PushNotifications/request/createSendPushSubscriptionRequest.js

@@ -0,0 +1,35 @@
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/** @import { DataCollectionRequestPayload, Request } from '@adobe/alloy-core/utils/request/types.js' */
+
+import { createRequest } from "@adobe/alloy-core/utils/request";
+
+/**
+ * @function
+ *
+ * @param {{ payload: DataCollectionRequestPayload }} options
+ *
+ * @returns {Request}
+ */
+export default ({ payload }) =>
+  createRequest({
+    payload,
+
+    getAction() {
+      return "interact";
+    },
+
+    getUseSendBeacon() {
+      return false;
+    },
+  });

package/src/components/PushNotifications/request/makeSendPushSubscriptionRequest.js

@@ -0,0 +1,98 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/** @import { Storage } from '@adobe/alloy-core/utils/types.js' */
+/** @import { EventManager, Logger } from '@adobe/alloy-core/core/types.js' */
+/** @import { IdentityManager } from '@adobe/alloy-core/core/identity/types.js' */
+/** @import { ConsentManager } from '@adobe/alloy-core/core/consent/types.js' */
+/** @import { EdgeRequestExecutor } from '@adobe/alloy-core/core/edgeNetwork/types.js' */
+
+import { sortObjectKeysRecursively } from "@adobe/alloy-core/utils";
+import getPushSubscriptionDetailsDefault from "../helpers/getPushSubscriptionDetails.js";
+import createSendPushSubscriptionRequest from "./createSendPushSubscriptionRequest.js";
+import createSendPushSubscriptionPayload from "./createSendPushSubscriptionPayload.js";
+import saveToIndexedDb from "../helpers/saveToIndexedDb.js";
+
+const SUBSCRIPTION_DETAILS = "subscriptionDetails";
+
+/**
+ * Retrieves and returns push subscription details with sorted object keys.
+ *
+ * This function gets the push subscription details using the provided VAPID public key
+ * and returns the details with all object keys sorted recursively for consistent output.
+ *
+ * @async
+ * @function
+ *
+ * @param {Object} options
+ * @param {{vapidPublicKey: string, appId: string}} options.config
+ * @param {Storage} options.storage
+ * @param {Logger} options.logger
+ * @param {EventManager} options.eventManager
+ * @param {IdentityManager} options.identity
+ * @param {EdgeRequestExecutor} options.sendEdgeNetworkRequest
+ * @param {ConsentManager} options.consent
+ * @param {Window} options.window
+ *
+ * @returns {Promise<void>}
+ */
+export default async ({
+  config: { vapidPublicKey, appId },
+  storage,
+  logger,
+  sendEdgeNetworkRequest,
+  consent,
+  eventManager,
+  identity,
+  window,
+  getPushSubscriptionDetails = getPushSubscriptionDetailsDefault,
+}) => {
+  await identity.awaitIdentity();
+  const ecid = identity.getEcidFromCookie();
+
+  const pushSubscriptionDetails = await getPushSubscriptionDetails({
+    vapidPublicKey,
+    window,
+  });
+
+  const serializedPushSubscriptionDetails = JSON.stringify(
+    sortObjectKeysRecursively(pushSubscriptionDetails),
+  );
+
+  const cacheValue = `${ecid}${serializedPushSubscriptionDetails}`;
+
+  if (cacheValue === storage.getItem(SUBSCRIPTION_DETAILS)) {
+    logger.info(
+      "Subscription details have not changed. Not sending to the server.",
+    );
+
+    return;
+  }
+
+  storage.setItem(SUBSCRIPTION_DETAILS, cacheValue);
+
+  const payload = await createSendPushSubscriptionPayload({
+    eventManager,
+    ecid,
+    serializedPushSubscriptionDetails,
+    appId,
+  });
+
+  const request = createSendPushSubscriptionRequest({
+    payload,
+  });
+
+  await consent.awaitConsent();
+  await sendEdgeNetworkRequest({ request });
+
+  await saveToIndexedDb({ ecid }, logger);
+};