@adobe/alloy 2.19.1-beta.0 → 2.20.0-alpha.0

package/libEs6/components/MediaCollection/createHeartbeatEngine.js

@@ -0,0 +1,57 @@
+/*
+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 toInteger from "../../utils/toInteger";
+export default (({
+  config,
+  mediaEventManager,
+  mediaSessionCacheManager
+}) => {
+  return ({
+    playerId,
+    sessionId,
+    onBeforeMediaEvent
+  }) => {
+    const currentTime = Date.now();
+    const {
+      mainPingInterval
+    } = config.mediaCollection;
+    const playerSession = mediaSessionCacheManager.getSession(playerId);
+    if (Math.abs(currentTime - playerSession.latestTriggeredEvent) / 1000 > mainPingInterval) {
+      const {
+        playhead,
+        qoeDataDetails
+      } = onBeforeMediaEvent(playerId);
+      const xdm = {
+        eventType: "media.ping",
+        mediaCollection: {
+          playhead: toInteger(playhead),
+          sessionID: sessionId,
+          qoeDataDetails
+        }
+      };
+      const event = mediaEventManager.createMediaEvent({
+        options: {
+          xdm
+        }
+      });
+      return mediaEventManager.trackMediaEvent({
+        event
+      }).then(() => {
+        mediaSessionCacheManager.updateLastTriggeredEventTS({
+          playerId
+        });
+      });
+    }
+    return Promise.resolve();
+  };
+});

package/libEs6/components/MediaCollection/createMediaEventManager.js

@@ -0,0 +1,122 @@
+/*
+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.
+*/
+/* eslint-disable import/no-restricted-paths */
+
+import MediaEvents from "./mediaConstants/mediaEvents";
+import createMediaRequestPayload from "./createMediaRequestPayload";
+import createMediaRequest from "./createMediaRequest";
+import injectTimestamp from "../Context/injectTimestamp";
+import { deepAssign, toInteger } from "../../utils";
+export default (({
+  config,
+  eventManager,
+  consent,
+  sendEdgeNetworkRequest
+}) => {
+  return {
+    createMediaEvent({
+      options
+    }) {
+      const {
+        xdm = {}
+      } = options;
+      const event = {
+        xdm
+      };
+      const timestamp = injectTimestamp(() => new Date());
+      timestamp(event.xdm);
+      return event;
+    },
+    createMediaSession(options) {
+      const {
+        playerName,
+        channel,
+        version
+      } = config.mediaCollection;
+      const event = eventManager.createEvent();
+      event.setUserXdm(options.xdm);
+      event.mergeXdm({
+        eventType: MediaEvents.SESSION_START,
+        mediaCollection: {
+          sessionDetails: {
+            playerName: options.xdm.mediaCollection.sessionDetails.playerName || playerName,
+            channel: options.xdm.mediaCollection.sessionDetails.channel || channel,
+            appVersion: options.xdm.mediaCollection.sessionDetails.appVersion || version
+          }
+        }
+      });
+      return event;
+    },
+    augmentMediaEvent({
+      event,
+      playerId,
+      onBeforeMediaEvent,
+      sessionID
+    }) {
+      if (!playerId || !onBeforeMediaEvent) {
+        return event;
+      }
+      const {
+        playhead,
+        qoeDataDetails
+      } = onBeforeMediaEvent({
+        playerId
+      });
+      if (event.mergeXdm) {
+        event.mergeXdm({
+          mediaCollection: {
+            playhead: toInteger(playhead),
+            qoeDataDetails
+          }
+        });
+        return event;
+      }
+      return deepAssign(event, {
+        xdm: {
+          mediaCollection: {
+            playhead: toInteger(playhead),
+            qoeDataDetails,
+            sessionID
+          }
+        }
+      });
+    },
+    trackMediaSession({
+      event,
+      playerId,
+      onBeforeMediaEvent
+    }) {
+      return eventManager.sendEvent(event, {
+        playerId,
+        onBeforeMediaEvent
+      });
+    },
+    trackMediaEvent({
+      event
+    }) {
+      const action = event.xdm.eventType.split(".")[1];
+      const mediaRequestPayload = createMediaRequestPayload();
+      const request = createMediaRequest({
+        mediaRequestPayload,
+        action
+      });
+      mediaRequestPayload.addEvent(event);
+      return consent.awaitConsent().then(() => {
+        return sendEdgeNetworkRequest({
+          request
+        }).then(() => {
+          return {};
+        });
+      });
+    }
+  };
+});

package/libEs6/components/MediaCollection/createMediaRequest.js

@@ -0,0 +1,28 @@
+/*
+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 { createRequest } from "../../utils/request";
+export default (({
+  mediaRequestPayload,
+  action
+}) => {
+  return createRequest({
+    payload: mediaRequestPayload,
+    edgeSubPath: "/va",
+    getAction() {
+      return action;
+    },
+    getUseSendBeacon() {
+      return false;
+    }
+  });
+});

package/libEs6/components/MediaCollection/createMediaRequestPayload.js

@@ -0,0 +1,26 @@
+/*
+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 { createAddIdentity, createHasIdentity, createRequestPayload } from "../../utils/request";
+export default (() => {
+  const content = {};
+  const payload = createRequestPayload({
+    content,
+    addIdentity: createAddIdentity(content),
+    hasIdentity: createHasIdentity(content)
+  });
+  payload.addEvent = event => {
+    content.events = content.events || [];
+    content.events.push(event);
+  };
+  return payload;
+});

package/libEs6/components/MediaCollection/createMediaSessionCacheManager.js

@@ -0,0 +1,63 @@
+/*
+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.
+*/
+
+export default (() => {
+  let mediaSessionCache;
+  const getSession = playerId => {
+    return mediaSessionCache[playerId] || {};
+  };
+  const saveHeartbeat = ({
+    playerId,
+    heartbeatId
+  }) => {
+    const mediaSession = mediaSessionCache[playerId];
+    if (!mediaSession) {
+      return;
+    }
+    mediaSession.heartbeatId = heartbeatId;
+  };
+  const stopHeartbeat = ({
+    playerId
+  }) => {
+    const mediaSession = mediaSessionCache[playerId];
+    if (!mediaSession) {
+      return;
+    }
+    clearInterval(mediaSession.heartbeatId);
+    mediaSession.heartbeatId = null;
+  };
+  const updateLastTriggeredEventTS = ({
+    playerId
+  }) => {
+    const player = mediaSessionCache[playerId];
+    if (!player) {
+      return;
+    }
+    player.latestTriggeredEvent = Date.now();
+  };
+  const storeSession = ({
+    playerId,
+    sessionDetails
+  }) => {
+    if (mediaSessionCache === undefined) {
+      mediaSessionCache = {};
+    }
+    mediaSessionCache[playerId] = sessionDetails;
+  };
+  return {
+    getSession,
+    stopHeartbeat,
+    updateLastTriggeredEventTS,
+    storeSession,
+    saveHeartbeat
+  };
+});

package/libEs6/components/MediaCollection/createUpdateMediaSessionState.js

@@ -0,0 +1,36 @@
+/*
+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 MediaEvents from "./mediaConstants/mediaEvents";
+export default (({
+  mediaSessionCacheManager
+}) => {
+  return ({
+    playerId,
+    xdm
+  }) => {
+    if (!playerId) {
+      return;
+    }
+    const {
+      eventType
+    } = xdm;
+    if (eventType === MediaEvents.SESSION_COMPLETE || eventType === MediaEvents.SESSION_END) {
+      mediaSessionCacheManager.stopHeartbeat({
+        playerId
+      });
+    }
+    mediaSessionCacheManager.updateLastTriggeredEventTS({
+      playerId
+    });
+  };
+});

package/libEs6/components/MediaCollection/index.js

@@ -0,0 +1,158 @@
+/*
+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 { string, number, objectOf } from "../../utils/validation";
+import createMediaSessionCacheManager from "./createMediaSessionCacheManager";
+import validateMediaEventOptions from "./validateMediaEventOptions";
+import validateSessionOptions from "./validateMediaSessionOptions";
+import createMediaEventManager from "./createMediaEventManager";
+import { noop } from "../../utils";
+import createHeartbeatEngine from "./createHeartbeatEngine";
+import createUpdateMediaSessionState from "./createUpdateMediaSessionState";
+const createMediaCollection = ({
+  config,
+  logger,
+  eventManager,
+  sendEdgeNetworkRequest,
+  consent
+}) => {
+  const mediaSessionCacheManager = createMediaSessionCacheManager({
+    config
+  });
+  const mediaEventManager = createMediaEventManager({
+    config,
+    eventManager,
+    logger,
+    consent,
+    sendEdgeNetworkRequest
+  });
+  const heartbeatTicker = createHeartbeatEngine({
+    config,
+    mediaEventManager,
+    mediaSessionCacheManager
+  });
+  const updateMediaSessionState = createUpdateMediaSessionState({
+    mediaSessionCacheManager
+  });
+  return {
+    lifecycle: {
+      onBeforeEvent({
+        playerId,
+        onBeforeMediaEvent,
+        onResponse = noop
+      }) {
+        onResponse(({
+          response
+        }) => {
+          const sessionId = response.getPayloadsByType("media-analytics:new-session");
+          logger.info("Media session ID returned: ", sessionId);
+          if (sessionId.length > 0) {
+            if (playerId && onBeforeMediaEvent) {
+              const heartbeatId = setInterval(() => {
+                heartbeatTicker({
+                  sessionId: sessionId[0].sessionId,
+                  playerId,
+                  onBeforeMediaEvent
+                });
+              }, 1000);
+              mediaSessionCacheManager.saveHeartbeat({
+                playerId,
+                heartbeatId
+              });
+            }
+            return {
+              sessionId: sessionId[0].sessionId
+            };
+          }
+          return {};
+        });
+      }
+    },
+    commands: {
+      createMediaSession: {
+        optionsValidator: options => validateSessionOptions({
+          options
+        }),
+        run: options => {
+          const {
+            playerId,
+            onBeforeMediaEvent
+          } = options;
+          const event = mediaEventManager.createMediaSession(options);
+          mediaEventManager.augmentMediaEvent({
+            event,
+            playerId,
+            onBeforeMediaEvent
+          });
+          const sessionPromise = mediaEventManager.trackMediaSession({
+            event,
+            playerId,
+            onBeforeMediaEvent
+          });
+          mediaSessionCacheManager.storeSession({
+            playerId,
+            sessionDetails: {
+              sessionPromise,
+              onBeforeMediaEvent,
+              latestTriggeredEvent: Date.now()
+            }
+          });
+          return sessionPromise;
+        }
+      },
+      sendMediaEvent: {
+        optionsValidator: options => validateMediaEventOptions({
+          options
+        }),
+        run: options => {
+          const event = mediaEventManager.createMediaEvent({
+            options
+          });
+          const {
+            playerId
+          } = options;
+          const {
+            onBeforeMediaEvent,
+            sessionPromise
+          } = mediaSessionCacheManager.getSession(playerId);
+          sessionPromise.then(result => {
+            const finalEvent = mediaEventManager.augmentMediaEvent({
+              event,
+              playerId,
+              onBeforeMediaEvent,
+              sessionID: result.sessionId
+            });
+            return mediaEventManager.trackMediaEvent({
+              event: finalEvent
+            }).then(() => {
+              updateMediaSessionState({
+                playerId,
+                xdm: finalEvent.xdm
+              });
+            });
+          });
+        }
+      }
+    }
+  };
+};
+createMediaCollection.namespace = "Media Collection";
+createMediaCollection.configValidators = objectOf({
+  mediaCollection: objectOf({
+    channel: string().nonEmpty().required(),
+    playerName: string().nonEmpty().required(),
+    version: string(),
+    mainPingInterval: number().minimum(10).maximum(60).default(10),
+    adPingInterval: number().minimum(10).maximum(60).default(10)
+  }).noUnknownFields()
+});
+export default createMediaCollection;

package/libEs6/components/MediaCollection/mediaConstants/mediaEvents.js

@@ -0,0 +1,9 @@
+export default {
+  PAUSE: "media.pauseStart",
+  PLAY: "media.play",
+  BUFFERING: "media.buffering",
+  AD_START: "media.adStart",
+  SESSION_END: "media.sessionEnd",
+  SESSION_START: "media.sessionStart",
+  SESSION_COMPLETE: "media.sessionComplete"
+};

package/libEs6/components/MediaCollection/validateMediaEventOptions.js

@@ -0,0 +1,32 @@
+/*
+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 { anyOf, anything, number, objectOf, string } from "../../utils/validation";
+export default (({
+  options
+}) => {
+  const validator = anyOf([objectOf({
+    playerId: string().required(),
+    xdm: objectOf({
+      eventType: string().required(),
+      mediaCollection: objectOf(anything())
+    }).required()
+  }).required(), objectOf({
+    xdm: objectOf({
+      eventType: string().required(),
+      mediaCollection: objectOf({
+        playhead: number().integer().required(),
+        sessionID: string().required()
+      }).required()
+    }).required()
+  }).required()], "Error validating the sendMediaEvent command options.");
+  return validator(options);
+});

package/libEs6/components/MediaCollection/validateMediaSessionOptions.js

@@ -0,0 +1,34 @@
+/*
+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 { anyOf, anything, callback, number, objectOf, string } from "../../utils/validation";
+export default (({
+  options
+}) => {
+  const sessionValidator = anyOf([objectOf({
+    playerId: string().required(),
+    onBeforeMediaEvent: callback().required(),
+    xdm: objectOf({
+      mediaCollection: objectOf({
+        sessionDetails: objectOf(anything()).required()
+      })
+    })
+  }).required(), objectOf({
+    xdm: objectOf({
+      mediaCollection: objectOf({
+        playhead: number().required(),
+        sessionDetails: objectOf(anything()).required()
+      })
+    })
+  }).required()], "Error validating the createMediaSession command options.");
+  return sessionValidator(options);
+});

package/libEs6/constants/libraryVersion.js

@@ -13,4 +13,4 @@ governing permissions and limitations under the License.
 // The __VERSION__ keyword will be replace at alloy build time with the package.json version.
 // see babel-plugin-version
 
-export default "2.19.1-beta.0";
+export default "2.20.0-alpha.0";

package/libEs6/core/componentCreators.js

@@ -23,7 +23,9 @@ import createEventMerge from "../components/EventMerge";
 import createLibraryInfo from "../components/LibraryInfo";
 import createDecisioningEngine from "../components/DecisioningEngine";
 import createMachineLearning from "../components/MachineLearning";
+import createMediaCollection from "../components/MediaCollection";
+import createLegacyMediaAnalytics from "../components/LegacyMediaAnalytics";
 
 // TODO: Register the Components here statically for now. They might be registered differently.
 // TODO: Figure out how sub-components will be made available/registered
-export default [createDataCollector, createActivityCollector, createIdentity, createAudiences, createPersonalization, createContext, createPrivacy, createEventMerge, createLibraryInfo, createMachineLearning, createDecisioningEngine];
+export default [createDataCollector, createActivityCollector, createIdentity, createAudiences, createPersonalization, createContext, createPrivacy, createEventMerge, createLibraryInfo, createMachineLearning, createDecisioningEngine, createLegacyMediaAnalytics, createMediaCollection];

package/libEs6/core/edgeNetwork/injectSendEdgeNetworkRequest.js

@@ -53,7 +53,7 @@ export default (({
     }).then(() => {
       const endpointDomain = request.getUseIdThirdPartyDomain() ? ID_THIRD_PARTY_DOMAIN : edgeDomain;
       const locationHint = getLocationHint();
-      const edgeBasePathWithLocationHint = locationHint ? `${edgeBasePath}/${locationHint}` : edgeBasePath;
+      const edgeBasePathWithLocationHint = locationHint ? `${edgeBasePath}/${locationHint}${request.getEdgeSubPath()}` : `${edgeBasePath}${request.getEdgeSubPath()}`;
       const configId = request.getDatastreamIdOverride() || datastreamId;
       const payload = request.getPayload();
       if (configId !== datastreamId) {

package/libEs6/utils/request/createRequest.js

@@ -18,7 +18,8 @@ export default (options => {
     payload,
     getAction,
     getUseSendBeacon,
-    datastreamIdOverride
+    datastreamIdOverride,
+    edgeSubPath
   } = options;
   const id = uuid();
   let shouldUseThirdPartyDomain = false;
@@ -43,6 +44,12 @@ export default (options => {
         isIdentityEstablished
       });
     },
+    getEdgeSubPath() {
+      if (edgeSubPath) {
+        return edgeSubPath;
+      }
+      return "";
+    },
     getUseIdThirdPartyDomain() {
       return shouldUseThirdPartyDomain;
     },

package/libEs6/utils/validation/createMaximumValidator.js

@@ -0,0 +1,16 @@
+/*
+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 { assertValid } from "./utils";
+export default ((typeName, maximum) => (value, path) => {
+  assertValid(value <= maximum, value, path, `${typeName} less than or equal to ${maximum}`);
+  return value;
+});

package/libEs6/utils/validation/index.js

@@ -77,6 +77,7 @@ import createDeprecatedValidator from "./createDeprecatedValidator";
 import createLiteralValidator from "./createLiteralValidator";
 import createMapOfValuesValidator from "./createMapOfValuesValidator";
 import createMinimumValidator from "./createMinimumValidator";
+import createMaximumValidator from "./createMaximumValidator";
 import createNoUnknownFieldsValidator from "./createNoUnknownFieldsValidator";
 import createNonEmptyValidator from "./createNonEmptyValidator";
 import createObjectOfValidator from "./createObjectOfValidator";
@@ -113,6 +114,9 @@ const minimumInteger = function minimumInteger(minValue) {
 const minimumNumber = function minimumNumber(minValue) {
   return nullSafeChain(this, createMinimumValidator("a number", minValue));
 };
+const maximumNumber = function maximumNumber(maxValue) {
+  return nullSafeChain(this, createMaximumValidator("a number", maxValue));
+};
 const integer = function integer() {
   return nullSafeChain(this, integerValidator, {
     minimum: minimumInteger
@@ -164,6 +168,7 @@ const literal = function literal(literalValue) {
 const number = function number() {
   return nullSafeChain(this, numberValidator, {
     minimum: minimumNumber,
+    maximum: maximumNumber,
     integer,
     unique
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/alloy",
-  "version": "2.19.1-beta.0",
+  "version": "2.20.0-alpha.0",
   "description": "Adobe Experience Platform Web SDK",
   "main": "libEs5/index.js",
   "module": "libEs6/index.js",
@@ -70,7 +70,7 @@
     "uuid": "^3.3.2"
   },
   "devDependencies": {
-    "@adobe/alloy": "^2.19.0",
+    "@adobe/alloy": "^2.19.1",
     "@babel/cli": "^7.12.8",
     "@babel/core": "^7.2.2",
     "@babel/plugin-proposal-object-rest-spread": "^7.3.2",