web-push-notifications 3.40.1 → 3.44.1

package/src/modules/InboxMessagesPublic.ts

@@ -0,0 +1,222 @@
+import { type Api } from './Api/Api';
+import { type Data } from './Data/Data';
+import DateModule from './DateModule';
+import { type default as InboxMessagesModel } from '../models/InboxMessages';
+import {
+  type IInboxMessage,
+  type IInboxMessageActionParams,
+  type IInboxMessagePublic,
+  type IInboxMessages,
+  type TInboxActionType,
+  type TInboxMessageStatus,
+  type TInboxMessageStatusDeleted,
+  type TInboxMessageStatusOpen,
+  type TInboxMessageStatusRead,
+  type TInboxMessageType,
+  type TInboxMessageTypeDeeplink,
+  type TInboxMessageTypePlain,
+  type TInboxMessageTypeRichmedia,
+  type TInboxMessageTypeURL,
+} from '../models/InboxMessages.types';
+
+export default class InboxMessages implements IInboxMessages {
+  private readonly data: Data;
+  private readonly api: Api;
+  private readonly inboxModel: InboxMessagesModel;
+  private dateModule: DateModule;
+
+  constructor(
+    data: Data,
+    api: Api,
+    inboxModel: InboxMessagesModel,
+    dateModule: DateModule = new DateModule(),
+  ) {
+    this.data = data;
+    this.api = api;
+    this.inboxModel = inboxModel;
+    this.dateModule = dateModule;
+
+    this.publicMessageBuilder = this.publicMessageBuilder.bind(this);
+  }
+
+  /**
+   * Get message type by IInboxMessageActionParams
+   * @param actionParams
+   */
+  private messageTypeFactory(action_type: TInboxActionType, actionParams: IInboxMessageActionParams): TInboxMessageType {
+    let messageType: TInboxMessageTypePlain = 0;
+    if (action_type === 2) { // 2 is Richmedia Action Type for server loaded messages. See TInboxActionType typings comment.
+      (<TInboxMessageTypeRichmedia>messageType) = 1;
+    } else if ('l' in actionParams && actionParams.l != null) { // 'l' - URL and deeplink parameter
+      if (actionParams.l.startsWith('http')) { // Deeplink parameter - relative URL; URL parameter - full URL
+        (<TInboxMessageTypeURL>messageType) = 2;
+      } else {
+        (<TInboxMessageTypeDeeplink>messageType) = 3;
+      }
+    }
+
+    return messageType;
+  }
+
+  /**
+   * Update messages status using codes from arguments
+   * @param codes
+   * @param messages
+   * @param status
+   */
+  private async updateMessagesStatusWithCodes(
+    codes: Array<string>,
+    messages: Array<IInboxMessage>,
+    status: TInboxMessageStatus,
+  ): Promise<void> {
+    const updatedMessages: Array<IInboxMessage> = [];
+    const inboxStatusQueries: Array<Promise<void>> = [];
+
+    messages.forEach(async (msg) => {
+      if (codes.indexOf(msg.inbox_id) === -1) {
+        return;
+      }
+
+      msg.status = status;
+      updatedMessages.push(msg);
+
+      // Set inbox status to server
+      inboxStatusQueries.push(this.api.inboxStatus(msg.order, msg.status));
+    });
+
+    await this.inboxModel.putBulkMessages(updatedMessages);
+    await Promise.all(inboxStatusQueries);
+  }
+
+  /**
+   * Build TInboxMessagePublic by TInboxMessage
+   * @param message
+   */
+  async publicMessageBuilder({
+    action_type,
+    action_params,
+    image,
+    title,
+    send_date,
+    inbox_id,
+    text,
+    status,
+  }: IInboxMessage): Promise<IInboxMessagePublic> {
+    const imageUrl = image || await this.data.getDefaultNotificationImage();
+    const inboxTitle = title || await this.data.getDefaultNotificationTitle();
+    const actionParams = JSON.parse(action_params);
+
+    this.dateModule.date = new Date(parseInt(send_date) * 1000);
+    this.dateModule.setLocal();
+
+    return {
+      title: inboxTitle,
+      imageUrl,
+      code: inbox_id,
+      message: text,
+      sendDate: this.dateModule.date.toISOString(),
+      type: this.messageTypeFactory(action_type, actionParams),
+      link: actionParams?.l || '/',
+      isRead: <TInboxMessageStatusRead> status === 2 || <TInboxMessageStatusOpen> status === 3,
+      isActionPerformed: <TInboxMessageStatusOpen> status === 3,
+    };
+  }
+
+  /**
+   * Count of messages with no action performed
+   */
+  messagesWithNoActionPerformedCount(): Promise<number> {
+    return this.inboxModel.getDeliveredReadMessagesCount();
+  }
+
+  /**
+   * All unread messages
+   */
+  unreadMessagesCount() {
+    return this.inboxModel.getDeliveredMessagesCount();
+  }
+
+  /**
+   * All messages count
+   */
+  messagesCount(): Promise<number> {
+    return this.inboxModel.messagesCount();
+  }
+
+  /**
+   * Get all active messages
+   */
+  async loadMessages(): Promise<Array<IInboxMessagePublic>> {
+    const readMessages = await this.inboxModel.getReadOpenMessages();
+    const unreadMessages = await this.inboxModel.getDeliveredMessages();
+    const buildMessagePromises = [...readMessages, ...unreadMessages]
+      .sort((msgA: IInboxMessage, msgB: IInboxMessage) => { // sort by send date
+        return parseInt(msgB.send_date, 10) - parseInt(msgA.send_date, 10);
+      })
+      .sort((msgA: IInboxMessage, msgB: IInboxMessage) => { // sort by order
+        return parseInt(msgB.order || '0', 10) - parseInt(msgA.order || '0', 10);
+      })
+      .map(this.publicMessageBuilder);
+    return Promise.all(buildMessagePromises);
+  }
+
+  /**
+   * Mark messages as read
+   * @param codes
+   */
+  async readMessagesWithCodes(codes: Array<string>): Promise<void> {
+    const unreadMessages = await this.inboxModel.getDeliveredMessages();
+
+    const statusRead: TInboxMessageStatusRead = 2;
+    await this.updateMessagesStatusWithCodes(
+      codes,
+      unreadMessages,
+      statusRead,
+    );
+  }
+
+  /**
+   * Execute message action. Type "richmedia" and "plain" does not support
+   * @param code
+   */
+  async performActionForMessageWithCode(code: string): Promise<void> {
+    const message = await this.inboxModel.getMessage(code);
+    const actionParams = JSON.parse(message.action_params);
+    const messageType = this.messageTypeFactory(message.action_type, actionParams);
+
+    if (<TInboxMessageTypeURL>messageType === 2 && actionParams.l != null) {
+      document.location.href = actionParams.l;
+    } else if (<TInboxMessageTypeDeeplink>messageType === 3 && actionParams.l != null) {
+      window.history.go(actionParams.l);
+    }
+
+    (<TInboxMessageStatusOpen>message.status) = 3;
+    await this.inboxModel.putMessage(message);
+
+    // Set inbox status to server
+    await this.api.inboxStatus(message.order, message.status);
+  }
+
+  /**
+   * Delete messages by codes
+   * @param codes
+   */
+  async deleteMessagesWithCodes(codes: Array<string>): Promise<void> {
+    const readMessages = await this.inboxModel.getReadOpenMessages();
+    const unreadMessages = await this.inboxModel.getDeliveredMessages();
+
+    const statusDeleted: TInboxMessageStatusDeleted = 4;
+    await this.updateMessagesStatusWithCodes(
+      codes,
+      [...readMessages, ...unreadMessages],
+      statusDeleted,
+    );
+  }
+
+  /**
+   * Sync inbox messages with server
+   */
+  async syncMessages() {
+    await this.inboxModel.updateMessages();
+  }
+}

package/src/modules/PlatformChecker/PlatformChecker.ts

@@ -0,0 +1,170 @@
+import { type TPlatform, type TPlatformChrome, type TPlatformEdge, type TPlatformFirefox, type TPlatformSafari } from './PlatformChecker.types';
+
+export class PlatformChecker {
+  private readonly global: typeof globalThis;
+
+  private readonly _isSafari: boolean;
+  private readonly _isOpera: boolean;
+  private readonly _isEdge: boolean;
+  private readonly _isFirefox: boolean;
+  private readonly _isChrome: boolean;
+
+  private readonly _isMacOS: boolean;
+
+  private readonly _isAvailableServiceWorker: boolean;
+  private readonly _isAvailableNotifications: boolean;
+
+  /**
+   * Browser name + version
+   * Example: "Chrome 70"
+   */
+  private readonly _browserVersion: string;
+  private readonly _platform: TPlatform;
+
+  constructor(global: typeof globalThis) {
+    this.global = global;
+
+    this._isSafari = this.isSafariBrowser();
+    this._isOpera = this.isOperaBrowser();
+    this._isEdge = this.isEdgeBrowser();
+    this._isFirefox = this.isFirefoxBrowser();
+    this._isChrome = this.isChromeBrowser();
+
+    this._isMacOS = this.isMacOS();
+
+    this._isAvailableServiceWorker = this.canUseServiceWorkers();
+    this._isAvailableNotifications = this.canReceiveNotifications();
+
+    this._platform = this.getPlatformType();
+    this._browserVersion = this.getBrowserVersion();
+  }
+
+  // Platform flags
+  get isEdge() {
+    return this._isEdge;
+  }
+
+  get isSafari() {
+    return this._isSafari;
+  }
+
+  get isOpera() {
+    return this._isOpera;
+  }
+
+  get isAvailableServiceWorker() {
+    return this._isAvailableServiceWorker;
+  }
+
+  get isAvailableNotifications() {
+    return this._isAvailableNotifications;
+  }
+
+  // Platform values
+
+  get platform() {
+    return this._platform;
+  }
+
+  get browserVersion() {
+    return this._browserVersion;
+  }
+
+  isSafariBrowser(): boolean {
+    return 'safari' in this.global && navigator.userAgent.indexOf('Safari') > -1;
+  }
+
+  isOperaBrowser(): boolean {
+    return navigator.userAgent.indexOf('Opera') !== -1 || navigator.userAgent.indexOf('OPR') !== -1;
+  }
+
+  isEdgeBrowser(): boolean {
+    return navigator.userAgent.indexOf('Edge') > -1;
+  }
+
+  isFirefoxBrowser(): boolean {
+    return navigator.userAgent.toLowerCase().indexOf('firefox') !== -1;
+  }
+
+  isChromeBrowser(): boolean {
+    return /Chrome/.test(navigator.userAgent)
+      && /Google Inc/.test(navigator.vendor)
+      && !this._isOpera
+      && !this._isEdge;
+  }
+
+  isMacOS(): boolean {
+    return 'platform' in navigator && navigator.platform.toLowerCase().indexOf('mac') !== -1;
+  }
+
+  canUseServiceWorkers(): boolean {
+    return !!navigator.serviceWorker && 'PushManager' in this.global && 'Notification' in this.global;
+  }
+
+  /**
+   * Check availability ServiceWorker or safari browser on macos
+   */
+  canReceiveNotifications(): boolean {
+    return (this._isSafari && this._isMacOS) || (this._isAvailableServiceWorker && !this._isEdge);
+  }
+
+  /**
+   * Get Pushwoosh system platform code
+   */
+  getPlatformType(): TPlatform {
+    let platform: TPlatformChrome = 11;
+
+    switch (true) {
+      case this._isSafari:
+        (<TPlatformSafari>platform) = 10;
+        break;
+
+      case this._isOpera || this._isChrome:
+        (<TPlatformChrome>platform) = 11;
+        break;
+
+      case this._isFirefox:
+        (<TPlatformFirefox>platform) = 12;
+        break;
+
+      case this._isEdge:
+        (<TPlatformEdge>platform) = 150;
+        break;
+    }
+
+    return platform;
+  }
+
+  /**
+   * Get browser name + version from userAgent
+   */
+  getBrowserVersion(): string {
+    const { userAgent } = navigator;
+    const matchOperaVersion = userAgent.match(/\bOPR\/(\d+)/);
+    if (matchOperaVersion !== null) {
+      return `Opera ${matchOperaVersion[1]}`;
+    }
+
+    const matchEdgeVersion = userAgent.match(/\bEdge\/(\d+)/);
+    if (matchEdgeVersion !== null) {
+      return `Edge ${matchEdgeVersion[1]}`;
+    }
+
+    // edge on chromium
+    const matchEdgVersion = userAgent.match(/\bEdg\/(\d+)/);
+    if (matchEdgVersion !== null) {
+      return `Edge ${matchEdgVersion[1]}`;
+    }
+
+    let match = userAgent.match(/(opera|chrome|safari|firefox(?=\/))\/?\s*(\d+)/i) || [];
+    const [, browser = ''] = match;
+
+    match = match[2] ? [browser, match[2]] : [navigator.appName, navigator.appVersion, '-?'];
+    const version = userAgent.match(/version\/([.\d]+)/i);
+    if (version !== null) {
+      match.splice(1, 1, version[1]);
+    }
+
+    return match.join(' ');
+  }
+}

package/src/modules/PlatformChecker/PlatformChecker.types.ts

@@ -0,0 +1,5 @@
+export type TPlatformSafari = 10; // Safari platform code in Pushwoosh system
+export type TPlatformChrome = 11; // Chrome platform code in Pushwoosh system
+export type TPlatformFirefox = 12; // Firefox platform code in Pushwoosh system
+export type TPlatformEdge = 150; // Edge platform code in Pushwoosh system
+export type TPlatform = TPlatformSafari | TPlatformChrome | TPlatformFirefox | TPlatformEdge;

package/src/modules/PlatformChecker/index.ts

@@ -0,0 +1 @@
+export { PlatformChecker } from './PlatformChecker';

package/src/modules/storage/Storage.ts

@@ -0,0 +1,164 @@
+import MigrationExecutor from './migrations/MigrationExecutor';
+import { type IIDBOpenEventTargetWithResult, type TIDBKeyType, type TIDBQueryValue, type TSdkStoreName } from './Storage.types';
+import Store from './Store';
+import dbVersion from './version';
+
+export default class Storage {
+  db: Promise<IDBDatabase>;
+
+  /**
+   * Change database version handler
+   * @param db
+   * @param event
+   */
+  private dbVersionChangeHandler(db: IDBDatabase, event: IDBVersionChangeEvent) {
+    console.info('onversionchange', event);
+    db.close();
+  }
+
+  /**
+   * Success database request handler
+   * @param resolve
+   * @param event
+   */
+  private dbRequestSuccessHandler(resolve: (db: IDBDatabase) => void, event: Event) {
+    const target: IIDBOpenEventTargetWithResult = <IIDBOpenEventTargetWithResult>event.target;
+    const database: IDBDatabase = target.result;
+
+    // close db and resolve new db instance on version change
+    database.onversionchange = (event: IDBVersionChangeEvent) => {
+      this.dbVersionChangeHandler(database, event);
+    };
+
+    resolve(database);
+  }
+
+  /**
+   * Need upgrade database version handler
+   * @param event
+   */
+  private dbRequestUpgradeNeededHandler(event: Event) {
+    const target: IIDBOpenEventTargetWithResult = <IIDBOpenEventTargetWithResult>event.target;
+    const database: IDBDatabase = target.result;
+
+    // close db and resolve new db instance on version change
+    database.onversionchange = (event: IDBVersionChangeEvent) => {
+      this.dbVersionChangeHandler(database, event);
+    };
+
+    // apply migrations
+    const migrationExecutor = new MigrationExecutor(database);
+    migrationExecutor.applyMigrations();
+  }
+
+  /**
+   * Open db
+   */
+  getDB(): Promise<IDBDatabase> {
+    return new Promise<IDBDatabase>((resolve, reject) => {
+      const request: IDBOpenDBRequest = indexedDB.open('PUSHWOOSH_SDK_STORE', dbVersion);
+
+      request.onsuccess = (event: Event) => {
+        this.dbRequestSuccessHandler(resolve, event); // Existing db without updates
+      };
+      request.onupgradeneeded = (event: Event) => {
+        this.dbRequestUpgradeNeededHandler(event); // Upgrade DB
+      };
+      request.onerror = () => reject(request.error); // Handle errors
+    });
+  }
+
+  /**
+   * https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore/put
+   * @param storeName
+   * @param data
+   * @param key
+   */
+  async put(storeName: TSdkStoreName, data: any, key?: string) {
+    const db = await this.getDB();
+    const store = new Store(db, storeName);
+    const result = await store.put(data, key);
+    db.close();
+    return result;
+  }
+
+  /**
+   * https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore/delete
+   * @param storeName
+   * @param key
+   */
+  async delete(storeName: TSdkStoreName, key: string | number) {
+    const db = await this.getDB();
+    const store = new Store(db, storeName);
+    const result = await store.delete(key);
+    db.close();
+    return result;
+  }
+
+  /**
+   * https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore/get
+   * @param storeName
+   * @param key
+   * @param defaultValue
+   */
+  async get<Response, D>(
+    storeName: TSdkStoreName,
+    key: TIDBKeyType,
+    defaultValue?: D,
+  ): Promise<Response | D> {
+    const db = await this.getDB();
+    const store = new Store(db, storeName);
+    const result = await store.get<Response, D>(key, defaultValue);
+    db.close();
+    return result;
+  }
+
+  /**
+   * https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore/getAll
+   * @param storeName
+   */
+  async getAll<Response>(
+    storeName: TSdkStoreName,
+  ): Promise<Array<Response>> {
+    const db = await this.getDB();
+    const store = new Store(db, storeName);
+    const result = await store.getAll<Response>();
+    db.close();
+    return result || [];
+  }
+
+  /**
+   * https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore/count
+   * @param storeName
+   * @param query
+   */
+  async count(
+    storeName: TSdkStoreName,
+    query?: IDBKeyRange,
+  ): Promise<number> {
+    const db = await this.getDB();
+    const store = new Store(db, storeName);
+    const result = await store.count(query);
+    db.close();
+    return result;
+  }
+
+  /**
+   * https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex/count
+   * @param storeName
+   * @param indexName
+   * @param key
+   */
+  async countByIndex(
+    storeName: TSdkStoreName,
+    indexName: string,
+    key?: TIDBQueryValue,
+  ): Promise<number> {
+    const db = await this.getDB();
+    const store = new Store(db, storeName);
+    store.index = indexName;
+    const result = await store.countByIndex(key);
+    db.close();
+    return result;
+  }
+}

package/src/modules/storage/Storage.types.ts

@@ -0,0 +1,54 @@
+export type TKeyValueStoreName = 'keyValue';
+export type TMessageLogStoreName = 'messages';
+export type TMainLogStoreName = 'log';
+export type TInboxMessagesStoreName = 'inboxMessages';
+export type TSdkStoreName =
+  | TKeyValueStoreName
+  | TMessageLogStoreName
+  | TInboxMessagesStoreName
+  | TMainLogStoreName;
+
+export type TMigrationType = (database: IDBDatabase) => void;
+
+export type TMigrationsObjectType = {
+  initial: Array<TMigrationType>;
+  [date: string]: Array<TMigrationType>; // date in YYYY/MM/DD format
+};
+
+export interface IIDBOpenEventTargetWithResult extends EventTarget {
+  result: IDBDatabase;
+}
+
+export interface IIDBGetTransactionEventTargetWithResult extends EventTarget {
+  result: any;
+}
+
+export type TIDBKeyType = string | number | Date;
+export type TIDBQueryValue = TIDBKeyType | IDBKeyRange;
+
+export interface IDBIndex {
+  getAll(query?: TIDBQueryValue, count?: number): IDBRequest;
+}
+
+export interface IDBObjectStore {
+  getAll(query?: TIDBQueryValue, count?: number): IDBRequest;
+}
+
+// KeyValue Keys
+
+export type TIDBAppCodeKey = 'params.applicationCode';
+export type TIDBApiUrlKey = 'params.apiUrl';
+export type TIDBHwidKey = 'params.hwid';
+export type TIDBDefaultNotificationImageKey = 'params.defaultNotificationImage';
+export type TIDBDefaultNotificationTitleKey = 'params.defaultNotificationTitle';
+export type TIDBUserIdKey = 'params.userId';
+export type TIDBUserIdWasChangedKey = 'params.userIdWasChanged';
+export type TIDBDeviceType = 'params.deviceType';
+
+export type TSubscriptionPopupLastOpen = 'params.subscriptionPopupLastOpen';
+
+export type TIDBInboxLastRequestCodeKey = 'inbox.lastRequestCode';
+export type TIDBInboxLastRequestTimeKey = 'inbox.lastRequestTime';
+export type TIDBInboxNewMessagesCountKey = 'inbox.newMessagesCount';
+
+///////////////////