remove legact pendingNotificationClickEvents

Author: fadi-george

__test__/unit/pushSubscription/nativePermissionChange.test.ts

@@ -8,7 +8,7 @@ import {
 import { TestEnvironment } from '__test__/support/environment/TestEnvironment';
 import { createPushSub } from '__test__/support/environment/TestEnvironmentHelpers';
 import { MockServiceWorker } from '__test__/support/mocks/MockServiceWorker';
-import { db } from 'src/shared/database/client';
+import { db, getOptionsValue } from 'src/shared/database/client';
 import { setAppState as setDBAppState } from 'src/shared/database/config';
 import * as PermissionUtils from 'src/shared/helpers/permissions';
 import Emitter from 'src/shared/libraries/Emitter';
@@ -78,8 +78,9 @@ describe('Notification Types are set correctly on subscription change', () => {
       await MainHelper.checkAndTriggerNotificationPermissionChanged();
 
       // should update the db
-      const dbPermission = (await db.get('Options', 'notificationPermission'))
-        ?.value;
+      const dbPermission = await getOptionsValue<NotificationPermission>(
+        'notificationPermission',
+      );
       expect(dbPermission).toBe(NotificationPermission.Granted);
       expect(permChangeListener).toHaveBeenCalledWith(true);
       expect(permChangeStringListener).toHaveBeenCalledWith('granted');
@@ -88,8 +89,7 @@ describe('Notification Types are set correctly on subscription change', () => {
 
   describe('checkAndTriggerSubscriptionChanged', async () => {
     const setAppState = async (appState: Partial<AppState>) => {
-      const currentAppState = (await db.get('Options', 'appState'))
-        ?.value as AppState;
+      const currentAppState = (await getOptionsValue<AppState>('appState'))!;
       await setDBAppState({
         ...currentAppState,
         ...appState,

src/core/modelRepo/ModelStore.ts

@@ -161,12 +161,12 @@ export abstract class ModelStore<
   protected async load(): Promise<void> {
     if (!this.modelName) return;
 
-    const jsonArray = await db.getAll(this.modelName);
+    const jsonArray = (await db.getAll(this.modelName)) as unknown as DBModel[];
 
     const shouldRePersist = this.models.length > 0;
 
     for (let index = jsonArray.length - 1; index >= 0; index--) {
-      const newModel = this.create(jsonArray[index] as DBModel);
+      const newModel = this.create(jsonArray[index]);
       if (!newModel) continue;
 
       this.models.unshift(newModel);

src/onesignal/NotificationsNamespace.ts

@@ -5,7 +5,6 @@ import {
   WrongTypeArgumentError,
 } from 'src/shared/errors/common';
 import { isValidUrl } from 'src/shared/helpers/validators';
-import { fireStoredNotificationClicks } from 'src/shared/listeners';
 import type {
   NotificationEventName,
   NotificationEventTypeMap,
@@ -125,10 +124,6 @@ export default class NotificationsNamespace extends EventListenerBase {
     listener: (obj: NotificationEventTypeMap[K]) => void,
   ): void {
     OneSignal.emitter.on(event, listener);
-
-    if (event === 'click') {
-      fireStoredNotificationClicks();
-    }
   }
 
   removeEventListener<K extends NotificationEventName>(

src/shared/database/client.ts

@@ -1,12 +1,12 @@
-import { openDB } from 'idb';
+import { openDB, type StoreNames } from 'idb';
 import { ONESIGNAL_SESSION_KEY } from '../session/constants';
 import {
   DATABASE_NAME,
   LegacyModelName,
   ModelName,
   VERSION,
 } from './constants';
-import type { IndexedDBSchema } from './types';
+import type { IdKey, IndexedDBSchema, OptionKey } from './types';
 import {
   migrateModelNameSubscriptionsTableForV6,
   migrateOutcomesNotificationClickedTableForV5,
@@ -77,33 +77,57 @@ export const getDb = async () => {
   return dbInstance;
 };
 
+type StoreName = StoreNames<IndexedDBSchema>;
+
 // Export db object with the same API as before
 export const db = {
-  async get(storeName: keyof IndexedDBSchema, key?: string) {
+  async get<K extends StoreName>(
+    storeName: K,
+    key: string,
+  ): Promise<IndexedDBSchema[K]['value'] | undefined> {
     const _db = await getDb();
-    return key ? _db.get(storeName as any, key) : _db.getAll(storeName as any);
+    return _db.get(storeName, key);
   },
-  async getAll(storeName: keyof IndexedDBSchema) {
+  async getAll<K extends StoreName>(
+    storeName: K,
+  ): Promise<IndexedDBSchema[K]['value'][]> {
     const _db = await getDb();
-    return _db.getAll(storeName as any);
+    return _db.getAll(storeName);
   },
-  async put(storeName: keyof IndexedDBSchema, value: any) {
+  async put<K extends StoreName>(
+    storeName: K,
+    value: IndexedDBSchema[K]['value'],
+  ) {
     const _db = await getDb();
-    return _db.put(storeName as any, value);
+    return _db.put(storeName, value);
   },
-  async delete(storeName: keyof IndexedDBSchema, key: string) {
+  async delete<K extends StoreName>(storeName: K, key: string) {
     const _db = await getDb();
-    return _db.delete(storeName as any, key);
+    return _db.delete(storeName, key);
   },
-  async clear(storeName: keyof IndexedDBSchema) {
+  async clear<K extends StoreName>(storeName: K) {
     const _db = await getDb();
-    return _db.clear(storeName as any);
+    return _db.clear(storeName);
   },
   get objectStoreNames() {
     return dbInstance?.objectStoreNames || [];
   },
 };
 
+export const getOptionsValue = async <T extends unknown>(
+  key: OptionKey,
+): Promise<T | null> => {
+  const result = await db.get('Options', key);
+  if (result && 'value' in result) return result.value as T;
+  return null;
+};
+
+export const getIdsValue = async <T>(key: IdKey): Promise<T | null> => {
+  const result = await db.get('Ids', key);
+  if (result && 'id' in result) return result.id as T;
+  return null;
+};
+
 export const getCurrentSession = async () => {
   return (await db.get('Sessions', ONESIGNAL_SESSION_KEY)) ?? null;
 };

src/shared/database/config.ts

@@ -1,55 +1,26 @@
-import {
-  type NotificationClickForOpenHandlingSchema,
-  notificationClickFromDatabase,
-} from '../helpers/serializer';
-import {
-  AppState,
-  type PendingNotificationClickEvents,
-} from '../models/AppState';
-import { db } from './client';
+import { AppState } from '../models/AppState';
+import { db, getIdsValue, getOptionsValue } from './client';
 
 export const getDBAppConfig = async () => {
   const config: any = {};
-  const appIdStr: string = (await db.get('Ids', 'appId'))?.id as string;
+  const appIdStr = await getIdsValue<string>('appId');
   config.appId = appIdStr;
-  config.vapidPublicKey = (await db.get('Options', 'vapidPublicKey'))?.value;
+  config.vapidPublicKey = await getOptionsValue<string>('vapidPublicKey');
   return config;
 };
 
-const getAllPendingNotificationClickEvents =
-  async (): Promise<PendingNotificationClickEvents> => {
-    const clickedNotifications: PendingNotificationClickEvents = {};
-    const eventsFromDb = await db.getAll('NotificationOpened');
-    for (const eventFromDb of eventsFromDb) {
-      const event = notificationClickFromDatabase(eventFromDb);
-      const url = event.result.url;
-      if (!url) {
-        continue;
-      }
-      clickedNotifications[url] = event;
-    }
-    return clickedNotifications;
-  };
-
 export const getAppState = async (): Promise<AppState> => {
   const state = new AppState();
-  state.defaultNotificationUrl = (await db.get('Options', 'defaultUrl'))
-    ?.value as string;
-  state.defaultNotificationTitle = (await db.get('Options', 'defaultTitle'))
-    ?.value as string;
-  state.lastKnownPushEnabled = (await db.get('Options', 'isPushEnabled'))
-    ?.value as boolean;
-  state.pendingNotificationClickEvents =
-    await getAllPendingNotificationClickEvents();
+  state.defaultNotificationUrl = await getOptionsValue<string>('defaultUrl');
+  state.defaultNotificationTitle =
+    await getOptionsValue<string>('defaultTitle');
+  state.lastKnownPushEnabled = await getOptionsValue<boolean>('isPushEnabled');
 
   // lastKnown<PushId|PushToken|OptedIn> are used to track changes to the user's subscription
   // state. Displayed in the `current` & `previous` fields of the `subscriptionChange` event.
-  state.lastKnownPushId = (await db.get('Options', 'lastPushId'))
-    ?.value as string;
-  state.lastKnownPushToken = (await db.get('Options', 'lastPushToken'))
-    ?.value as string;
-  state.lastKnownOptedIn = (await db.get('Options', 'lastOptedIn'))
-    ?.value as boolean;
+  state.lastKnownPushId = await getOptionsValue<string>('lastPushId');
+  state.lastKnownPushToken = await getOptionsValue<string>('lastPushToken');
+  state.lastKnownOptedIn = await getOptionsValue<boolean>('lastOptedIn');
   return state;
 };
 
@@ -91,35 +62,8 @@ export const setAppState = async (appState: AppState) => {
       key: 'lastOptedIn',
       value: appState.lastKnownOptedIn,
     });
-
-  if (appState.pendingNotificationClickEvents) {
-    const clickedNotificationUrls = Object.keys(
-      appState.pendingNotificationClickEvents,
-    );
-    for (const url of clickedNotificationUrls) {
-      const notificationDetails =
-        appState.pendingNotificationClickEvents[
-          url as keyof typeof appState.pendingNotificationClickEvents
-        ];
-
-      if (notificationDetails) {
-        await db.put('NotificationOpened', {
-          url: url,
-          data: (notificationDetails as any).data,
-          timestamp: (notificationDetails as any).timestamp,
-        } as NotificationClickForOpenHandlingSchema);
-      } else if (notificationDetails === null) {
-        // If we get an object like:
-        // { "http://site.com/page": null}
-        // It means we need to remove that entry
-        await db.delete('NotificationOpened', url);
-      }
-    }
-  }
 };
 
 export const getConsentGiven = async () => {
-  return (await db.get('Options', 'consentGiven'))?.value as
-    | boolean
-    | undefined;
+  return await getOptionsValue<boolean>('consentGiven');
 };

src/shared/database/types.ts

@@ -11,7 +11,7 @@ import { ModelName } from './constants';
 
 export type ModelNameType = (typeof ModelName)[keyof typeof ModelName];
 
-type IdKey = 'appId' | 'registrationId' | 'userId' | 'jwtToken';
+export type IdKey = 'appId' | 'registrationId' | 'userId' | 'jwtToken';
 
 export type OptionKey =
   | 'appState'
@@ -124,7 +124,7 @@ export interface IndexedDBSchema extends DBSchema {
     key: OptionKey;
     value: {
       key: OptionKey;
-      value: boolean | number | string | AppState | undefined;
+      value: boolean | number | string | AppState | undefined | null;
     };
   };
 
@@ -175,7 +175,8 @@ export interface IndexedDBSchema extends DBSchema {
     value: {
       modelId: string;
       modelName: 'operations';
-      [key: string]: any;
+      name: string;
+      [key: string]: unknown;
     };
   };
 }

src/shared/helpers/init.ts

@@ -3,6 +3,7 @@ import type { AppConfig } from '../config/types';
 import type { ContextInterface } from '../context/types';
 import { db } from '../database/client';
 import { getSubscription, setSubscription } from '../database/subscription';
+import type { OptionKey } from '../database/types';
 import Log from '../libraries/Log';
 import { CustomLinkManager } from '../managers/CustomLinkManager';
 import { NotificationPermission } from '../models/NotificationPermission';
@@ -306,13 +307,16 @@ export async function saveInitOptions() {
     ) {
       opPromises.push(
         db.put('Options', {
-          key: `webhooks.${event}`,
+          key: `webhooks.${event}` as OptionKey,
           value: webhookOptions[event as keyof typeof webhookOptions],
         }),
       );
     } else {
       opPromises.push(
-        db.put('Options', { key: `webhooks.${event}`, value: false }),
+        db.put('Options', {
+          key: `webhooks.${event}` as OptionKey,
+          value: false,
+        }),
       );
     }
   });

src/shared/helpers/permissions.ts

@@ -1,4 +1,4 @@
-import { db } from '../database/client';
+import { db, getOptionsValue } from '../database/client';
 import OneSignalEvent from '../services/OneSignalEvent';
 
 // This flag prevents firing the NOTIFICATION_PERMISSION_CHANGED_AS_STRING event twice
@@ -24,8 +24,7 @@ export const triggerNotificationPermissionChanged = async (force = false) => {
 const privateTriggerNotificationPermissionChanged = async (force: boolean) => {
   const newPermission: NotificationPermission =
     await OneSignal.context.permissionManager.getPermissionStatus();
-  const previousPermission: NotificationPermission = await db.get(
-    'Options',
+  const previousPermission = await getOptionsValue<NotificationPermission>(
     'notificationPermission',
   );
 
@@ -47,7 +46,7 @@ const privateTriggerNotificationPermissionChanged = async (force: boolean) => {
 };
 
 const triggerBooleanPermissionChangeEvent = (
-  previousPermission: NotificationPermission,
+  previousPermission: NotificationPermission | null,
   newPermission: NotificationPermission,
   force: boolean,
 ): void => {

src/shared/listeners.test.ts

@@ -1,19 +1,19 @@
 import { TestEnvironment } from '__test__/support/environment/TestEnvironment';
-import * as eventListeners from 'src/shared/listeners';
+import OneSignal from 'src/onesignal/OneSignal';
+import type { Mock } from 'vitest';
 
-describe('Notification Listeners', () => {
-  beforeEach(async () => {
-    await TestEnvironment.initialize();
-  });
+let emitterSpy: Mock;
 
-  afterEach(() => {
-    vi.resetAllMocks();
-  });
+beforeEach(async () => {
+  await TestEnvironment.initialize();
+  emitterSpy = vi.spyOn(OneSignal.emitter, 'on');
+});
+
+afterEach(() => {
+  vi.resetAllMocks();
+});
 
-  test('Adding click listener fires internal EventHelper', async () => {
-    const stub = vi.spyOn(eventListeners, 'fireStoredNotificationClicks');
-    // @ts-expect-error - listener doesnt matter
-    OneSignal.Notifications.addEventListener('click', null);
-    expect(stub).toHaveBeenCalledTimes(1);
-  });
+test('Adding click listener fires internal EventHelper', async () => {
+  OneSignal.Notifications.addEventListener('click', () => {});
+  expect(emitterSpy).toHaveBeenCalledTimes(1);
 });