Merge branch 'release-candidate' into release

Author: AntonLantukh

CHANGELOG.md

@@ -1,3 +1,19 @@
+## [6.6.0](https://github.com/jwplayer/ott-web-app/compare/v6.5.0...v6.6.0) (2024-09-06)
+
+
+### Features
+
+* **project:** add injectable wrapper to common components ([#598](https://github.com/jwplayer/ott-web-app/issues/598)) ([a6ad0d8](https://github.com/jwplayer/ott-web-app/commit/a6ad0d88b0e7cdc36548867870c8eb3c014f1ad2))
+* **project:** app metadata insertion ([3753a9c](https://github.com/jwplayer/ott-web-app/commit/3753a9c352289620af6ec597fb5f474d7b8ac6d4))
+* **project:** remove free and productIds from content-types.json ([#605](https://github.com/jwplayer/ott-web-app/issues/605)) ([2268447](https://github.com/jwplayer/ott-web-app/commit/226844726061184252af24fabc8340e8539230b6))
+
+
+### Bug Fixes
+
+* **e2e:** fix tests after cleeng api update ([#606](https://github.com/jwplayer/ott-web-app/issues/606)) ([9062dba](https://github.com/jwplayer/ott-web-app/commit/9062dba9184561b5af399e25632f4fe132960223))
+* **search:** override search query cache ([#594](https://github.com/jwplayer/ott-web-app/issues/594)) ([1c25ad2](https://github.com/jwplayer/ott-web-app/commit/1c25ad2cd2ecfc1d388e5f8094006f7d961c93a0))
+* wrong protocol and url path ([#588](https://github.com/jwplayer/ott-web-app/issues/588)) ([de75eb7](https://github.com/jwplayer/ott-web-app/commit/de75eb7eaca51d4fef9be4a40f13d043437bf3f0))
+
 ## [6.5.0](https://github.com/jwplayer/ott-web-app/compare/v6.4.0...v6.5.0) (2024-07-25)
 
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jwp/ott",
-  "version": "6.5.0",
+  "version": "6.6.0",
   "private": true,
   "license": "Apache-2.0",
   "repository": "https://github.com/jwplayer/ott-web-app.git",

packages/common/src/controllers/CheckoutController.ts

@@ -27,6 +27,7 @@ import { useCheckoutStore } from '../stores/CheckoutStore';
 import { useAccountStore } from '../stores/AccountStore';
 import { FormValidationError } from '../errors/FormValidationError';
 import { determineSwitchDirection } from '../utils/subscription';
+import { findDefaultCardMethodId } from '../utils/payments';
 
 @injectable()
 export default class CheckoutController {
@@ -70,7 +71,7 @@ export default class CheckoutController {
     const { customer } = getAccountInfo();
 
     const paymentMethods = await this.getPaymentMethods();
-    const paymentMethodId = paymentMethods[0]?.id;
+    const paymentMethodId = parseInt(findDefaultCardMethodId(paymentMethods));
 
     const createOrderArgs: CreateOrderArgs = {
       offer,

packages/common/src/services/ApiService.ts

@@ -28,14 +28,14 @@ export default class ApiService {
    * We use playlistLabel prop to define the label used for all media items inside.
    * That way we can change the behavior of the same media items being in different playlists
    */
-  private generateAlternateImageURL = ({ mediaId, label, playlistLabel }: { mediaId: string; label: string; playlistLabel?: string }) => {
+  protected generateAlternateImageURL = ({ mediaId, label, playlistLabel }: { mediaId: string; label: string; playlistLabel?: string }) => {
     const pathname = `/v2/media/${mediaId}/images/${playlistLabel || label}.webp`;
     const url = createURL(`${env.APP_API_BASE_URL}${pathname}`, { poster_fallback: 1, fallback: playlistLabel ? label : null });
 
     return url;
   };
 
-  private parseDate = (item: PlaylistItem, prop: string) => {
+  protected parseDate = (item: PlaylistItem, prop: string) => {
     const date = item[prop] as string | undefined;
 
     if (date && !isValid(new Date(date))) {
@@ -49,7 +49,7 @@ export default class ApiService {
   /**
    * Transform incoming content lists
    */
-  private transformContentList = (contentList: ContentList): Playlist => {
+  protected transformContentList = (contentList: ContentList): Playlist => {
     const { list, ...rest } = contentList;
 
     const playlist: Playlist = { ...rest, playlist: [] };
@@ -80,7 +80,7 @@ export default class ApiService {
   /**
    * Transform incoming playlists
    */
-  private transformPlaylist = (playlist: Playlist, relatedMediaId?: string) => {
+  protected transformPlaylist = (playlist: Playlist, relatedMediaId?: string) => {
     playlist.playlist = playlist.playlist.map((item) => this.transformMediaItem(item, playlist));
 
     // remove the related media item (when this is a recommendations playlist)

packages/common/src/services/ConfigService.ts

@@ -7,18 +7,16 @@ import { AppError } from '../utils/error';
 import type { Config } from '../../types/config';
 import env from '../env';
 
-import ApiService from './ApiService';
-
 /**
  * Set config setup changes in both config.service.ts and config.d.ts
  * */
 
 @injectable()
 export default class ConfigService {
-  private CONFIG_HOST = env.APP_API_BASE_URL;
+  protected CONFIG_HOST = env.APP_API_BASE_URL;
   // Explicitly set default config here as a local variable,
   // otherwise if it's a module level const, the merge below causes changes to nested properties
-  private DEFAULT_CONFIG: Config = {
+  protected DEFAULT_CONFIG: Config = {
     id: '',
     siteName: '',
     description: '',
@@ -35,13 +33,7 @@ export default class ConfigService {
     features: {},
   };
 
-  private readonly apiService: ApiService;
-
-  constructor(apiService: ApiService) {
-    this.apiService = apiService;
-  }
-
-  private enrichConfig = (config: Config): Config => {
+  protected enrichConfig = (config: Config): Config => {
     const { content, siteName } = config;
     const updatedContent = content.map((content) => Object.assign({ featured: false }, content));
 
@@ -70,10 +62,6 @@ export default class ConfigService {
     return source;
   };
 
-  loadAdSchedule = async (adScheduleId: string | undefined | null) => {
-    return this.apiService.getAdSchedule(adScheduleId);
-  };
-
   loadConfig = async (configLocation: string | undefined) => {
     const i18n = getI18n();
 

packages/common/src/services/FavoriteService.ts

@@ -23,31 +23,35 @@ const schema = array(
 export default class FavoriteService {
   private PERSIST_KEY_FAVORITES = 'favorites';
 
-  private readonly apiService;
-  private readonly storageService;
-  private readonly accountService;
-
-  constructor(@inject(INTEGRATION_TYPE) integrationType: string, apiService: ApiService, storageService: StorageService) {
+  protected readonly apiService;
+  protected readonly storageService;
+  protected readonly accountService;
+
+  constructor(
+    @inject(INTEGRATION_TYPE) integrationType: string,
+    @inject(ApiService) apiService: ApiService,
+    @inject(StorageService) storageService: StorageService,
+  ) {
     this.apiService = apiService;
     this.storageService = storageService;
     this.accountService = getNamedModule(AccountService, integrationType, false);
   }
 
-  private validateFavorites(favorites: unknown) {
+  protected validateFavorites(favorites: unknown) {
     if (favorites && schema.validateSync(favorites)) {
       return favorites as SerializedFavorite[];
     }
 
     return [];
   }
 
-  private async getFavoritesFromAccount(user: Customer) {
+  protected async getFavoritesFromAccount(user: Customer) {
     const favorites = await this.accountService?.getFavorites({ user });
 
     return this.validateFavorites(favorites);
   }
 
-  private async getFavoritesFromStorage() {
+  protected async getFavoritesFromStorage() {
     const favorites = await this.storageService.getItem(this.PERSIST_KEY_FAVORITES, true);
 
     return this.validateFavorites(favorites);

packages/common/src/services/GenericEntitlementService.ts

@@ -5,7 +5,7 @@ import type { GetTokenResponse } from '../../types/entitlement';
 
 @injectable()
 export default class GenericEntitlementService {
-  private getToken = async <T>(url: string, body: unknown = {}, jwt?: string): Promise<T> => {
+  protected getToken = async <T>(url: string, body: unknown = {}, jwt?: string): Promise<T> => {
     const response = await fetch(url, {
       method: 'POST',
       headers: {

packages/common/src/services/JWPEntitlementService.ts

@@ -5,7 +5,7 @@ import JWPAPIService from './integrations/jwp/JWPAPIService';
 
 @injectable()
 export default class JWPEntitlementService {
-  private readonly apiService;
+  protected readonly apiService;
 
   constructor(@inject(JWPAPIService) apiService: JWPAPIService) {
     this.apiService = apiService;
@@ -14,7 +14,7 @@ export default class JWPEntitlementService {
   getJWPMediaToken = async (configId: string = '', mediaId: string) => {
     try {
       const data = await this.apiService.get<SignedMediaResponse>(
-        'v2/items/jw-media/token',
+        '/v2/items/jw-media/token',
         {
           withAuthentication: true,
         },

packages/common/src/services/SettingsService.ts

@@ -1,4 +1,4 @@
-import { injectable } from 'inversify';
+import { inject, injectable } from 'inversify';
 import ini from 'ini';
 import { getI18n } from 'react-i18next';
 
@@ -12,9 +12,9 @@ import StorageService from './StorageService';
 
 @injectable()
 export default class SettingsService {
-  private readonly storageService;
+  protected readonly storageService;
 
-  constructor(storageService: StorageService) {
+  constructor(@inject(StorageService) storageService: StorageService) {
     this.storageService = storageService;
   }
 

packages/common/src/services/WatchHistoryService.ts

@@ -22,28 +22,32 @@ const schema = array(
 
 @injectable()
 export default class WatchHistoryService {
-  private PERSIST_KEY_WATCH_HISTORY = 'history';
+  protected PERSIST_KEY_WATCH_HISTORY = 'history';
 
-  private readonly apiService;
-  private readonly storageService;
-  private readonly accountService;
+  protected readonly apiService;
+  protected readonly storageService;
+  protected readonly accountService;
 
-  constructor(@inject(INTEGRATION_TYPE) integrationType: string, apiService: ApiService, storageService: StorageService) {
+  constructor(
+    @inject(INTEGRATION_TYPE) integrationType: string,
+    @inject(ApiService) apiService: ApiService,
+    @inject(StorageService) storageService: StorageService,
+  ) {
     this.apiService = apiService;
     this.storageService = storageService;
     this.accountService = getNamedModule(AccountService, integrationType);
   }
 
   // Retrieve watch history media items info using a provided watch list
-  private getWatchHistoryItems = async (continueWatchingList: string, ids: string[]): Promise<Record<string, PlaylistItem>> => {
+  protected getWatchHistoryItems = async (continueWatchingList: string, ids: string[]): Promise<Record<string, PlaylistItem>> => {
     const watchHistoryItems = await this.apiService.getMediaByWatchlist(continueWatchingList, ids);
     const watchHistoryItemsDict = Object.fromEntries((watchHistoryItems || []).map((item) => [item.mediaid, item]));
 
     return watchHistoryItemsDict;
   };
 
   // We store separate episodes in the watch history and to show series card in the Continue Watching shelf we need to get their parent media items
-  private getWatchHistorySeriesItems = async (continueWatchingList: string, ids: string[]): Promise<Record<string, PlaylistItem | undefined>> => {
+  protected getWatchHistorySeriesItems = async (continueWatchingList: string, ids: string[]): Promise<Record<string, PlaylistItem | undefined>> => {
     const mediaWithSeries = await this.apiService.getSeriesByMediaIds(ids);
     const seriesIds = Object.keys(mediaWithSeries || {})
       .map((key) => mediaWithSeries?.[key]?.[0]?.series_id)
@@ -62,21 +66,21 @@ export default class WatchHistoryService {
     return seriesItemsDict;
   };
 
-  private validateWatchHistory(history: unknown) {
+  protected validateWatchHistory(history: unknown) {
     if (history && schema.validateSync(history)) {
       return history as SerializedWatchHistoryItem[];
     }
 
     return [];
   }
 
-  private async getWatchHistoryFromAccount(user: Customer) {
+  protected async getWatchHistoryFromAccount(user: Customer) {
     const history = await this.accountService.getWatchHistory({ user });
 
     return this.validateWatchHistory(history);
   }
 
-  private async getWatchHistoryFromStorage() {
+  protected async getWatchHistoryFromStorage() {
     const history = await this.storageService.getItem(this.PERSIST_KEY_WATCH_HISTORY, true);
 
     return this.validateWatchHistory(history);