@raydiant/playlist-window-manager 0.0.0-test-27 → 0.0.0-test-29

package/src/PresentationWindow.test.ts

@@ -218,4 +218,116 @@ describe('embedded apps', () => {
   });
 });
 
+describe('payments', () => {
+  test('charge request', async () => {
+    const testRenderer = createRenderer();
+
+    const window = createPresentationWindow({
+      windowId: 'test-charge-request',
+      presentation: createPresentation(),
+      applicationVersion: createApplicationVersion({
+        embeddedUrlFormat: 'http://test.local/:input',
+      }),
+      renderer: testRenderer,
+    });
+
+    const callback = jest.fn();
+    window.onChargeRequest(callback);
+
+    await window.load();
+
+    testRenderer.runReceiveMessageCallback('payments-charge-request', {
+      requestId: 'test',
+      amount: 100,
+    });
+
+    expect(callback).toHaveBeenCalledWith({
+      requestId: 'test',
+      amount: 100,
+    });
+
+    // Send charge response.
+
+    window.sendChargeResponse({
+      requestId: 'test',
+      charge: { id: '1', status: 'pending' },
+    });
+
+    expect(testRenderer.sendMessageObject).toHaveBeenCalledWith(
+      'test-charge-request',
+      'payments-charge-response',
+      { requestId: 'test', charge: { id: '1', status: 'pending' } }
+    );
+  });
+
+  test('subscribe to charge', async () => {
+    const testRenderer = createRenderer();
+
+    const window = createPresentationWindow({
+      windowId: 'test-payments-subscribe-charge',
+      presentation: createPresentation(),
+      applicationVersion: createApplicationVersion({
+        embeddedUrlFormat: 'http://test.local/:input',
+      }),
+      renderer: testRenderer,
+    });
+
+    await window.load();
+
+    testRenderer.runReceiveMessageCallback('payments-subscribe', 'charge');
+
+    window.sendCharge({ id: 'test', status: 'success' });
+
+    expect(testRenderer.sendMessageObject).toHaveBeenCalledWith(
+      'test-payments-subscribe-charge',
+      'payments-charge-event',
+      { charge: { id: 'test', status: 'success' } }
+    );
+
+    // Unsubscribe should not send a message.
+    testRenderer.runReceiveMessageCallback('payments-unsubscribe', 'charge');
+    window.sendCharge({ id: 'test2', status: 'success' });
+    expect(testRenderer.sendMessageObject).toHaveBeenCalledTimes(1);
+  });
+
+  test('subscribe to terminal', async () => {
+    const testRenderer = createRenderer();
+
+    const window = createPresentationWindow({
+      windowId: 'test-payments-subscribe-terminal',
+      presentation: createPresentation(),
+      applicationVersion: createApplicationVersion({
+        embeddedUrlFormat: 'http://test.local/:input',
+      }),
+      renderer: testRenderer,
+      getTerminal: () => null,
+    });
+
+    await window.load();
+
+    testRenderer.runReceiveMessageCallback('payments-subscribe', 'terminal');
+
+    // Terminal subscriptions should receive the current terminal immediately after subscribing.
+    expect(testRenderer.sendMessageObject).toHaveBeenCalledWith(
+      'test-payments-subscribe-terminal',
+      'payments-terminal-event',
+      { terminal: null }
+    );
+
+    // Send terminal update event.
+    window.sendTerminal({ status: 'open' });
+
+    expect(testRenderer.sendMessageObject).toHaveBeenCalledWith(
+      'test-payments-subscribe-terminal',
+      'payments-terminal-event',
+      { terminal: { status: 'open' } }
+    );
+
+    // Unsubscribe should not send a message.
+    testRenderer.runReceiveMessageCallback('payments-unsubscribe', 'terminal');
+    window.sendTerminal({ status: 'closed' });
+    expect(testRenderer.sendMessageObject).toHaveBeenCalledTimes(2);
+  });
+});
+
 // TODO: Backfill tests for all legacy and embedded apps.

package/src/PresentationWindow.ts

@@ -20,6 +20,10 @@ import {
   EmbeddedAppMetadata,
   AnalyticsEvent,
   PreviewState,
+  Charge,
+  ChargeRequest,
+  ChargeResponse,
+  Terminal,
 } from './types';
 
 export interface PresentationWindowOptions {
@@ -52,6 +56,7 @@ export interface PresentationWindowOptions {
     properties: any[],
     string: { [key: string]: string }
   ) => void;
+  getTerminal?: () => Terminal | null;
 }
 
 // TODO: Automatically inject latest version when building in CI.
@@ -69,32 +74,46 @@ const isValidAnalyticsEvent = (value: any): value is AnalyticsEvent =>
     value.productCategory === undefined ||
     value.productCategory === null);
 
+const isValidChargeRequest = (value: any): value is ChargeRequest =>
+  value &&
+  typeof value === 'object' &&
+  typeof value.requestId === 'string' &&
+  typeof value.amount === 'number' &&
+  (value.tags === undefined ||
+    value.tags === null ||
+    typeof value.tags === 'object') &&
+  (value.idempotencyId === undefined ||
+    value.idempotencyId === null ||
+    typeof value.idempotencyId === 'string');
+
 export default class PresentationWindow {
-  private didReceiveReady = false;
+  private didReceiveReady: boolean = false;
   private readyCallback: (() => void) | null = null;
-  private didReceiveComplete = false;
+  private didReceiveComplete: boolean = false;
   private completeCallback: (() => void) | null = null;
   private errorCallback: ((err: Error) => void) | null = null;
   private readyTimeout: ReturnType<typeof setTimeout> | null = null;
   private windowManagers: { [windowId: string]: PlaylistWindowManager } = {};
   private focusedWindowManager: PlaylistWindowManager | null = null;
-  private didEmbeddedAppLoad = false;
+  private didEmbeddedAppLoad: boolean = false;
   private lastPlayedAt: Date | null = null;
   private configurableDurationTimeout: ReturnType<typeof setTimeout> | null =
     null;
-  private isWindowLocked = false;
+  private isWindowLocked: boolean = false;
   private isChildWindowLocked: { [windowId: string]: boolean } = {};
   private enableInterruptLockCallback: (() => void) | null = null;
   private disableInterruptLockCallback: (() => void) | null = null;
   private analyticsEventCallback: ((event: AnalyticsEvent) => void) | null =
     null;
+  private chargeRequestCallback: ((request: ChargeRequest) => void) | null =
+    null;
 
   private builderState: BuilderState | undefined;
   private presentation: Presentation;
   private playlistWindowManagerState: PlaylistWindowManagerState;
   private ruleEngineState: RE.State;
   private theme: Theme | undefined;
-  private forceMute = false;
+  private forceMute: boolean = false;
   private error: Error | null = null;
 
   private workerState: WorkerState = {};
@@ -102,6 +121,7 @@ export default class PresentationWindow {
   private runtimeSubscriptions = new Set<string>();
   private previewSubscriptions = new Set<string>();
   private previewState: PreviewState = { inputs: {} };
+  private paymentSubscriptions = new Set<string>();
 
   private createObjectURLResolvers: Record<string, (url: string) => void> = {};
   private createObjectURLTimeouts: Record<
@@ -126,7 +146,7 @@ export default class PresentationWindow {
     return this.loadLegacyApp();
   }
 
-  public show(isFocused = true): void {
+  public show(isFocused: boolean = true): void {
     const { windowId, renderer } = this.options;
 
     // Show the main window and focus it before any child windows. Showing a child
@@ -288,6 +308,10 @@ export default class PresentationWindow {
     this.analyticsEventCallback = callback;
   }
 
+  public onChargeRequest(callback: ((request: ChargeRequest) => void) | null) {
+    this.chargeRequestCallback = callback;
+  }
+
   public isReady() {
     // TODO: To support the 'ready' event in embedded apps, they will need to tell the
     // runtime that it should wait for ready instead of DOMLoaded. This could be a "wait
@@ -394,6 +418,42 @@ export default class PresentationWindow {
     return URL.createObjectURL(blob);
   }
 
+  public sendChargeResponse(response: ChargeResponse) {
+    // TODO: Instead of sending the charge to all windows, we should only send it to the app
+    // that requested the charge. We probably don't want to use the windowId to avoid missing
+    // the events in case the window was closed/restarted. Since we are only sending the charge
+    // id and status this seems ok for now but need to be mindful of sending any sensitive data.
+    this.sendMessageObject('payments-charge-response', {
+      requestId: response.requestId,
+      charge: response.charge,
+      error: response.error,
+    });
+    // Forward the event to the child window managers.
+    Object.values(this.windowManagers).forEach((wm) =>
+      wm.sendChargeResponse(response)
+    );
+  }
+
+  public sendCharge(charge: Charge) {
+    // TODO: Instead of sending the charge to all windows, we should only send it to the app
+    // that requested the charge.
+    if (this.paymentSubscriptions.has('charge')) {
+      this.sendMessageObject('payments-charge-event', { charge });
+    }
+    // Forward the event to the child window managers.
+    Object.values(this.windowManagers).forEach((wm) => wm.sendCharge(charge));
+  }
+
+  public sendTerminal(terminal: Terminal | null) {
+    if (this.paymentSubscriptions.has('terminal')) {
+      this.sendMessageObject('payments-terminal-event', { terminal });
+    }
+    // Forward the event to the child window managers.
+    Object.values(this.windowManagers).forEach((wm) =>
+      wm.sendTerminal(terminal)
+    );
+  }
+
   private isEmbeddedApp() {
     const { applicationVersion, isPreview } = this.options;
 
@@ -490,19 +550,12 @@ export default class PresentationWindow {
     backgroundColor?: string,
     receiveMessageCallback?: (type: string, payload?: any) => void
   ) {
-    const { windowId, parentWindowId, renderer, bounds, logger } = this.options;
-
-    logger.info(
-      `playlist-window-manager/src/PresentationWindow.ts createAndLoadWindow1: ${JSON.stringify(
-        bounds
-      )}`
-    );
+    const { windowId, parentWindowId, renderer, bounds } = this.options;
 
     renderer.createWindow({
       windowId,
       parentWindowId,
       bounds,
-      logger,
       backgroundColor,
       receiveMessageCallback,
       errorCallback: this.handleError,
@@ -646,8 +699,8 @@ export default class PresentationWindow {
     windowName: string,
     playlistId: string,
     bounds: WindowBounds,
-    forceMute = false,
-    isFocused = false,
+    forceMute: boolean = false,
+    isFocused: boolean = false,
     themeOverride?: any
   ) {
     const {
@@ -673,18 +726,7 @@ export default class PresentationWindow {
         ? !deepEqual(bounds, prevBounds)
         : true;
 
-      this.logInfo(
-        `playlist-window-manager/src/PresentationWindow.ts openChildWindow1: ${JSON.stringify(
-          prevBounds
-        )}`
-      );
-
       if (didBoundsChange) {
-        this.logInfo(
-          `playlist-window-manager/src/PresentationWindow.ts openChildWindow2: ${JSON.stringify(
-            bounds
-          )}`
-        );
         windowManager.updateBounds(bounds);
       }
 
@@ -711,11 +753,6 @@ export default class PresentationWindow {
         );
       }
     } else {
-      this.logInfo(
-        `playlist-window-manager/src/PresentationWindow.ts openChildWindow3: ${JSON.stringify(
-          bounds
-        )}`
-      );
       windowManager = new PlaylistWindowManager({
         parentWindowId: windowId,
         windowName,
@@ -737,6 +774,7 @@ export default class PresentationWindow {
         isPreview,
         onEnableInterruptLock: () => this.enableInteruptLock(windowName),
         onDisableInterruptLock: () => this.disableInteruptLock(windowName),
+        getTerminal: this.options.getTerminal,
       });
 
       // Hook up child window manager events to bubble up to the parent.
@@ -756,6 +794,9 @@ export default class PresentationWindow {
         windowManager.on('window_analytics_event', (metadata) => {
           parentWindowManager.emit('window_analytics_event', metadata);
         });
+        windowManager.on('window_charge_request', (metadata) => {
+          parentWindowManager.emit('window_charge_request', metadata);
+        });
       }
 
       this.windowManagers[windowName] = windowManager;
@@ -940,8 +981,14 @@ export default class PresentationWindow {
       }
 
       case 'analytics-event': {
-        if (this.analyticsEventCallback && isValidAnalyticsEvent(payload)) {
-          this.analyticsEventCallback(payload);
+        if (isValidAnalyticsEvent(payload)) {
+          if (this.analyticsEventCallback) {
+            this.analyticsEventCallback(payload);
+          }
+        } else {
+          this.logWarning(
+            `Invalid payload for analytics-event message: ${payload}`
+          );
         }
         break;
       }
@@ -996,6 +1043,53 @@ export default class PresentationWindow {
         break;
       }
 
+      case 'payments-charge-request': {
+        if (isValidChargeRequest(payload)) {
+          if (this.chargeRequestCallback) {
+            this.chargeRequestCallback(payload);
+          }
+        } else {
+          this.logWarning(
+            `Invalid payload for payments-charge-request message: ${payload}`
+          );
+        }
+        break;
+      }
+
+      case 'payments-subscribe': {
+        if (typeof payload === 'string') {
+          this.logInfo(`Received 'worker-subscribe' from window '${windowId}'`);
+          // The payload is the payment subscription type (ex. 'charge', 'terminal')
+          this.paymentSubscriptions.add(payload);
+
+          // Immediately send terminal when subscribing.
+          if (payload === 'terminal' && this.options.getTerminal) {
+            this.sendMessageObject('payments-terminal-event', {
+              terminal: this.options.getTerminal(),
+            });
+          }
+        } else {
+          this.logWarning(
+            `Invalid payload for payments-subscribe message: ${payload}`
+          );
+        }
+        break;
+      }
+
+      case 'payments-unsubscribe': {
+        if (typeof payload === 'string') {
+          this.logInfo(
+            `Received 'payments-unsubscribe' from window '${windowId}'`
+          );
+          this.paymentSubscriptions.delete(payload);
+        } else {
+          this.logWarning(
+            `Invalid payload for payments-unsubscribe message: ${payload}`
+          );
+        }
+        break;
+      }
+
       default: {
         this.logWarning(`Received unknown embedded message type: ${type}`);
       }

package/src/testUtils.ts

@@ -38,6 +38,7 @@ export function createPresentationWindow(
       muteWindow() {},
       unMuteWindow() {},
     },
+    getTerminal: overrides.getTerminal,
   });
 }
 

package/src/types.ts

@@ -86,7 +86,6 @@ export interface CreateWindowOptions {
   windowId: string;
   parentWindowId?: string;
   bounds?: WindowBounds;
-  logger: Logger;
   backgroundColor?: string;
 
   // Called when attaching a message listener to the inner window.
@@ -174,3 +173,27 @@ export interface AnalyticsEvent {
   source: string;
   productCategory?: string | null;
 }
+
+export interface ChargeRequest {
+  requestId: string;
+  amount: number;
+  tags?: Record<string, undefined | null | boolean | number | string>;
+  idempotencyId?: string;
+}
+
+export interface Charge {
+  id: string;
+  status: string;
+}
+
+export interface ChargeResponse {
+  requestId: string;
+  charge?: Charge;
+  error?: {
+    message: string;
+  };
+}
+
+export interface Terminal {
+  status: string;
+}

package/tasks/npm-publish.sh

@@ -10,4 +10,4 @@ mkdir build
 yarn build
 
 # Publish
-yarn publish  --access public
+yarn publish --non-interactive --access public

package/build/boundUtils.d.ts

@@ -1,3 +0,0 @@
-import { WindowBounds } from './types';
-export declare const isFullscreen: (bounds: WindowBounds) => boolean;
-export declare const areBoundsEqual: (bounds1: WindowBounds, bounds2: WindowBounds) => boolean;

package/build/boundUtils.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.areBoundsEqual = exports.isFullscreen = void 0;
-var electron_1 = require("electron");
-var isFullscreen = function (bounds) {
-    var screenBounds = electron_1.screen.getPrimaryDisplay().bounds;
-    return (bounds.width === screenBounds.width && bounds.height === screenBounds.height);
-};
-exports.isFullscreen = isFullscreen;
-var areBoundsEqual = function (bounds1, bounds2) {
-    return (bounds1.x === bounds2.x &&
-        bounds1.y === bounds2.y &&
-        bounds1.width === bounds2.width &&
-        bounds1.height === bounds2.height);
-};
-exports.areBoundsEqual = areBoundsEqual;

package/src/boundUtils.ts

@@ -1,21 +0,0 @@
-import { screen } from 'electron';
-import { WindowBounds } from './types';
-
-export const isFullscreen = (bounds: WindowBounds): boolean => {
-  const screenBounds = screen.getPrimaryDisplay().bounds;
-  return (
-    bounds.width === screenBounds.width && bounds.height === screenBounds.height
-  );
-};
-
-export const areBoundsEqual = (
-  bounds1: WindowBounds,
-  bounds2: WindowBounds
-): boolean => {
-  return (
-    bounds1.x === bounds2.x &&
-    bounds1.y === bounds2.y &&
-    bounds1.width === bounds2.width &&
-    bounds1.height === bounds2.height
-  );
-};