web-push-notifications 3.40.3 → 3.44.1

package/src/core/storage.ts

@@ -0,0 +1,254 @@
+import {
+  STORE_NAME_KEY_VALUE,
+  STORE_NAME_MAIN_LOG,
+  STORE_NAME_MESSAGE_LOG,
+} from '../modules/storage/migrations/constants';
+import MigrationExecutor from '../modules/storage/migrations/MigrationExecutor';
+import { type IIDBOpenEventTargetWithResult } from '../modules/storage/Storage.types';
+import version from '../modules/storage/version';
+
+declare const self: ServiceWorkerGlobalScope;
+
+function onversionchange(database: IDBDatabase, event: Event) {
+  console.info('onversionchange', event);
+  database.close();
+}
+
+let databasePromise: Promise<IDBDatabase>;
+export function getInstance(): Promise<IDBDatabase> {
+  if (!databasePromise) {
+    databasePromise = new Promise<IDBDatabase>((resolve, reject) => {
+      const request: IDBOpenDBRequest = indexedDB.open('PUSHWOOSH_SDK_STORE', version);
+      request.onsuccess = (event) => {
+        const database: IDBDatabase = (event.target as IIDBOpenEventTargetWithResult).result;
+        database.onversionchange = onversionchange.bind(null, database, reject);
+        resolve(database);
+      };
+
+      request.onerror = () => reject(request.error);
+
+      request.onupgradeneeded = (event) => {
+        const database: IDBDatabase = (event.target as IIDBOpenEventTargetWithResult).result;
+        database.onversionchange = onversionchange.bind(null, database, reject);
+
+        const migrationExecutor = new MigrationExecutor(database);
+        migrationExecutor.applyMigrations();
+      };
+    });
+  }
+  return databasePromise;
+}
+
+function getInstanceWithPromise(executor: any): any {
+  return getInstance().then((database) => (
+    new Promise((resolve, reject) => executor(database, resolve, reject))
+  ));
+}
+
+function createKeyValue(name: string) {
+  return {
+    get<K extends string, D>(key: K, defaultValue?: D) {
+      return getInstanceWithPromise((database: IDBDatabase, resolve: any, reject: any) => {
+        const request = database.transaction(name).objectStore(name).get(key);
+
+        /** @TODO
+         * we cant invoke "resolve" or "reject" in onsuccess or onerror because
+         * it leads to bugs in Safari when we try to get permissions for notifications
+         *
+         * Checking status of request in setTimeout fixes this bug
+         */
+        let isComplete = false;
+        let isError = false;
+        let timeout: any;
+
+        const check = () => {
+          clearTimeout(timeout);
+          if (isComplete) {
+            resolve(request.result?.value || defaultValue);
+          } else if (isError) {
+            reject(request.error);
+          } else {
+            timeout = setTimeout(check, 0);
+          }
+        };
+
+        request.onsuccess = () => isComplete = true;
+        request.onerror = () => isError = true;
+        check();
+      });
+    },
+
+    getAll() {
+      return getInstanceWithPromise((database: IDBDatabase, resolve: any, reject: any) => {
+        const result: { [key: string]: any } = {};
+        const cursor = database.transaction(name).objectStore(name).openCursor();
+        let isComplete = false;
+        let isError = false;
+        let timeout: any;
+
+        /** @TODO
+         * we cant invoke "resolve" or "reject" in onsuccess or onerror because
+         * it leads to bugs in Safari when we try to get permissions for notifications
+         *
+         * Checking status of request in setTimeout fixes this bug
+         */
+        const check = () => {
+          clearTimeout(timeout);
+          if (isComplete) {
+            resolve(result);
+          } else if (isError) {
+            reject(cursor.error);
+          } else {
+            timeout = setTimeout(check, 0);
+          }
+        };
+
+        cursor.onsuccess = (event) => {
+          const cursorResult = (event.target as any).result;
+          if (cursorResult) {
+            result[cursorResult.key] = cursorResult.value.value;
+            cursorResult.continue();
+          } else {
+            isComplete = true;
+          }
+        };
+        cursor.onerror = () => isError = true;
+        check();
+      });
+    },
+
+    async extend(key: string, value: any) {
+      const oldValues = await this.get(key);
+      const { ...newValues } = value;
+      await this.set(key, { ...oldValues, ...newValues });
+    },
+
+    set<K, D>(key: K, value: D) {
+      return getInstanceWithPromise((database: IDBDatabase, resolve: any, reject: any) => {
+        const request = database.transaction([name], 'readwrite').objectStore(name).put({ key, value });
+        let isComplete = false;
+        let isError = false;
+        let timeout: any;
+
+        /** @TODO
+         * we cant invoke "resolve" or "reject" in onsuccess or onerror because
+         * it leads to bugs in Safari when we try to get permissions for notifications
+         *
+         * Checking status of request in setTimeout fixes this bug
+         */
+        const check = () => {
+          clearTimeout(timeout);
+          if (isComplete) {
+            resolve(key);
+          } else if (isError) {
+            reject(request.error);
+          } else {
+            timeout = setTimeout(check, 0);
+          }
+        };
+
+        request.onsuccess = () => isComplete = true;
+        request.onerror = () => isError = true;
+        check();
+      });
+    },
+  };
+}
+
+export abstract class LogBase {
+  protected abstract name: string;
+  protected abstract maxItems: number;
+  _add(obj: any) {
+    return getInstanceWithPromise((database: IDBDatabase, resolve: any, reject: any) => {
+      const request = database.transaction([this.name], 'readwrite').objectStore(this.name).add(obj);
+      request.onsuccess = () => {
+        resolve(obj);
+      };
+      request.onerror = () => {
+        reject(request.error);
+      };
+    }).then((obj: any) => {
+      return this.getAll().then((items: { id: number }[]) => {
+        if (Array.isArray(items)) {
+          const ids = items.map((i) => i.id).sort((a, b) => {
+            if (a == b) return 0;
+            return a < b ? 1 : -1;
+          });
+          if (ids.length > this.maxItems) {
+            return Promise.all(ids.slice(this.maxItems).map((id) => this.delete(id))).then(() => obj);
+          }
+        }
+        return obj;
+      });
+    });
+  }
+
+  delete(key: any) {
+    return getInstanceWithPromise((database: IDBDatabase, resolve: any, reject: any) => {
+      const request = database.transaction([this.name], 'readwrite').objectStore(this.name).delete(key);
+      request.onsuccess = () => {
+        resolve(request.result);
+      };
+      request.onerror = () => {
+        reject(request.error);
+      };
+    });
+  }
+
+  getAll() {
+    return getInstanceWithPromise((database: IDBDatabase, resolve: any, reject: any) => {
+      const result: any[] = [];
+      const cursor = database.transaction(this.name).objectStore(this.name).openCursor();
+      cursor.onsuccess = (ev) => {
+        const cursorResult = (ev.target as any).result;
+        if (cursorResult) {
+          if (cursorResult.value) {
+            result.push(cursorResult.value);
+          }
+          cursorResult.continue();
+        } else {
+          resolve(result);
+        }
+      };
+      cursor.onerror = () => {
+        reject(cursor.error);
+      };
+    });
+  }
+}
+
+export class LogLog extends LogBase {
+  protected name = STORE_NAME_MAIN_LOG;
+  protected maxItems = 100;
+  protected environment = (typeof self !== 'undefined' && self.registration) ? 'worker' : 'browser';
+  add(type: string, message: any, additional?: any) {
+    const obj: any = {
+      type,
+      environment: this.environment,
+      message: `${message}`,
+      date: new Date(),
+    };
+    if (message instanceof Error) {
+      obj.stack = message.stack;
+    }
+    if (additional) {
+      obj.additional = additional;
+    }
+    return this._add(obj);
+  }
+}
+
+export class LogMessage extends LogBase {
+  protected name = STORE_NAME_MESSAGE_LOG;
+  protected maxItems = 25;
+  add(log: any) {
+    return this._add({
+      ...log,
+      date: new Date(),
+    });
+  }
+}
+
+export const keyValue = createKeyValue(STORE_NAME_KEY_VALUE);
+export const log = new LogLog();
+export const message = new LogMessage();

package/src/helpers/logger.ts

@@ -0,0 +1,81 @@
+import {
+  Logger,
+  handlerConsole,
+} from './pwlogger';
+
+type TLogMessage = {
+  message: string;
+  code: string;
+  error: any;
+
+  [key: string]: any;
+};
+
+const logger = new Logger({
+  level: 'error',
+  subscribers: [
+    {
+      level: 'fatal',
+      handler: handlerConsole,
+    },
+    {
+      level: 'error',
+      handler: handlerConsole,
+    },
+  ],
+});
+
+async function sendFatalLogToRemoteServer(params: TLogMessage) {
+  const message = makeMessage(params);
+
+  return logger.fatal(message.text, message.code, message.options);
+}
+
+async function sendErrorLogToRemoteServer(params: TLogMessage) {
+  const message = makeMessage(params);
+
+  return logger.error(message.text, message.code, message.options);
+}
+
+function makeMessage(params: TLogMessage) {
+  const {
+    message,
+    code,
+    error,
+    ...data
+  } = params;
+
+  const cleanError = makeCleanError(error);
+
+  const options = {
+    ...data,
+    errorText: cleanError.message,
+    errorStack: cleanError.stack,
+  };
+
+  return {
+    text: message,
+    code,
+    options,
+  };
+}
+
+function makeCleanError(error: any): Error {
+  let cleanError: Error = new Error('unknown error');
+
+  if (typeof error === 'string' || typeof error === 'number' || typeof error === 'boolean') {
+    cleanError.message = error.toString();
+  }
+
+  if (error instanceof Error) {
+    cleanError = error;
+  }
+
+  return cleanError;
+}
+
+export {
+  logger,
+  sendFatalLogToRemoteServer,
+  sendErrorLogToRemoteServer,
+};

package/src/helpers/pwlogger/Logger.constants.ts

@@ -0,0 +1,31 @@
+import {
+  type TLoggerLevelSilent,
+  type TLoggerLevelFatal,
+  type TLoggerLevelError,
+  type TLoggerLevelWarn,
+  type TLoggerLevelInfo,
+  type TLoggerLevelDebug,
+} from './Logger.types';
+
+export const LOGGER_LEVEL_SILENT: TLoggerLevelSilent = 'silent';
+export const LOGGER_LEVEL_FATAL: TLoggerLevelFatal = 'fatal';
+export const LOGGER_LEVEL_ERROR: TLoggerLevelError = 'error';
+export const LOGGER_LEVEL_WARN: TLoggerLevelWarn = 'warn';
+export const LOGGER_LEVEL_INFO: TLoggerLevelInfo = 'info';
+export const LOGGER_LEVEL_DEBUG: TLoggerLevelDebug = 'debug';
+
+export const LOGGER_LEVEL_VALUE_SILENT = 0;
+export const LOGGER_LEVEL_VALUE_FATAL = 10;
+export const LOGGER_LEVEL_VALUE_ERROR = 20;
+export const LOGGER_LEVEL_VALUE_WARN = 30;
+export const LOGGER_LEVEL_VALUE_INFO = 40;
+export const LOGGER_LEVEL_VALUE_DEBUG = 50;
+
+export const loggerRelationsMap = {
+  [LOGGER_LEVEL_SILENT]: LOGGER_LEVEL_VALUE_SILENT,
+  [LOGGER_LEVEL_FATAL]: LOGGER_LEVEL_VALUE_FATAL,
+  [LOGGER_LEVEL_ERROR]: LOGGER_LEVEL_VALUE_ERROR,
+  [LOGGER_LEVEL_WARN]: LOGGER_LEVEL_VALUE_WARN,
+  [LOGGER_LEVEL_INFO]: LOGGER_LEVEL_VALUE_INFO,
+  [LOGGER_LEVEL_DEBUG]: LOGGER_LEVEL_VALUE_DEBUG,
+};

package/src/helpers/pwlogger/Logger.ts

@@ -0,0 +1,218 @@
+import {
+  loggerRelationsMap,
+  LOGGER_LEVEL_FATAL,
+  LOGGER_LEVEL_ERROR,
+  LOGGER_LEVEL_WARN,
+  LOGGER_LEVEL_INFO,
+  LOGGER_LEVEL_DEBUG, LOGGER_LEVEL_SILENT,
+} from './Logger.constants';
+import {
+  type ILoggerConfig,
+  type TLoggerLevels,
+  type TLoggerApplicationType,
+  type ILoggerLogOptions,
+  type ILoggerLogParams,
+  type ILoggerMessage,
+  type TLoggerHandler,
+  type ILoggerSubscriber,
+  type TLoggerOutputLevels,
+  type TReject,
+} from './Logger.types';
+
+export * from './Logger.types';
+export * from './Logger.constants';
+
+export class Logger {
+  public readonly relations: typeof loggerRelationsMap = loggerRelationsMap;
+  public applicationType: TLoggerApplicationType;
+  public level: TLoggerLevels;
+  public readonly subscribers: ILoggerSubscriber[];
+
+  public applicationCode: string | undefined;
+  public domain: string | undefined;
+  public deviceInfo: { [key: string]: any } | undefined;
+
+  constructor(config?: ILoggerConfig) {
+    this.level = config && typeof (config.level) !== 'undefined' ? config.level : LOGGER_LEVEL_ERROR;
+    this.applicationType = config && typeof (config.applicationType) !== 'undefined' ? config.applicationType : 'sdk';
+    this.subscribers = config && typeof (config.subscribers) !== 'undefined' ? config.subscribers : [];
+  }
+
+  public updateLogLevel(level: TLoggerLevels): void {
+    this.level = level;
+  }
+
+  public updateApplicationType(applicationType: TLoggerApplicationType): void {
+    this.applicationType = applicationType;
+  }
+
+  public updateApplicationCode(applicationCode: string): void {
+    this.applicationCode = applicationCode;
+  }
+
+  public updateDomain(domain: string): void {
+    this.domain = domain;
+  }
+
+  public updateDeviceInfo(deviceInfo: { [key: string]: any }): void {
+    this.deviceInfo = deviceInfo;
+  }
+
+  public subscribe(level: TLoggerOutputLevels, handler: TLoggerHandler) {
+    this.subscribers.push({
+      handler,
+      level,
+    });
+  }
+
+  public async log(params: ILoggerLogParams): Promise<void> {
+    const actions: Array<Promise<void> | void> = [];
+    const {
+      options,
+      ...other
+    } = params;
+
+    let data = other;
+
+    if (options) {
+      const {
+        handler: _handler,
+        ...additionalData
+      } = options;
+
+      data = {
+        ...other,
+        ...additionalData,
+      };
+    }
+    const message = this.getMessage(data);
+
+    this.subscribers.forEach((subscriber) => {
+      if (subscriber.level === params.type && this.relations[subscriber.level] <= this.relations[this.level]) {
+        actions.push(subscriber.handler.call(null, message));
+      }
+    });
+
+    if (options && options.handler && this.level !== LOGGER_LEVEL_SILENT) {
+      options.handler.call(null, message);
+    }
+
+    await Promise.all(actions);
+    return;
+  }
+
+  public async debug(text: string, options?: ILoggerLogOptions): Promise<void> {
+    return this.log({
+      type: LOGGER_LEVEL_DEBUG,
+      text,
+      options,
+    });
+  }
+
+  public async info(text: string, options?: ILoggerLogOptions): Promise<void> {
+    return this.log({
+      type: LOGGER_LEVEL_INFO,
+      text,
+      options,
+    });
+  }
+
+  public async warn(text: string, code?: string, options?: ILoggerLogOptions): Promise<void> {
+    return this.log({
+      type: LOGGER_LEVEL_WARN,
+      text,
+      code,
+      options,
+    });
+  }
+
+  public async error(text: string, code?: string, options?: ILoggerLogOptions): Promise<void> {
+    return this.log({
+      type: LOGGER_LEVEL_ERROR,
+      text,
+      code,
+      options,
+    });
+  }
+
+  public async fatal(text: string, code?: string, options?: ILoggerLogOptions): Promise<void> {
+    return this.log({
+      type: LOGGER_LEVEL_FATAL,
+      text,
+      code,
+      options,
+    });
+  }
+
+  public async errorAndThrow(text: string, code?: string, options?: ILoggerLogOptions): Promise<void> {
+    return this.logAndThrow({
+      type: LOGGER_LEVEL_ERROR,
+      text,
+      code,
+      options,
+    });
+  }
+
+  public async errorAndReject(cb: TReject, text: string, code?: string, options?: ILoggerLogOptions): Promise<void> {
+    return this.logAndReject(cb, {
+      type: LOGGER_LEVEL_ERROR,
+      text,
+      code,
+      options,
+    });
+  }
+
+  public async fatalAndThrow(text: string, code?: string, options?: ILoggerLogOptions): Promise<void> {
+    return this.logAndThrow({
+      type: LOGGER_LEVEL_FATAL,
+      text,
+      code,
+      options,
+    });
+  }
+
+  public async fatalAndReject(cb: TReject, text: string, code?: string, options?: ILoggerLogOptions): Promise<void> {
+    return this.logAndReject(cb, {
+      type: LOGGER_LEVEL_FATAL,
+      text,
+      code,
+      options,
+    });
+  }
+
+  private async logAndThrow(params: ILoggerLogParams): Promise<void> {
+    await this.log(params);
+
+    const error = new Error(params.text);
+
+    if (params.code) {
+      // @ts-ignore
+      error.code = params.code;
+    }
+
+    throw error;
+  }
+
+  private async logAndReject(reject: TReject, params: ILoggerLogParams): Promise<void> {
+    await this.log(params);
+
+    const error = new Error(params.text);
+
+    if (params.code) {
+      // @ts-ignore
+      error.code = params.code;
+    }
+
+    reject(error);
+  }
+
+  private getMessage(params: ILoggerLogParams): ILoggerMessage {
+    return {
+      applicationCode: this.applicationCode,
+      domain: this.domain,
+      applicationType: this.applicationType,
+      deviceInfo: this.deviceInfo,
+      ...params,
+    };
+  }
+}

package/src/helpers/pwlogger/Logger.types.ts

@@ -0,0 +1,66 @@
+export type TLoggerLevelSilent = 'silent';
+export type TLoggerLevelFatal = 'fatal';
+export type TLoggerLevelError = 'error';
+export type TLoggerLevelWarn = 'warn';
+export type TLoggerLevelInfo = 'info';
+export type TLoggerLevelDebug = 'debug';
+
+export type TLoggerFromSDK = 'sdk';
+export type TLoggerFromCP = 'cp';
+
+export type TLoggerApplicationType =
+  | TLoggerFromSDK
+  | TLoggerFromCP;
+
+export type TLoggerOutputLevels =
+  | TLoggerLevelFatal
+  | TLoggerLevelError
+  | TLoggerLevelWarn
+  | TLoggerLevelInfo
+  | TLoggerLevelDebug;
+
+export type TLoggerLevels =
+  | TLoggerLevelSilent
+  | TLoggerOutputLevels;
+
+export interface ILoggerLogOptions {
+  handler?: TLoggerHandler;
+  [key: string]: any;
+}
+
+export interface ILoggerLogParams {
+  type: TLoggerOutputLevels;
+  text: string;
+  code?: string | number;
+  options?: ILoggerLogOptions;
+}
+
+export type TLoggerHandler = (message: ILoggerMessage) => void | Promise<void>;
+
+export interface ILoggerSubscriber {
+  handler: TLoggerHandler;
+  level: TLoggerOutputLevels;
+}
+
+export interface ILoggerMessage {
+  type: TLoggerOutputLevels;
+  text: string;
+  applicationType: TLoggerApplicationType;
+
+  code?: string | number;
+  applicationCode?: string;
+  domain?: string;
+  deviceInfo?: {
+    [key: string]: any;
+  };
+
+  [key: string]: any;
+}
+
+export interface ILoggerConfig {
+  level?: TLoggerLevels;
+  applicationType?: TLoggerApplicationType;
+  subscribers?: ILoggerSubscriber[];
+}
+
+export type TReject = (reason: Error) => void;

package/src/helpers/pwlogger/handlers/handler-console/handler-console.ts

@@ -0,0 +1,40 @@
+import {
+  type ILoggerMessage,
+  type TLoggerOutputLevels,
+} from './../../Logger';
+
+export function handlerConsole(message: ILoggerMessage) {
+  const {
+    code,
+    text,
+    type,
+  } = message;
+
+  const log = getOutputFunction(type);
+  // tslint:disable-next-line
+  console.groupCollapsed(type);
+
+  if (code) {
+    log(`${code}: ${text}`);
+  } else {
+    log(text);
+  }
+
+  // tslint:disable-next-line
+  console.groupEnd();
+}
+
+function getOutputFunction(type: TLoggerOutputLevels): (text: string) => void {
+  switch (type) {
+    case 'fatal':
+    case 'error':
+      // tslint:disable-next-line
+      return console.error;
+
+    case 'warn':
+    case 'info':
+    case 'debug':
+      // tslint:disable-next-line
+      return console.log;
+  }
+}

package/src/helpers/pwlogger/index.ts

@@ -0,0 +1,2 @@
+export * from './Logger';
+export * from './handlers/handler-console/handler-console';