@vouchfor/embeds 0.0.0-experiment.2ab669a → 0.0.0-experiment.2e18d0d

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vouchfor/embeds",
-  "version": "0.0.0-experiment.2ab669a",
+  "version": "0.0.0-experiment.2e18d0d",
   "license": "MIT",
   "author": "Aaron Williams",
   "main": "dist/es/embeds.js",
@@ -36,11 +36,11 @@
   },
   "dependencies": {
     "@lit/task": "^1.0.0",
-    "@vouchfor/media-player": "0.0.0-experiment.2ab669a",
+    "@vouchfor/media-player": "0.0.0-experiment.2e18d0d",
     "uuid": "^9.0.1"
   },
   "peerDependencies": {
-    "lit": "^3.0.2"
+    "lit": "^3.1.0"
   },
   "devDependencies": {
     "@esm-bundle/chai": "^4.3.4-fix.0",
@@ -62,7 +62,7 @@
     "eslint": "^8.50.0",
     "eslint-plugin-import": "^2.28.1",
     "lint-staged": "^14.0.1",
-    "lit": "^2.8.0",
+    "lit": "^3.1.0",
     "prettier": "^3.0.3",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",

package/src/components/Embed/Embed.stories.ts

@@ -39,10 +39,10 @@ type Story = StoryObj<EmbedArgs>;
 
 const Embed: Story = {
   args: {
-    env: 'dev',
+    env: 'local',
     apiKey: 'TVik9uTMgE-PD25UTHIS6gyl0hMBWC7AT4dkpdlLBT4VIfDWZJrQiCk6Ak7m1',
     vouchId: '6JQEIPeStt',
-    templateId: '7d0113f7-3f9a-4bdd-97e3-07ee6eec5730',
+    templateId: '357fc118-e179-4171-9446-ff2b8e9d1b29',
     aspectRatio: 0,
     preload: 'none',
     autoplay: false
@@ -50,7 +50,7 @@ const Embed: Story = {
   argTypes: {
     env: {
       control: 'radio',
-      options: ['prod', 'staging', 'dev']
+      options: ['local', 'dev', 'staging', 'prod']
     },
     preload: {
       control: 'radio',

package/src/components/Embed/controllers/fetcher.ts

@@ -1,4 +1,5 @@
 import { Task } from '@lit/task';
+import { v4 as uuidv4 } from 'uuid';
 
 import type { Embed, EmbedProps } from '..';
 import type { ReactiveControllerHost } from 'lit';
@@ -31,23 +32,67 @@ class FetcherController {
     return this._fetching;
   }
 
-  private async getVouch(env: Environment, apiKey: string, vouchId: string) {
+  private getVouch = async (env: Environment, apiKey: string, vouchId: string) => {
     const { embedApiUrl } = getEnvUrls(env);
 
-    return fetch(`${embedApiUrl}/vouches/${vouchId}`, {
+    const cacheCheck = uuidv4();
+    const res = await fetch(`${embedApiUrl}/vouches/${vouchId}`, {
       method: 'GET',
-      headers: [['X-Api-Key', apiKey]]
-    }).then((response) => response.json());
-  }
+      headers: [
+        ['X-Api-Key', apiKey],
+        ['X-Cache-Check', cacheCheck]
+      ]
+    });
+
+    const vouch = await res.json();
+    this.host.dispatchEvent(new CustomEvent('vouch:loaded', { detail: vouchId }));
+
+    // HACK: we're currently using API Gateway caching on the embed API without any invalidation logic,
+    // so to ensure that the cache stays up to date, whenever we detect a cache hit we trigger another
+    // API call with the `Cache-Control` header which will re-fill the cache
+    const resCacheCheck = res?.headers?.get('X-Cache-Check');
+    if (resCacheCheck && resCacheCheck !== cacheCheck) {
+      fetch(`${embedApiUrl}/vouches/${vouchId}`, {
+        method: 'GET',
+        headers: [
+          ['X-Api-Key', apiKey],
+          ['Cache-Control', 'max-age=0']
+        ]
+      });
+    }
+
+    return vouch;
+  };
 
-  private async getTemplate(env: Environment, apiKey: string, templateId: string) {
+  private getTemplate = async (env: Environment, apiKey: string, templateId: string) => {
     const { embedApiUrl } = getEnvUrls(env);
 
-    return fetch(`${embedApiUrl}/templates/${templateId}`, {
+    const cacheCheck = uuidv4();
+    const res = await fetch(`${embedApiUrl}/templates/${templateId}`, {
       method: 'GET',
-      headers: [['X-Api-Key', apiKey]]
-    }).then((response) => response.json());
-  }
+      headers: [
+        ['X-Api-Key', apiKey],
+        ['X-Cache-Check', cacheCheck]
+      ]
+    });
+    const template = await res.json();
+
+    // HACK: we're currently using API Gateway caching on the embed API without any invalidation logic,
+    // so to ensure that the cache stays up to date, whenever we detect a cache hit we trigger another
+    // API call with the `Cache-Control` header which will re-fill the cache
+    const resCacheCheck = res?.headers?.get('X-Cache-Check');
+    if (resCacheCheck && resCacheCheck !== cacheCheck) {
+      fetch(`${embedApiUrl}/templates/${templateId}`, {
+        method: 'GET',
+        headers: [
+          ['X-Api-Key', apiKey],
+          ['Cache-Control', 'max-age=0']
+        ]
+      });
+    }
+
+    return template;
+  };
 
   constructor(host: EmbedHost) {
     this.host = host;

package/src/components/Embed/controllers/tracking.ts

@@ -6,13 +6,13 @@ import type { ReactiveController, ReactiveControllerHost } from 'lit';
 
 import { getEnvUrls } from '~/utils/env';
 
-const STREAMED_THROTTLE = 2000;
+// In seconds due to checking against node.currentTime
+const STREAMED_THROTTLE = 10;
 
 type EmbedHost = ReactiveControllerHost & Embed;
 
 type TrackingEvent = 'VOUCH_LOADED' | 'VOUCH_RESPONSE_VIEWED' | 'VIDEO_PLAYED' | 'VIDEO_STREAMED';
 type TrackingPayload = {
-  vouchId: string;
   answerId?: string;
   streamStart?: number;
   streamEnd?: number;
@@ -36,8 +36,9 @@ class TrackingController implements ReactiveController {
   private _hasPlayed = false;
   private _hasLoaded: BooleanMap = {};
   private _answersViewed: BooleanMap = {};
-  private _streamedTime: TimeMap = {};
-  private _streamedPrevTimestamp: TimeMap = {};
+  private _streamStartTime: TimeMap = {};
+  private _streamLatestTime: TimeMap = {};
+  private _currentlyPlayingVideo: VideoEventDetail | null = null;
 
   constructor(host: EmbedHost) {
     this.host = host;
@@ -45,11 +46,11 @@ class TrackingController implements ReactiveController {
   }
 
   private _findVouchId() {
-    if (this.host.data) {
-      if ('uuid' in this.host.data) {
-        return this.host.data.uuid;
+    if (this.host.vouch) {
+      if ('uuid' in this.host.vouch) {
+        return this.host.vouch.uuid;
       }
-      return this.host.data.id;
+      return this.host.vouch.id;
     }
   }
 
@@ -116,7 +117,7 @@ class TrackingController implements ReactiveController {
     });
 
     return {
-      source: 'media_player',
+      source: this.host.trackingSource,
       time: new Date(),
       region,
       country,
@@ -128,11 +129,16 @@ class TrackingController implements ReactiveController {
     };
   };
 
-  private _sendTrackingEvent = (event: TrackingEvent, payload: TrackingPayload) => {
+  private _sendTrackingEvent = (event: TrackingEvent, payload?: TrackingPayload) => {
+    const vouchId = this._findVouchId();
+
+    if (!vouchId || this.host.disableTracking) {
+      return;
+    }
+
     const { publicApiUrl } = getEnvUrls(this.host.env);
     const { client, tab, request, visitor } = this._getUids();
 
-    // Don't send tracking if we don't have a source
     navigator.sendBeacon(
       `${publicApiUrl}/api/events`,
       JSON.stringify({
@@ -156,87 +162,74 @@ class TrackingController implements ReactiveController {
 
     // Only send loaded event once per session
     if (!this._hasLoaded[vouchId]) {
-      this._sendTrackingEvent('VOUCH_LOADED', {
-        vouchId
-      });
+      this._sendTrackingEvent('VOUCH_LOADED');
       this._hasLoaded[vouchId] = true;
     }
   };
 
   private _handlePlay = () => {
-    const vouchId = this._findVouchId();
-
-    if (!vouchId) {
-      return;
-    }
-
     // Only send the video played event once per session
     if (!this._hasPlayed) {
       this._sendTrackingEvent('VIDEO_PLAYED', {
-        vouchId,
         streamStart: this.host.currentTime
       });
       this._hasPlayed = true;
     }
   };
 
-  private _handleVideoPlay = ({ detail: { id, node } }: CustomEvent<VideoEventDetail>) => {
-    const vouchId = this._findVouchId();
-    if (!vouchId) {
-      return;
-    }
+  private _handleVideoPlay = ({ detail: { id, key, node } }: CustomEvent<VideoEventDetail>) => {
     // Only increment play count once per session
-    if (!this._answersViewed[id]) {
+    if (!this._answersViewed[key]) {
       this._sendTrackingEvent('VOUCH_RESPONSE_VIEWED', {
-        vouchId,
         answerId: id
       });
-      this._answersViewed[id] = true;
+      this._answersViewed[key] = true;
     }
-    this._streamedTime[id] = node.currentTime;
-    this._streamedPrevTimestamp[id] = Date.now();
+
+    this._streamStartTime[key] = node.currentTime;
+    this._streamLatestTime[key] = node.currentTime;
   };
 
-  private _handleVideoTimeUpdate = ({ detail: { id, node } }: CustomEvent<VideoEventDetail>) => {
-    const vouchId = this._findVouchId();
-    if (!vouchId) {
-      return;
+  private _handleVideoTimeUpdate = ({ detail: { id, key, node } }: CustomEvent<VideoEventDetail>) => {
+    // We only want to count any time that the video is actually playing
+    if (!this.host.paused) {
+      this._currentlyPlayingVideo = { id, key, node };
+      this._streamLatestTime[key] = node.currentTime;
     }
-    const currentTimestamp = Date.now();
+
     if (
+      !node.paused &&
       !this.host.paused &&
       // Only fire the video seeked event when this video is the active one
       id === this.host.scene?.video?.id &&
       // Throttle the frequency that we send streamed events while playing
-      currentTimestamp - this._streamedPrevTimestamp[id] > STREAMED_THROTTLE
+      this._streamLatestTime[key] - this._streamStartTime[key] > STREAMED_THROTTLE
     ) {
       this._sendTrackingEvent('VIDEO_STREAMED', {
-        vouchId,
         answerId: id,
-        streamStart: this._streamedTime[id],
-        streamEnd: node.currentTime
+        streamStart: this._streamStartTime[key],
+        streamEnd: this._streamLatestTime[key]
       });
-      this._streamedTime[id] = node.currentTime;
-      this._streamedPrevTimestamp[id] = currentTimestamp;
+
+      this._streamStartTime[key] = node.currentTime;
     }
   };
 
-  private _handleVideoPause = ({ detail: { id, node } }: CustomEvent<VideoEventDetail>) => {
-    const vouchId = this._findVouchId();
-    if (!vouchId) {
-      return;
+  private _handleVideoPause = ({ detail: { id, key } }: CustomEvent<VideoEventDetail>) => {
+    // Don't send a tracking event when seeking backwards
+    if (this._streamLatestTime[key] > this._streamStartTime[key]) {
+      // Send a video streamed event any time the video pauses then reset the streamed state
+      // We do this to capture the last bit of time that the video was played between the previous
+      // stream event and the video being paused manually or stopping because it ended
+      this._sendTrackingEvent('VIDEO_STREAMED', {
+        answerId: id,
+        streamStart: this._streamStartTime[key],
+        streamEnd: this._streamLatestTime[key]
+      });
     }
-    // Send a video streamed event any time the video pauses then reset the streamed state
-    // We do this to capture the last bit of time that the video was played between the previous
-    // stream event and the video being paused manually or stopping because it ended
-    this._sendTrackingEvent('VIDEO_STREAMED', {
-      vouchId,
-      answerId: id,
-      streamStart: this._streamedTime[id],
-      streamEnd: node.currentTime
-    });
-    delete this._streamedTime[id];
-    delete this._streamedPrevTimestamp[id];
+    this._currentlyPlayingVideo = null;
+    delete this._streamStartTime[key];
+    delete this._streamLatestTime[key];
   };
 
   hostConnected() {
@@ -250,6 +243,20 @@ class TrackingController implements ReactiveController {
   }
 
   hostDisconnected() {
+    if (this._currentlyPlayingVideo) {
+      const { id, key } = this._currentlyPlayingVideo;
+      if (this._streamLatestTime[key] > this._streamStartTime[key]) {
+        // Send a video streamed event any time the video pauses then reset the streamed state
+        // We do this to capture the last bit of time that the video was played between the previous
+        // stream event and the video being paused manually or stopping because it ended
+        this._sendTrackingEvent('VIDEO_STREAMED', {
+          answerId: id,
+          streamStart: this._streamStartTime[key],
+          streamEnd: this._streamLatestTime[key]
+        });
+      }
+    }
+
     this.host.removeEventListener('vouch:loaded', this._handleVouchLoaded);
     this.host.mediaPlayer?.removeEventListener('play', this._handlePlay);
     this.host.mediaPlayer?.removeEventListener('video:play', this._handleVideoPlay);

package/src/components/Embed/index.ts

@@ -17,6 +17,8 @@ import '@vouchfor/media-player';
 type EmbedProps = Pick<MediaPlayerProps, 'data' | 'aspectRatio' | 'preload' | 'autoplay' | 'controls'> & {
   env: Environment;
   apiKey: string;
+  disableTracking?: boolean;
+  trackingSource?: string;
   vouchId?: string;
   templateId?: string;
 };
@@ -31,6 +33,8 @@ class Embed extends LitElement {
 
   @property({ type: String }) env: EmbedProps['env'] = 'prod';
   @property({ type: String }) apiKey: EmbedProps['apiKey'] = '';
+  @property({ type: Boolean }) disableTracking: EmbedProps['disableTracking'] = false;
+  @property({ type: String }) trackingSource: EmbedProps['trackingSource'] = 'embed';
 
   @property({ type: Array }) controls: EmbedProps['controls'];
   @property({ type: String }) preload: EmbedProps['preload'] = 'auto';
@@ -55,6 +59,7 @@ class Embed extends LitElement {
     'waiting',
 
     'video:loadeddata',
+    'video:seeking',
     'video:seeked',
     'video:play',
     'video:playing',

package/src/utils/env.ts

@@ -1,15 +1,11 @@
-type Environment = 'dev' | 'staging' | 'prod';
+type Environment = 'local' | 'dev' | 'staging' | 'prod';
 
 type GetEnvUrlsReturn = {
-  marketingUrl: string;
   videoUrl: string;
   publicApiUrl: string;
   embedApiUrl: string;
-  publicRecorderUrl: string;
 };
 
-const marketingUrl = 'https://vouchfor.com';
-
 const devVideoUrl = 'https://d2rxhdlm2q91uk.cloudfront.net';
 const stagingVideoUrl = 'https://d1ix11aj5kfygl.cloudfront.net';
 const prodVideoUrl = 'https://d157jlwnudd93d.cloudfront.net';
@@ -18,61 +14,51 @@ const devPublicApiUrl = 'https://bshyfw4h5a.execute-api.ap-southeast-2.amazonaws
 const stagingPublicApiUrl = 'https://gyzw7rpbq3.execute-api.ap-southeast-2.amazonaws.com/staging';
 const prodPublicApiUrl = 'https://vfcjuim1l3.execute-api.ap-southeast-2.amazonaws.com/prod';
 
+const localEmbedApiUrl = 'http://localhost:6060/v2';
 const devEmbedApiUrl = 'https://embed-dev.vouchfor.com/v2';
 const stagingEmbedApiUrl = 'https://embed-staging.vouchfor.com/v2';
 const prodEmbedApiUrl = 'https://embed.vouchfor.com/v2';
 
-const devPublicRecorderUrl = 'https://dev.vouchfor.com';
-const stagingPublicRecorderUrl = 'https://staging.vouchfor.com';
-const prodPublicRecorderUrl = 'https://app.vouchfor.com';
-
 // We are handling the case where env is an unknown string so the ts error is a lie
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 function getEnvUrls(env: Environment): GetEnvUrlsReturn {
-  if (!['dev', 'staging', 'prod'].includes(env)) {
+  if (!['local', 'dev', 'staging', 'prod'].includes(env)) {
     throw new Error(`Unknown environment: ${env}`);
   }
 
+  if (env === 'local') {
+    return {
+      videoUrl: devVideoUrl,
+      publicApiUrl: devPublicApiUrl,
+      embedApiUrl: localEmbedApiUrl
+    };
+  }
+
   if (env === 'dev') {
     return {
-      marketingUrl,
       videoUrl: devVideoUrl,
       publicApiUrl: devPublicApiUrl,
-      embedApiUrl: devEmbedApiUrl,
-      publicRecorderUrl: devPublicRecorderUrl
+      embedApiUrl: devEmbedApiUrl
     };
   }
 
   if (env === 'staging') {
     return {
-      marketingUrl,
       videoUrl: stagingVideoUrl,
       publicApiUrl: stagingPublicApiUrl,
-      embedApiUrl: stagingEmbedApiUrl,
-      publicRecorderUrl: stagingPublicRecorderUrl
+      embedApiUrl: stagingEmbedApiUrl
     };
   }
 
   if (env === 'prod') {
     return {
-      marketingUrl,
       videoUrl: prodVideoUrl,
       publicApiUrl: prodPublicApiUrl,
-      embedApiUrl: prodEmbedApiUrl,
-      publicRecorderUrl: prodPublicRecorderUrl
+      embedApiUrl: prodEmbedApiUrl
     };
   }
 }
 
-export {
-  marketingUrl,
-  devEmbedApiUrl,
-  stagingEmbedApiUrl,
-  prodEmbedApiUrl,
-  devPublicRecorderUrl,
-  stagingPublicRecorderUrl,
-  prodPublicRecorderUrl,
-  getEnvUrls
-};
+export { devEmbedApiUrl, stagingEmbedApiUrl, prodEmbedApiUrl, getEnvUrls };
 export type { Environment };

package/dist/es/components/Embed/controllers/event-forwarder.d.ts

@@ -1,14 +0,0 @@
-import type { Embed } from '..';
-import type { ReactiveController, ReactiveControllerHost } from 'lit';
-type EmbedHost = ReactiveControllerHost & Embed;
-declare class EventForwardController implements ReactiveController {
-    host: EmbedHost;
-    private _events;
-    private _cleanup;
-    private _forwardElementRef;
-    constructor(host: EmbedHost, events: string[]);
-    register(): import("lit-html/directive.js").DirectiveResult<typeof import("lit-html/directives/ref.js").RefDirective>;
-    hostConnected(): void;
-    hostDisconnected(): void;
-}
-export { EventForwardController };