From 610f3532d3cf62ae3415f3b204f0d8e463c67313 Mon Sep 17 00:00:00 2001 From: AR Abdul Azeez Date: Mon, 21 Sep 2026 10:57:29 -0500 Subject: [PATCH 01/12] fix: [SDK-5304] ignore null login externalId instead of crashing Co-authored-by: Cursor --- .../java/com/onesignal/rnonesignalandroid/RNOneSignal.java | 4 ++++ ios/RCTOneSignal/RCTOneSignalEventEmitter.mm | 4 ++++ src/index.test.ts | 6 ++++++ src/index.ts | 4 ++++ 4 files changed, 18 insertions(+) diff --git a/android/src/main/java/com/onesignal/rnonesignalandroid/RNOneSignal.java b/android/src/main/java/com/onesignal/rnonesignalandroid/RNOneSignal.java index 3e151160..bd20d6da 100644 --- a/android/src/main/java/com/onesignal/rnonesignalandroid/RNOneSignal.java +++ b/android/src/main/java/com/onesignal/rnonesignalandroid/RNOneSignal.java @@ -598,6 +598,10 @@ public void addOutcomeWithValue(String name, double value) { @Override public void login(String externalUserId) { + if (externalUserId == null) { + Logging.error("login called with a null externalUserId", null); + return; + } OneSignal.login(externalUserId); } diff --git a/ios/RCTOneSignal/RCTOneSignalEventEmitter.mm b/ios/RCTOneSignal/RCTOneSignalEventEmitter.mm index 4273ac11..bb85d707 100644 --- a/ios/RCTOneSignal/RCTOneSignalEventEmitter.mm +++ b/ios/RCTOneSignal/RCTOneSignalEventEmitter.mm @@ -138,6 +138,10 @@ + (void)sendEventWithName:(NSString *)name withBody:(NSDictionary *)body { } RCT_EXPORT_METHOD(login : (NSString *)externalId) { + if (externalId == nil) { + NSLog(@"OneSignal: login called with a nil externalId"); + return; + } [OneSignal login:externalId]; } diff --git a/src/index.test.ts b/src/index.test.ts index 99bc865f..e06ef73a 100644 --- a/src/index.test.ts +++ b/src/index.test.ts @@ -180,6 +180,12 @@ describe('OneSignal', () => { OneSignal.login('external-123'); expect(mockRNOneSignal.login).not.toHaveBeenCalled(); }); + + test('should not login if externalId is null', () => { + OneSignal.login(null as unknown as string); + expect(mockRNOneSignal.login).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith('OneSignal: login: externalId is required'); + }); }); describe('logout', () => { diff --git a/src/index.ts b/src/index.ts index 212299d1..b61bffed 100644 --- a/src/index.ts +++ b/src/index.ts @@ -121,6 +121,10 @@ export namespace OneSignal { */ export function login(externalId: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (externalId == null) { + console.error('OneSignal: login: externalId is required'); + return; + } RNOneSignal.login(externalId); } From e53d3d1b25b65b698adc16eb92ec4f44a221db6c Mon Sep 17 00:00:00 2001 From: AR Abdul Azeez Date: Mon, 21 Sep 2026 14:27:03 -0500 Subject: [PATCH 02/12] fix: [SDK-5304] reject null and empty identity strings Kotlin non-null String APIs crash when JS passes null. Empty login is invalid too. Guard both in isNonEmptyString and skip the native call. Co-authored-by: Cursor --- .../rnonesignalandroid/RNOneSignal.java | 4 +- ios/RCTOneSignal/RCTOneSignalEventEmitter.mm | 4 +- src/helpers.test.ts | 18 +++++++ src/helpers.ts | 4 ++ src/index.test.ts | 38 ++++++++++++-- src/index.ts | 50 +++++++++++++++++-- 6 files changed, 106 insertions(+), 12 deletions(-) diff --git a/android/src/main/java/com/onesignal/rnonesignalandroid/RNOneSignal.java b/android/src/main/java/com/onesignal/rnonesignalandroid/RNOneSignal.java index bd20d6da..ec28e64a 100644 --- a/android/src/main/java/com/onesignal/rnonesignalandroid/RNOneSignal.java +++ b/android/src/main/java/com/onesignal/rnonesignalandroid/RNOneSignal.java @@ -598,8 +598,8 @@ public void addOutcomeWithValue(String name, double value) { @Override public void login(String externalUserId) { - if (externalUserId == null) { - Logging.error("login called with a null externalUserId", null); + if (externalUserId == null || externalUserId.isEmpty()) { + Logging.error("login called with a null or empty externalUserId", null); return; } OneSignal.login(externalUserId); diff --git a/ios/RCTOneSignal/RCTOneSignalEventEmitter.mm b/ios/RCTOneSignal/RCTOneSignalEventEmitter.mm index bb85d707..0fa86c94 100644 --- a/ios/RCTOneSignal/RCTOneSignalEventEmitter.mm +++ b/ios/RCTOneSignal/RCTOneSignalEventEmitter.mm @@ -138,8 +138,8 @@ + (void)sendEventWithName:(NSString *)name withBody:(NSDictionary *)body { } RCT_EXPORT_METHOD(login : (NSString *)externalId) { - if (externalId == nil) { - NSLog(@"OneSignal: login called with a nil externalId"); + if (externalId == nil || [externalId length] == 0) { + NSLog(@"OneSignal: login called with a nil or empty externalId"); return; } [OneSignal login:externalId]; diff --git a/src/helpers.test.ts b/src/helpers.test.ts index 8d904ebf..24b6f7ae 100644 --- a/src/helpers.test.ts +++ b/src/helpers.test.ts @@ -5,6 +5,7 @@ import { IOS_NULL_SENTINEL } from './constants/internal'; import { encodeNullsForIOS, isNativeModuleLoaded, + isNonEmptyString, isObjectSerializable, isValidCallback, } from './helpers'; @@ -66,6 +67,23 @@ describe('helpers', () => { }); }); + describe('isNonEmptyString', () => { + test.each([ + { description: 'a non-empty string', value: 'id', expected: true }, + { description: 'a whitespace string', value: ' ', expected: true }, + { description: 'an empty string', value: '', expected: false }, + { description: 'null', value: null, expected: false }, + { description: 'undefined', value: undefined, expected: false }, + { description: 'a number', value: 1, expected: false }, + { description: 'a boolean', value: true, expected: false }, + ])( + 'should return $expected for $description', + ({ value, expected }: { description: string; value: unknown; expected: boolean }) => { + expect(isNonEmptyString(value)).toBe(expected); + }, + ); + }); + describe('isObjectSerializable', () => { test.each([ { description: 'an empty object', value: {} }, diff --git a/src/helpers.ts b/src/helpers.ts index ca6e0f41..76d28927 100644 --- a/src/helpers.ts +++ b/src/helpers.ts @@ -18,6 +18,10 @@ export function isNativeModuleLoaded(module: object | null | undefined): boolean return true; } +export function isNonEmptyString(value: unknown): value is string { + return typeof value === 'string' && value.length > 0; +} + /** * Returns true if the value is a JSON-serializable object. */ diff --git a/src/index.test.ts b/src/index.test.ts index e06ef73a..67ee4f7b 100644 --- a/src/index.test.ts +++ b/src/index.test.ts @@ -112,6 +112,18 @@ describe('OneSignal', () => { expect(mockRNOneSignal.initialize).not.toHaveBeenCalled(); }); + test('should not initialize if appId is null', () => { + OneSignal.initialize(null as unknown as string); + expect(mockRNOneSignal.initialize).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith('OneSignal: initialize: appId is required'); + }); + + test('should not initialize if appId is empty', () => { + OneSignal.initialize(''); + expect(mockRNOneSignal.initialize).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith('OneSignal: initialize: appId is required'); + }); + test('should keep a permission event that arrives before the startup read resolves', async () => { let resolveStartupRead: ((granted: boolean) => void) | undefined; vi.mocked(mockRNOneSignal.hasNotificationPermission).mockReturnValueOnce( @@ -186,6 +198,12 @@ describe('OneSignal', () => { expect(mockRNOneSignal.login).not.toHaveBeenCalled(); expect(errorSpy).toHaveBeenCalledWith('OneSignal: login: externalId is required'); }); + + test('should not login if externalId is empty', () => { + OneSignal.login(''); + expect(mockRNOneSignal.login).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith('OneSignal: login: externalId is required'); + }); }); describe('logout', () => { @@ -754,6 +772,18 @@ describe('OneSignal', () => { OneSignal.User.addEmail(EMAIL); expect(mockRNOneSignal.addEmail).not.toHaveBeenCalled(); }); + + test('should not add email if email is null', () => { + OneSignal.User.addEmail(null as unknown as string); + expect(mockRNOneSignal.addEmail).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith('OneSignal: addEmail: email is required'); + }); + + test('should not add email if email is empty', () => { + OneSignal.User.addEmail(''); + expect(mockRNOneSignal.addEmail).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith('OneSignal: addEmail: email is required'); + }); }); describe('removeEmail', () => { @@ -1312,16 +1342,16 @@ describe('OneSignal', () => { expect(mockRNOneSignal.addTrigger).toHaveBeenCalledWith('key', 'value'); }); - test('should log error but still call native method if key is missing', () => { + test('should not add trigger if key is missing', () => { OneSignal.InAppMessages.addTrigger('', 'value'); expect(errorSpy).toHaveBeenCalled(); - expect(mockRNOneSignal.addTrigger).toHaveBeenCalledWith('', 'value'); + expect(mockRNOneSignal.addTrigger).not.toHaveBeenCalled(); }); - test('should log error but still call native method if value is null', () => { + test('should not add trigger if value is null', () => { OneSignal.InAppMessages.addTrigger('key', null as unknown as string); expect(errorSpy).toHaveBeenCalled(); - expect(mockRNOneSignal.addTrigger).toHaveBeenCalledWith('key', null); + expect(mockRNOneSignal.addTrigger).not.toHaveBeenCalled(); }); test('should not add trigger if native module is not loaded', () => { diff --git a/src/index.ts b/src/index.ts index b61bffed..9263b6b2 100644 --- a/src/index.ts +++ b/src/index.ts @@ -18,6 +18,7 @@ import NotificationWillDisplayEvent from './events/NotificationWillDisplayEvent' import { encodeNullsForIOS, isNativeModuleLoaded, + isNonEmptyString, isObjectSerializable, isValidCallback, } from './helpers'; @@ -107,6 +108,10 @@ export namespace OneSignal { /** Initializes the OneSignal SDK. This should be called during startup of the application. */ export function initialize(appId: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (!isNonEmptyString(appId)) { + console.error('OneSignal: initialize: appId is required'); + return; + } RNOneSignal.initialize(appId); @@ -121,7 +126,7 @@ export namespace OneSignal { */ export function login(externalId: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; - if (externalId == null) { + if (!isNonEmptyString(externalId)) { console.error('OneSignal: login: externalId is required'); return; } @@ -452,6 +457,10 @@ export namespace OneSignal { /** Explicitly set a 2-character language code for the user. */ export function setLanguage(language: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (!isNonEmptyString(language)) { + console.error('OneSignal: setLanguage: language is required'); + return; + } RNOneSignal.setLanguage(language); } @@ -459,6 +468,10 @@ export namespace OneSignal { /** Set an alias for the current user. If this alias label already exists on this user, it will be overwritten with the new alias id. */ export function addAlias(label: string, id: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (!isNonEmptyString(label) || !isNonEmptyString(id)) { + console.error('OneSignal: addAlias: must include a label and an id'); + return; + } RNOneSignal.addAlias(label, id); } @@ -473,6 +486,10 @@ export namespace OneSignal { /** Remove an alias from the current user. */ export function removeAlias(label: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (!isNonEmptyString(label)) { + console.error('OneSignal: removeAlias: label is required'); + return; + } RNOneSignal.removeAlias(label); } @@ -487,6 +504,10 @@ export namespace OneSignal { /** Add a new email subscription to the current user. */ export function addEmail(email: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (!isNonEmptyString(email)) { + console.error('OneSignal: addEmail: email is required'); + return; + } RNOneSignal.addEmail(email); } @@ -497,6 +518,10 @@ export namespace OneSignal { */ export function removeEmail(email: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (!isNonEmptyString(email)) { + console.error('OneSignal: removeEmail: email is required'); + return; + } RNOneSignal.removeEmail(email); } @@ -504,6 +529,10 @@ export namespace OneSignal { /** Add a new SMS subscription to the current user. */ export function addSms(smsNumber: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (!isNonEmptyString(smsNumber)) { + console.error('OneSignal: addSms: smsNumber is required'); + return; + } RNOneSignal.addSms(smsNumber); } @@ -514,6 +543,10 @@ export namespace OneSignal { */ export function removeSms(smsNumber: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (!isNonEmptyString(smsNumber)) { + console.error('OneSignal: removeSms: smsNumber is required'); + return; + } RNOneSignal.removeSms(smsNumber); } @@ -525,7 +558,7 @@ export namespace OneSignal { export function addTag(key: string, value: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; - if (!key || value === undefined || value === null) { + if (!isNonEmptyString(key) || value == null) { console.error('OneSignal: addTag: must include a key and a value'); return; } @@ -547,6 +580,10 @@ export namespace OneSignal { /** Remove the data tag with the provided key from the current user. */ export function removeTag(key: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (!isNonEmptyString(key)) { + console.error('OneSignal: removeTag: key is required'); + return; + } RNOneSignal.removeTag(key); } @@ -791,9 +828,10 @@ export namespace OneSignal { export function addTrigger(key: string, value: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; - // value can be assigned to `false` so we cannot just check `!value` - if (!key || value == null) { + // false is a valid trigger value, so reject only null/undefined for value. + if (!isNonEmptyString(key) || value == null) { console.error('OneSignal: addTrigger: must include a key and a value'); + return; } RNOneSignal.addTrigger(key, value); @@ -812,6 +850,10 @@ export namespace OneSignal { /** Remove the trigger with the provided key from the current user. */ export function removeTrigger(key: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (!isNonEmptyString(key)) { + console.error('OneSignal: removeTrigger: key is required'); + return; + } RNOneSignal.removeTrigger(key); } From f07c2b64082bb412fc06a24d5480314a20172002 Mon Sep 17 00:00:00 2001 From: AR Abdul Azeez Date: Mon, 21 Sep 2026 14:43:02 -0500 Subject: [PATCH 03/12] fix: [SDK-5304] log invalid iOS login through OneSignalLog NSLog bypasses setLogLevel. Use the same OneSignalLog error path as the rest of the iOS bridge. Co-authored-by: Cursor --- ios/RCTOneSignal/RCTOneSignalEventEmitter.mm | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ios/RCTOneSignal/RCTOneSignalEventEmitter.mm b/ios/RCTOneSignal/RCTOneSignalEventEmitter.mm index 0fa86c94..180c35eb 100644 --- a/ios/RCTOneSignal/RCTOneSignalEventEmitter.mm +++ b/ios/RCTOneSignal/RCTOneSignalEventEmitter.mm @@ -139,7 +139,8 @@ + (void)sendEventWithName:(NSString *)name withBody:(NSDictionary *)body { RCT_EXPORT_METHOD(login : (NSString *)externalId) { if (externalId == nil || [externalId length] == 0) { - NSLog(@"OneSignal: login called with a nil or empty externalId"); + [OneSignalLog onesignalLog:ONE_S_LL_ERROR + message:@"login called with a nil or empty externalId"]; return; } [OneSignal login:externalId]; From 6b94323526515c2a7c3c17a6ab363e5fb7d1c8f7 Mon Sep 17 00:00:00 2001 From: AR Abdul Azeez Date: Thu, 24 Sep 2026 12:28:45 -0500 Subject: [PATCH 04/12] fix: [SDK-5304] keep setLanguage("") as the device language reset Empty language is the only reset path. Null is still rejected. Co-authored-by: Cursor --- src/index.test.ts | 10 ++++++++++ src/index.ts | 4 ++-- 2 files changed, 12 insertions(+), 2 deletions(-) diff --git a/src/index.test.ts b/src/index.test.ts index 67ee4f7b..eb8b1c48 100644 --- a/src/index.test.ts +++ b/src/index.test.ts @@ -700,6 +700,16 @@ describe('OneSignal', () => { expect(mockRNOneSignal.setLanguage).toHaveBeenCalledWith('en'); }); + test('forwards an empty language so native can reset', () => { + OneSignal.User.setLanguage(''); + expect(mockRNOneSignal.setLanguage).toHaveBeenCalledWith(''); + }); + + test('does not set a null language', () => { + OneSignal.User.setLanguage(null as unknown as string); + expect(mockRNOneSignal.setLanguage).not.toHaveBeenCalled(); + }); + test('should not set language if native module is not loaded', () => { isNativeLoadedSpy.mockReturnValue(false); OneSignal.User.setLanguage('en'); diff --git a/src/index.ts b/src/index.ts index 9263b6b2..371f9a94 100644 --- a/src/index.ts +++ b/src/index.ts @@ -454,10 +454,10 @@ export namespace OneSignal { return RNOneSignal.getExternalId(); } - /** Explicitly set a 2-character language code for the user. */ + /** Explicitly set a 2-character language code for the user. Empty string resets to the device language. */ export function setLanguage(language: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; - if (!isNonEmptyString(language)) { + if (typeof language !== 'string') { console.error('OneSignal: setLanguage: language is required'); return; } From 5f0e971daff563a949394e89ff51676889fdf06b Mon Sep 17 00:00:00 2001 From: AR Abdul Azeez Date: Tue, 29 Sep 2026 14:57:59 -0700 Subject: [PATCH 05/12] fix: [SDK-5304] rename input guards to isMissing The checks read as predicates: isMissing, isMissingAny, and hasMissingEntries. --- src/helpers.test.ts | 20 +++++++-------- src/helpers.ts | 6 +++-- src/index.ts | 62 +++++++++++++-------------------------------- 3 files changed, 31 insertions(+), 57 deletions(-) diff --git a/src/helpers.test.ts b/src/helpers.test.ts index 24b6f7ae..a71394f2 100644 --- a/src/helpers.test.ts +++ b/src/helpers.test.ts @@ -5,7 +5,7 @@ import { IOS_NULL_SENTINEL } from './constants/internal'; import { encodeNullsForIOS, isNativeModuleLoaded, - isNonEmptyString, + isMissing, isObjectSerializable, isValidCallback, } from './helpers'; @@ -67,19 +67,19 @@ describe('helpers', () => { }); }); - describe('isNonEmptyString', () => { + describe('isMissing', () => { test.each([ - { description: 'a non-empty string', value: 'id', expected: true }, - { description: 'a whitespace string', value: ' ', expected: true }, - { description: 'an empty string', value: '', expected: false }, - { description: 'null', value: null, expected: false }, - { description: 'undefined', value: undefined, expected: false }, - { description: 'a number', value: 1, expected: false }, - { description: 'a boolean', value: true, expected: false }, + { description: 'a non-empty string', value: 'id', expected: false }, + { description: 'a whitespace string', value: ' ', expected: false }, + { description: 'an empty string', value: '', expected: true }, + { description: 'null', value: null, expected: true }, + { description: 'undefined', value: undefined, expected: true }, + { description: 'a number', value: 1, expected: true }, + { description: 'a boolean', value: true, expected: true }, ])( 'should return $expected for $description', ({ value, expected }: { description: string; value: unknown; expected: boolean }) => { - expect(isNonEmptyString(value)).toBe(expected); + expect(isMissing(value, 'login: externalId')).toBe(expected); }, ); }); diff --git a/src/helpers.ts b/src/helpers.ts index 76d28927..cd52f7e6 100644 --- a/src/helpers.ts +++ b/src/helpers.ts @@ -18,8 +18,10 @@ export function isNativeModuleLoaded(module: object | null | undefined): boolean return true; } -export function isNonEmptyString(value: unknown): value is string { - return typeof value === 'string' && value.length > 0; +export function isMissing(value: unknown, api: string): boolean { + if (typeof value === 'string' && value.length > 0) return false; + console.error(`OneSignal: ${api} is required`); + return true; } /** diff --git a/src/index.ts b/src/index.ts index 371f9a94..ea49125d 100644 --- a/src/index.ts +++ b/src/index.ts @@ -18,7 +18,7 @@ import NotificationWillDisplayEvent from './events/NotificationWillDisplayEvent' import { encodeNullsForIOS, isNativeModuleLoaded, - isNonEmptyString, + isMissing, isObjectSerializable, isValidCallback, } from './helpers'; @@ -108,10 +108,7 @@ export namespace OneSignal { /** Initializes the OneSignal SDK. This should be called during startup of the application. */ export function initialize(appId: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; - if (!isNonEmptyString(appId)) { - console.error('OneSignal: initialize: appId is required'); - return; - } + if (isMissing(appId, 'initialize: appId')) return; RNOneSignal.initialize(appId); @@ -126,10 +123,7 @@ export namespace OneSignal { */ export function login(externalId: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; - if (!isNonEmptyString(externalId)) { - console.error('OneSignal: login: externalId is required'); - return; - } + if (isMissing(externalId, 'login: externalId')) return; RNOneSignal.login(externalId); } @@ -468,10 +462,7 @@ export namespace OneSignal { /** Set an alias for the current user. If this alias label already exists on this user, it will be overwritten with the new alias id. */ export function addAlias(label: string, id: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; - if (!isNonEmptyString(label) || !isNonEmptyString(id)) { - console.error('OneSignal: addAlias: must include a label and an id'); - return; - } + if (isMissing(label, 'addAlias: label') || isMissing(id, 'addAlias: id')) return; RNOneSignal.addAlias(label, id); } @@ -486,10 +477,7 @@ export namespace OneSignal { /** Remove an alias from the current user. */ export function removeAlias(label: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; - if (!isNonEmptyString(label)) { - console.error('OneSignal: removeAlias: label is required'); - return; - } + if (isMissing(label, 'removeAlias: label')) return; RNOneSignal.removeAlias(label); } @@ -504,10 +492,7 @@ export namespace OneSignal { /** Add a new email subscription to the current user. */ export function addEmail(email: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; - if (!isNonEmptyString(email)) { - console.error('OneSignal: addEmail: email is required'); - return; - } + if (isMissing(email, 'addEmail: email')) return; RNOneSignal.addEmail(email); } @@ -518,10 +503,7 @@ export namespace OneSignal { */ export function removeEmail(email: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; - if (!isNonEmptyString(email)) { - console.error('OneSignal: removeEmail: email is required'); - return; - } + if (isMissing(email, 'removeEmail: email')) return; RNOneSignal.removeEmail(email); } @@ -529,10 +511,7 @@ export namespace OneSignal { /** Add a new SMS subscription to the current user. */ export function addSms(smsNumber: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; - if (!isNonEmptyString(smsNumber)) { - console.error('OneSignal: addSms: smsNumber is required'); - return; - } + if (isMissing(smsNumber, 'addSms: smsNumber')) return; RNOneSignal.addSms(smsNumber); } @@ -543,10 +522,7 @@ export namespace OneSignal { */ export function removeSms(smsNumber: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; - if (!isNonEmptyString(smsNumber)) { - console.error('OneSignal: removeSms: smsNumber is required'); - return; - } + if (isMissing(smsNumber, 'removeSms: smsNumber')) return; RNOneSignal.removeSms(smsNumber); } @@ -558,8 +534,9 @@ export namespace OneSignal { export function addTag(key: string, value: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; - if (!isNonEmptyString(key) || value == null) { - console.error('OneSignal: addTag: must include a key and a value'); + if (isMissing(key, 'addTag: key')) return; + if (value == null) { + console.error('OneSignal: addTag: value is required'); return; } @@ -580,10 +557,7 @@ export namespace OneSignal { /** Remove the data tag with the provided key from the current user. */ export function removeTag(key: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; - if (!isNonEmptyString(key)) { - console.error('OneSignal: removeTag: key is required'); - return; - } + if (isMissing(key, 'removeTag: key')) return; RNOneSignal.removeTag(key); } @@ -829,8 +803,9 @@ export namespace OneSignal { if (!isNativeModuleLoaded(RNOneSignal)) return; // false is a valid trigger value, so reject only null/undefined for value. - if (!isNonEmptyString(key) || value == null) { - console.error('OneSignal: addTrigger: must include a key and a value'); + if (isMissing(key, 'addTrigger: key')) return; + if (value == null) { + console.error('OneSignal: addTrigger: value is required'); return; } @@ -850,10 +825,7 @@ export namespace OneSignal { /** Remove the trigger with the provided key from the current user. */ export function removeTrigger(key: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; - if (!isNonEmptyString(key)) { - console.error('OneSignal: removeTrigger: key is required'); - return; - } + if (isMissing(key, 'removeTrigger: key')) return; RNOneSignal.removeTrigger(key); } From 5bff687c51bec5566d7cd68414b4043452216a50 Mon Sep 17 00:00:00 2001 From: Fadi George Date: Fri, 2 Oct 2026 16:52:00 -0700 Subject: [PATCH 06/12] fix: [SDK-5304] guard plural maps, outcomes, and log levels Co-Authored-By: Claude Opus 5.5 (1M context) --- src/helpers.test.ts | 48 ++++++++++++++ src/helpers.ts | 24 +++++++ src/index.test.ts | 151 +++++++++++++++++++++++++++++++++++++++++++- src/index.ts | 32 +++++++++- 4 files changed, 251 insertions(+), 4 deletions(-) diff --git a/src/helpers.test.ts b/src/helpers.test.ts index a71394f2..1c208faa 100644 --- a/src/helpers.test.ts +++ b/src/helpers.test.ts @@ -4,6 +4,8 @@ import { beforeEach, describe, expect, test, vi, type MockInstance } from 'vite- import { IOS_NULL_SENTINEL } from './constants/internal'; import { encodeNullsForIOS, + hasMissingEntries, + hasMissingItems, isNativeModuleLoaded, isMissing, isObjectSerializable, @@ -84,6 +86,52 @@ describe('helpers', () => { ); }); + describe('hasMissingEntries', () => { + test.each([ + { description: 'null', values: null, allowEmptyValue: false, expected: true }, + { description: 'an array', values: ['x'], allowEmptyValue: false, expected: true }, + { description: 'an empty key', values: { '': 'id' }, allowEmptyValue: false, expected: true }, + { description: 'an empty value', values: { a: '' }, allowEmptyValue: false, expected: true }, + { description: 'a numeric value', values: { a: 5 }, allowEmptyValue: false, expected: true }, + { + description: 'an allowed empty value', + values: { a: '' }, + allowEmptyValue: true, + expected: false, + }, + { + description: 'an allowed numeric value', + values: { a: 5 }, + allowEmptyValue: true, + expected: false, + }, + { description: 'a null value', values: { a: null }, allowEmptyValue: true, expected: true }, + { + description: 'valid entries', + values: { a: 'id' }, + allowEmptyValue: false, + expected: false, + }, + ])('should return $expected for $description', ({ values, allowEmptyValue, expected }) => { + expect( + hasMissingEntries(values as Record | null, 'addAliases', allowEmptyValue), + ).toBe(expected); + }); + }); + + describe('hasMissingItems', () => { + test.each([ + { description: 'null', values: null, expected: true }, + { description: 'a string', values: 'key', expected: true }, + { description: 'an empty item', values: ['a', ''], expected: true }, + { description: 'a non-string item', values: ['a', 1], expected: true }, + { description: 'valid items', values: ['a', 'b'], expected: false }, + { description: 'an empty array', values: [], expected: false }, + ])('should return $expected for $description', ({ values, expected }) => { + expect(hasMissingItems(values, 'removeTags', 'key')).toBe(expected); + }); + }); + describe('isObjectSerializable', () => { test.each([ { description: 'an empty object', value: {} }, diff --git a/src/helpers.ts b/src/helpers.ts index cd52f7e6..74ca28ff 100644 --- a/src/helpers.ts +++ b/src/helpers.ts @@ -24,6 +24,30 @@ export function isMissing(value: unknown, api: string): boolean { return true; } +export function hasMissingEntries( + values: Record | null | undefined, + api: string, + allowEmptyValue = false, +): boolean { + if (typeof values !== 'object' || values === null || Array.isArray(values)) { + console.error(`OneSignal: ${api}: argument must be an object`); + return true; + } + return Object.entries(values).some(([key, item]) => { + if (isMissing(key, `${api}: key`)) return true; + if (!allowEmptyValue) return isMissing(item, `${api}: value`); + return item == null && isMissing(item, `${api}: value`); + }); +} + +export function hasMissingItems(values: unknown, api: string, item: string): boolean { + if (!Array.isArray(values)) { + console.error(`OneSignal: ${api}: ${item}s must be an array of strings`); + return true; + } + return values.some((value) => isMissing(value, `${api}: ${item}`)); +} + /** * Returns true if the value is a JSON-serializable object. */ diff --git a/src/index.test.ts b/src/index.test.ts index eb8b1c48..c067335c 100644 --- a/src/index.test.ts +++ b/src/index.test.ts @@ -257,6 +257,17 @@ describe('OneSignal', () => { OneSignal.Debug.setLogLevel(LogLevel.Info); expect(mockRNOneSignal.setLogLevel).not.toHaveBeenCalled(); }); + + test.each([-1, 7, 2.5, '2', null, undefined, NaN])( + 'should not set log level for invalid level %s', + (level) => { + OneSignal.Debug.setLogLevel(level as unknown as LogLevel); + expect(mockRNOneSignal.setLogLevel).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith( + 'OneSignal: setLogLevel: level must be a LogLevel value', + ); + }, + ); }); describe('setAlertLevel', () => { @@ -270,6 +281,14 @@ describe('OneSignal', () => { OneSignal.Debug.setAlertLevel(LogLevel.Warn); expect(mockRNOneSignal.setAlertLevel).not.toHaveBeenCalled(); }); + + test('should not set alert level for an invalid level', () => { + OneSignal.Debug.setAlertLevel(99 as LogLevel); + expect(mockRNOneSignal.setAlertLevel).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith( + 'OneSignal: setAlertLevel: level must be a LogLevel value', + ); + }); }); }); @@ -742,6 +761,17 @@ describe('OneSignal', () => { OneSignal.User.addAliases({}); expect(mockRNOneSignal.addAliases).not.toHaveBeenCalled(); }); + + test.each([ + { description: 'an empty label', aliases: { '': 'id' } }, + { description: 'an empty id', aliases: { label: '' } }, + { description: 'a null id', aliases: { label: null } }, + { description: 'a non-object', aliases: ['x'] }, + ])('should not add aliases with $description', ({ aliases }) => { + OneSignal.User.addAliases(aliases as unknown as Record); + expect(mockRNOneSignal.addAliases).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalled(); + }); }); describe('removeAlias', () => { @@ -769,6 +799,20 @@ describe('OneSignal', () => { OneSignal.User.removeAliases(['label']); expect(mockRNOneSignal.removeAliases).not.toHaveBeenCalled(); }); + + test('should not remove aliases with an empty label', () => { + OneSignal.User.removeAliases(['label', '']); + expect(mockRNOneSignal.removeAliases).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith('OneSignal: removeAliases: label is required'); + }); + + test('should not remove aliases if labels is not an array', () => { + OneSignal.User.removeAliases(null as unknown as string[]); + expect(mockRNOneSignal.removeAliases).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith( + 'OneSignal: removeAliases: labels must be an array of strings', + ); + }); }); describe('addEmail', () => { @@ -872,6 +916,22 @@ describe('OneSignal', () => { OneSignal.User.addTags({ key: 'value' }); expect(mockRNOneSignal.addTags).not.toHaveBeenCalled(); }); + + test('should allow an empty tag value', () => { + OneSignal.User.addTags({ level: '' }); + expect(mockRNOneSignal.addTags).toHaveBeenCalledWith({ level: '' }); + }); + + test.each([ + { description: 'an empty key', tags: { '': 'value' } }, + { description: 'a null value', tags: { key: null } }, + { description: 'a non-object', tags: 'abc' }, + { description: 'null', tags: null }, + ])('should not add tags with $description', ({ tags }) => { + OneSignal.User.addTags(tags as unknown as Record); + expect(mockRNOneSignal.addTags).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalled(); + }); }); describe('removeTag', () => { @@ -899,6 +959,20 @@ describe('OneSignal', () => { OneSignal.User.removeTags(['key']); expect(mockRNOneSignal.removeTags).not.toHaveBeenCalled(); }); + + test('should not remove tags with an empty key', () => { + OneSignal.User.removeTags(['']); + expect(mockRNOneSignal.removeTags).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith('OneSignal: removeTags: key is required'); + }); + + test('should not remove tags if keys is not an array', () => { + OneSignal.User.removeTags('key' as unknown as string[]); + expect(mockRNOneSignal.removeTags).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith( + 'OneSignal: removeTags: keys must be an array of strings', + ); + }); }); describe('getTags', () => { @@ -937,17 +1011,27 @@ describe('OneSignal', () => { expect(mockRNOneSignal.trackEvent).not.toHaveBeenCalled(); }); + test.each(['', null, undefined])('should not track event with name %s', (name) => { + OneSignal.User.trackEvent(name as unknown as string); + expect(mockRNOneSignal.trackEvent).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith('OneSignal: trackEvent: name is required'); + }); + test('should not track event if properties are not serializable', () => { const circular: Record = {}; circular.self = circular; OneSignal.User.trackEvent('event', circular); - expect(errorSpy).toHaveBeenCalledWith('Properties must be a JSON-serializable object'); + expect(errorSpy).toHaveBeenCalledWith( + 'OneSignal: trackEvent: properties must be a JSON-serializable object', + ); expect(mockRNOneSignal.trackEvent).not.toHaveBeenCalled(); }); test('should not track event if properties is not an object', () => { OneSignal.User.trackEvent('event', 'invalid' as unknown as Record); - expect(errorSpy).toHaveBeenCalledWith('Properties must be a JSON-serializable object'); + expect(errorSpy).toHaveBeenCalledWith( + 'OneSignal: trackEvent: properties must be a JSON-serializable object', + ); expect(mockRNOneSignal.trackEvent).not.toHaveBeenCalled(); }); @@ -1383,6 +1467,21 @@ describe('OneSignal', () => { OneSignal.InAppMessages.addTriggers({ key: 'value' }); expect(mockRNOneSignal.addTriggers).not.toHaveBeenCalled(); }); + + test('should allow an empty trigger value', () => { + OneSignal.InAppMessages.addTriggers({ key: '' }); + expect(mockRNOneSignal.addTriggers).toHaveBeenCalledWith({ key: '' }); + }); + + test.each([ + { description: 'an empty key', triggers: { '': 'value' } }, + { description: 'a null value', triggers: { key: null } }, + { description: 'a non-object', triggers: ['a'] }, + ])('should not add triggers with $description', ({ triggers }) => { + OneSignal.InAppMessages.addTriggers(triggers as unknown as Record); + expect(mockRNOneSignal.addTriggers).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalled(); + }); }); describe('removeTrigger', () => { @@ -1410,6 +1509,20 @@ describe('OneSignal', () => { OneSignal.InAppMessages.removeTriggers(['key']); expect(mockRNOneSignal.removeTriggers).not.toHaveBeenCalled(); }); + + test('should not remove triggers with an empty key', () => { + OneSignal.InAppMessages.removeTriggers(['']); + expect(mockRNOneSignal.removeTriggers).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith('OneSignal: removeTriggers: key is required'); + }); + + test('should not remove triggers if keys is not an array', () => { + OneSignal.InAppMessages.removeTriggers('key' as unknown as string[]); + expect(mockRNOneSignal.removeTriggers).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith( + 'OneSignal: removeTriggers: keys must be an array of strings', + ); + }); }); describe('clearTriggers', () => { @@ -1513,6 +1626,12 @@ describe('OneSignal', () => { OneSignal.Session.addOutcome(OUTCOME_NAME); expect(mockRNOneSignal.addOutcome).not.toHaveBeenCalled(); }); + + test.each(['', null])('should not add outcome with name %s', (name) => { + OneSignal.Session.addOutcome(name as unknown as string); + expect(mockRNOneSignal.addOutcome).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith('OneSignal: addOutcome: name is required'); + }); }); describe('addUniqueOutcome', () => { @@ -1526,6 +1645,12 @@ describe('OneSignal', () => { OneSignal.Session.addUniqueOutcome(OUTCOME_NAME); expect(mockRNOneSignal.addUniqueOutcome).not.toHaveBeenCalled(); }); + + test('should not add unique outcome with an empty name', () => { + OneSignal.Session.addUniqueOutcome(''); + expect(mockRNOneSignal.addUniqueOutcome).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith('OneSignal: addUniqueOutcome: name is required'); + }); }); describe('addOutcomeWithValue', () => { @@ -1544,6 +1669,28 @@ describe('OneSignal', () => { OneSignal.Session.addOutcomeWithValue(OUTCOME_NAME, 100); expect(mockRNOneSignal.addOutcomeWithValue).not.toHaveBeenCalled(); }); + + test.each([-5, 0, 0.5])('should allow value %s', (value) => { + OneSignal.Session.addOutcomeWithValue(OUTCOME_NAME, value); + expect(mockRNOneSignal.addOutcomeWithValue).toHaveBeenCalledWith(OUTCOME_NAME, value); + }); + + test.each([NaN, Infinity, 'abc', '', ' ', null, undefined])( + 'should not add outcome with value %s', + (value) => { + OneSignal.Session.addOutcomeWithValue(OUTCOME_NAME, value as unknown as number); + expect(mockRNOneSignal.addOutcomeWithValue).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith( + 'OneSignal: addOutcomeWithValue: value must be a finite number', + ); + }, + ); + + test('should not add outcome with an empty name', () => { + OneSignal.Session.addOutcomeWithValue('', 1); + expect(mockRNOneSignal.addOutcomeWithValue).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith('OneSignal: addOutcomeWithValue: name is required'); + }); }); }); }); diff --git a/src/index.ts b/src/index.ts index ea49125d..1e8e2169 100644 --- a/src/index.ts +++ b/src/index.ts @@ -17,6 +17,8 @@ import EventManager from './events/EventManager'; import NotificationWillDisplayEvent from './events/NotificationWillDisplayEvent'; import { encodeNullsForIOS, + hasMissingEntries, + hasMissingItems, isNativeModuleLoaded, isMissing, isObjectSerializable, @@ -58,6 +60,13 @@ export enum LogLevel { Verbose, } +// Native maps the level straight onto its own enum without a range check. +function isValidLogLevel(level: unknown, api: string): boolean { + if (typeof level === 'number' && Number.isInteger(level) && level in LogLevel) return true; + console.error(`OneSignal: ${api}: level must be a LogLevel value`); + return false; +} + let notificationPermission = false; let permissionObserverAdded = false; let subscriptionObserverAdded = false; @@ -163,6 +172,7 @@ export namespace OneSignal { */ export function setLogLevel(nsLogLevel: LogLevel) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (!isValidLogLevel(nsLogLevel, 'setLogLevel')) return; RNOneSignal.setLogLevel(nsLogLevel); } @@ -173,6 +183,7 @@ export namespace OneSignal { */ export function setAlertLevel(visualLogLevel: LogLevel) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (!isValidLogLevel(visualLogLevel, 'setAlertLevel')) return; RNOneSignal.setAlertLevel(visualLogLevel); } @@ -470,6 +481,7 @@ export namespace OneSignal { /** Set aliases for the current user. If any alias already exists, it will be overwritten to the new values. */ export function addAliases(aliases: Record) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (hasMissingEntries(aliases, 'addAliases')) return; RNOneSignal.addAliases(aliases); } @@ -485,6 +497,7 @@ export namespace OneSignal { /** Remove aliases from the current user. */ export function removeAliases(labels: string[]) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (hasMissingItems(labels, 'removeAliases', 'label')) return; RNOneSignal.removeAliases(labels); } @@ -550,6 +563,7 @@ export namespace OneSignal { */ export function addTags(tags: Record) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (hasMissingEntries(tags, 'addTags', true)) return; RNOneSignal.addTags(tags); } @@ -565,6 +579,7 @@ export namespace OneSignal { /** Remove multiple tags with the provided keys from the current user. */ export function removeTags(keys: string[]) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (hasMissingItems(keys, 'removeTags', 'key')) return; RNOneSignal.removeTags(keys); } @@ -582,9 +597,10 @@ export namespace OneSignal { /** Track custom events for the current user. */ export function trackEvent(name: string, properties: Record = {}) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (isMissing(name, 'trackEvent: name')) return; if (!isObjectSerializable(properties)) { - console.error('Properties must be a JSON-serializable object'); + console.error('OneSignal: trackEvent: properties must be a JSON-serializable object'); return; } @@ -818,6 +834,7 @@ export namespace OneSignal { */ export function addTriggers(triggers: Record) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (hasMissingEntries(triggers, 'addTriggers', true)) return; RNOneSignal.addTriggers(triggers); } @@ -833,6 +850,7 @@ export namespace OneSignal { /** Remove multiple triggers from the current user. */ export function removeTriggers(keys: string[]) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (hasMissingItems(keys, 'removeTriggers', 'key')) return; RNOneSignal.removeTriggers(keys); } @@ -897,6 +915,7 @@ export namespace OneSignal { /** Increases the "Count" of this Outcome by 1 and will be counted each time sent. */ export function addOutcome(name: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (isMissing(name, 'addOutcome: name')) return; RNOneSignal.addOutcome(name); } @@ -904,6 +923,7 @@ export namespace OneSignal { /** Increases "Count" by 1 only once. This can only be attributed to a single notification. */ export function addUniqueOutcome(name: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (isMissing(name, 'addUniqueOutcome: name')) return; RNOneSignal.addUniqueOutcome(name); } @@ -915,7 +935,15 @@ export namespace OneSignal { export function addOutcomeWithValue(name: string, value: string | number) { if (!isNativeModuleLoaded(RNOneSignal)) return; - RNOneSignal.addOutcomeWithValue(name, Number(value)); + if (isMissing(name, 'addOutcomeWithValue: name')) return; + + const numericValue = typeof value === 'string' && value.trim() !== '' ? Number(value) : value; + if (typeof numericValue !== 'number' || !Number.isFinite(numericValue)) { + console.error('OneSignal: addOutcomeWithValue: value must be a finite number'); + return; + } + + RNOneSignal.addOutcomeWithValue(name, numericValue); } } } From c024f42b3f1d273acdef2a869440b1776aafd8db Mon Sep 17 00:00:00 2001 From: Fadi George Date: Fri, 2 Oct 2026 17:27:41 -0700 Subject: [PATCH 07/12] fix(sdk-5304): guard Live Activity and tag inputs --- src/helpers.ts | 12 +++++ src/index.test.ts | 118 ++++++++++++++++++++++++++++++++++++++++++++++ src/index.ts | 47 +++++++++++++++++- 3 files changed, 175 insertions(+), 2 deletions(-) diff --git a/src/helpers.ts b/src/helpers.ts index 74ca28ff..0eedaa46 100644 --- a/src/helpers.ts +++ b/src/helpers.ts @@ -24,6 +24,18 @@ export function isMissing(value: unknown, api: string): boolean { return true; } +export function isObject(value: unknown, api: string): value is Record { + if (typeof value === 'object' && value !== null && !Array.isArray(value)) return true; + console.error(`OneSignal: ${api} must be an object`); + return false; +} + +export function isFunction(value: unknown, api: string): value is Function { + if (typeof value === 'function') return true; + console.error(`OneSignal: ${api} must be a function`); + return false; +} + export function hasMissingEntries( values: Record | null | undefined, api: string, diff --git a/src/index.test.ts b/src/index.test.ts index c067335c..5e7d6ab5 100644 --- a/src/index.test.ts +++ b/src/index.test.ts @@ -18,6 +18,7 @@ import { IOS_NULL_SENTINEL } from './constants/internal'; import EventManager, { type EventListenerMap } from './events/EventManager'; import * as helpers from './helpers'; import { LogLevel, OneSignal, OSNotificationPermission } from './index'; +import type { LiveActivitySetupOptions } from './types/liveActivities'; const mockPlatform = Platform; @@ -324,6 +325,26 @@ describe('OneSignal', () => { OneSignal.LiveActivities.enter('activity-id', 'token'); expect(mockRNOneSignal.enterLiveActivity).not.toHaveBeenCalled(); }); + + test.each([ + ['', 'token', 'OneSignal: enter: activityId is required'], + [123, 'token', 'OneSignal: enter: activityId is required'], + ['activity-id', null, 'OneSignal: enter: token is required'], + ])('should not enter with activityId %s and token %s', (activityId, token, message) => { + OneSignal.LiveActivities.enter(activityId as string, token as string); + expect(mockRNOneSignal.enterLiveActivity).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith(message); + }); + + test.each([null, 1, {}])('should not enter with handler %s', (handler) => { + OneSignal.LiveActivities.enter( + 'activity-id', + 'token', + handler as unknown as (result: object) => void, + ); + expect(mockRNOneSignal.enterLiveActivity).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith('OneSignal: enter: handler must be a function'); + }); }); describe('exit', () => { @@ -353,6 +374,21 @@ describe('OneSignal', () => { expect(mockRNOneSignal.exitLiveActivity).not.toHaveBeenCalled(); mockPlatform.OS = 'ios'; }); + + test.each([null, '', 1])('should not exit with activityId %s', (activityId) => { + OneSignal.LiveActivities.exit(activityId as string); + expect(mockRNOneSignal.exitLiveActivity).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith('OneSignal: exit: activityId is required'); + }); + + test.each([null, 'cb'])('should not exit with handler %s', (handler) => { + OneSignal.LiveActivities.exit( + 'activity-id', + handler as unknown as (result: object) => void, + ); + expect(mockRNOneSignal.exitLiveActivity).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith('OneSignal: exit: handler must be a function'); + }); }); describe('setPushToStartToken', () => { @@ -373,6 +409,15 @@ describe('OneSignal', () => { expect(mockRNOneSignal.setPushToStartToken).not.toHaveBeenCalled(); mockPlatform.OS = 'ios'; }); + + test.each([ + [undefined, 'token', 'OneSignal: setPushToStartToken: activityType is required'], + ['activity-type', 7, 'OneSignal: setPushToStartToken: token is required'], + ])('should not set token with %s and %s', (activityType, token, message) => { + OneSignal.LiveActivities.setPushToStartToken(activityType as string, token as string); + expect(mockRNOneSignal.setPushToStartToken).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith(message); + }); }); describe('removePushToStartToken', () => { @@ -393,6 +438,14 @@ describe('OneSignal', () => { expect(mockRNOneSignal.removePushToStartToken).not.toHaveBeenCalled(); mockPlatform.OS = 'ios'; }); + + test.each([null, '', {}])('should not remove token with activityType %s', (activityType) => { + OneSignal.LiveActivities.removePushToStartToken(activityType as string); + expect(mockRNOneSignal.removePushToStartToken).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith( + 'OneSignal: removePushToStartToken: activityType is required', + ); + }); }); describe('setupDefault', () => { @@ -419,6 +472,34 @@ describe('OneSignal', () => { expect(mockRNOneSignal.setupDefaultLiveActivity).not.toHaveBeenCalled(); mockPlatform.OS = 'ios'; }); + + test('should allow options with only one flag', () => { + OneSignal.LiveActivities.setupDefault({ + enablePushToStart: false, + } as LiveActivitySetupOptions); + expect(mockRNOneSignal.setupDefaultLiveActivity).toHaveBeenCalledWith({ + enablePushToStart: false, + }); + }); + + test.each([ + ['a string', 'abc', 'OneSignal: setupDefault: options must be an object'], + ['an array', [], 'OneSignal: setupDefault: options must be an object'], + [ + 'a null flag', + { enablePushToStart: null }, + 'OneSignal: setupDefault: enablePushToStart must be a boolean', + ], + [ + 'an object flag', + { enablePushToUpdate: {} }, + 'OneSignal: setupDefault: enablePushToUpdate must be a boolean', + ], + ])('should not setup with %s', (_description, options, message) => { + OneSignal.LiveActivities.setupDefault(options as unknown as LiveActivitySetupOptions); + expect(mockRNOneSignal.setupDefaultLiveActivity).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith(message); + }); }); describe('startDefault', () => { @@ -445,6 +526,21 @@ describe('OneSignal', () => { expect(mockRNOneSignal.startDefaultLiveActivity).not.toHaveBeenCalled(); mockPlatform.OS = 'ios'; }); + + test.each([ + [null, {}, {}, 'OneSignal: startDefault: activityId is required'], + ['activity-id', null, {}, 'OneSignal: startDefault: attributes must be an object'], + ['activity-id', {}, 'content', 'OneSignal: startDefault: content must be an object'], + ['activity-id', {}, [], 'OneSignal: startDefault: content must be an object'], + ])('should not start with %s, %s, %s', (activityId, attributes, content, message) => { + OneSignal.LiveActivities.startDefault( + activityId as string, + attributes as object, + content as object, + ); + expect(mockRNOneSignal.startDefaultLiveActivity).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith(message); + }); }); }); @@ -897,6 +993,14 @@ describe('OneSignal', () => { expect(mockRNOneSignal.addTag).not.toHaveBeenCalled(); }); + test.each([ + [5, '5'], + [false, 'false'], + ])('should convert tag value %s to a string', (value, expected) => { + OneSignal.User.addTag('key', value as unknown as string); + expect(mockRNOneSignal.addTag).toHaveBeenCalledWith('key', expected); + }); + test('should not add tag if native module is not loaded', () => { isNativeLoadedSpy.mockReturnValue(false); OneSignal.User.addTag('key', 'value'); @@ -922,6 +1026,11 @@ describe('OneSignal', () => { expect(mockRNOneSignal.addTags).toHaveBeenCalledWith({ level: '' }); }); + test('should convert non-string tag values to strings', () => { + OneSignal.User.addTags({ age: 5, vip: true } as unknown as Record); + expect(mockRNOneSignal.addTags).toHaveBeenCalledWith({ age: '5', vip: 'true' }); + }); + test.each([ { description: 'an empty key', tags: { '': 'value' } }, { description: 'a null value', tags: { key: null } }, @@ -1337,6 +1446,15 @@ describe('OneSignal', () => { expect(mockRNOneSignal.removeGroupedNotifications).not.toHaveBeenCalled(); }); + test.each([null, undefined, ''])('should not remove with group id %s', (id) => { + OneSignal.Notifications.removeGroupedNotifications(id as string); + + expect(mockRNOneSignal.removeGroupedNotifications).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith( + 'OneSignal: removeGroupedNotifications: id is required', + ); + }); + test('should log message on iOS', () => { mockPlatform.OS = 'ios'; OneSignal.Notifications.removeGroupedNotifications(GROUP_ID); diff --git a/src/index.ts b/src/index.ts index 1e8e2169..3bb8ad72 100644 --- a/src/index.ts +++ b/src/index.ts @@ -20,7 +20,9 @@ import { hasMissingEntries, hasMissingItems, isNativeModuleLoaded, + isFunction, isMissing, + isObject, isObjectSerializable, isValidCallback, } from './helpers'; @@ -67,6 +69,21 @@ function isValidLogLevel(level: unknown, api: string): boolean { return false; } +// iOS reads each flag with `boolValue`, which throws on objects, arrays, and NSNull. +function isValidSetupOptions(options: unknown): boolean { + if (!isObject(options, 'setupDefault: options')) return false; + return (['enablePushToStart', 'enablePushToUpdate'] as const).every((flag) => { + if (options[flag] === undefined || typeof options[flag] === 'boolean') return true; + console.error(`OneSignal: setupDefault: ${flag} must be a boolean`); + return false; + }); +} + +// iOS bridges tags into a Swift [String: String], which crashes on non-string values. +function stringifyValues(values: Record): Record { + return Object.fromEntries(Object.entries(values).map(([key, value]) => [key, String(value)])); +} + let notificationPermission = false; let permissionObserverAdded = false; let subscriptionObserverAdded = false; @@ -206,6 +223,13 @@ export namespace OneSignal { if (!isNativeModuleLoaded(RNOneSignal)) return; if (Platform.OS === 'ios') { + if ( + isMissing(activityId, 'enter: activityId') || + isMissing(token, 'enter: token') || + !isFunction(handler, 'enter: handler') + ) { + return; + } RNOneSignal.enterLiveActivity(activityId, token, handler); } } @@ -222,6 +246,9 @@ export namespace OneSignal { if (!isNativeModuleLoaded(RNOneSignal)) return; if (Platform.OS === 'ios') { + if (isMissing(activityId, 'exit: activityId') || !isFunction(handler, 'exit: handler')) { + return; + } RNOneSignal.exitLiveActivity(activityId, handler); } } @@ -241,6 +268,12 @@ export namespace OneSignal { if (!isNativeModuleLoaded(RNOneSignal)) return; if (Platform.OS === 'ios') { + if ( + isMissing(activityType, 'setPushToStartToken: activityType') || + isMissing(token, 'setPushToStartToken: token') + ) { + return; + } RNOneSignal.setPushToStartToken(activityType, token); } } @@ -259,6 +292,7 @@ export namespace OneSignal { if (!isNativeModuleLoaded(RNOneSignal)) return; if (Platform.OS === 'ios') { + if (isMissing(activityType, 'removePushToStartToken: activityType')) return; RNOneSignal.removePushToStartToken(activityType); } } @@ -281,6 +315,7 @@ export namespace OneSignal { if (!isNativeModuleLoaded(RNOneSignal)) return; if (Platform.OS === 'ios') { + if (options != null && !isValidSetupOptions(options)) return; RNOneSignal.setupDefaultLiveActivity(options ?? null); } } @@ -301,6 +336,13 @@ export namespace OneSignal { if (!isNativeModuleLoaded(RNOneSignal)) return; if (Platform.OS === 'ios') { + if ( + isMissing(activityId, 'startDefault: activityId') || + !isObject(attributes, 'startDefault: attributes') || + !isObject(content, 'startDefault: content') + ) { + return; + } RNOneSignal.startDefaultLiveActivity(activityId, attributes, content); } } @@ -553,7 +595,7 @@ export namespace OneSignal { return; } - RNOneSignal.addTag(key, value); + RNOneSignal.addTag(key, String(value)); } /** @@ -565,7 +607,7 @@ export namespace OneSignal { if (!isNativeModuleLoaded(RNOneSignal)) return; if (hasMissingEntries(tags, 'addTags', true)) return; - RNOneSignal.addTags(tags); + RNOneSignal.addTags(stringifyValues(tags)); } /** Remove the data tag with the provided key from the current user. */ @@ -757,6 +799,7 @@ export namespace OneSignal { if (!isNativeModuleLoaded(RNOneSignal)) return; if (Platform.OS === 'android') { + if (isMissing(id, 'removeGroupedNotifications: id')) return; RNOneSignal.removeGroupedNotifications(id); } else { console.warn('removeGroupedNotifications: this function is not supported on iOS'); From a98f2249cc3afebaeaa9cfc50b31757ed6c4ff38 Mon Sep 17 00:00:00 2001 From: Fadi George Date: Fri, 2 Oct 2026 17:42:28 -0700 Subject: [PATCH 08/12] fix(sdk-5304): JSON round-trip properties in trackEvent --- src/index.test.ts | 41 +++++++++++++++++++++++++++++++++++++++++ src/index.ts | 15 +++++++++++++-- 2 files changed, 54 insertions(+), 2 deletions(-) diff --git a/src/index.test.ts b/src/index.test.ts index 5e7d6ab5..72cffe69 100644 --- a/src/index.test.ts +++ b/src/index.test.ts @@ -1109,6 +1109,47 @@ describe('OneSignal', () => { expect(mockRNOneSignal.trackEvent).toHaveBeenCalledWith('purchase', properties); }); + describe.each(['android', 'ios'] as const)('JSON round-trip on %s', (os) => { + const sent = (value: Record) => + os === 'ios' ? helpers.encodeNullsForIOS(value) : value; + + beforeEach(() => { + mockPlatform.OS = os; + }); + + test.each([ + { + description: 'NaN and Infinity as null', + properties: { abc: NaN, def: Infinity, nested: { items: [1, -Infinity] } }, + expected: { abc: null, def: null, nested: { items: [1, null] } }, + }, + { + description: 'a Date as an ISO string', + properties: { at: new Date('2026-01-02T03:04:05.000Z') }, + expected: { at: '2026-01-02T03:04:05.000Z' }, + }, + { + description: 'undefined values and functions dropped', + properties: { kept: 'yes', missing: undefined, fn: () => {} }, + expected: { kept: 'yes' }, + }, + { + description: 'JSON values unchanged', + properties: { s: 'x', n: 1.5, b: false, nil: null, list: ['a', { deep: 2 }] }, + expected: { s: 'x', n: 1.5, b: false, nil: null, list: ['a', { deep: 2 }] }, + }, + ])('should send $description', ({ properties, expected }) => { + OneSignal.User.trackEvent('purchase', properties); + expect(mockRNOneSignal.trackEvent).toHaveBeenCalledWith('purchase', sent(expected)); + }); + + test('should not mutate the caller properties', () => { + const properties = { abc: NaN }; + OneSignal.User.trackEvent('purchase', properties); + expect(properties.abc).toBeNaN(); + }); + }); + test('should track event with just name using default empty properties', () => { OneSignal.User.trackEvent('page_view'); expect(mockRNOneSignal.trackEvent).toHaveBeenCalledWith('page_view', {}); diff --git a/src/index.ts b/src/index.ts index 3bb8ad72..d750f883 100644 --- a/src/index.ts +++ b/src/index.ts @@ -636,7 +636,14 @@ export namespace OneSignal { return tags as { [key: string]: string }; } - /** Track custom events for the current user. */ + /** + * Track custom events for the current user. + * + * @param name - The event name. + * @param properties - A JSON-serializable object, sent as its `JSON.stringify` result: + * `NaN` and `Infinity` become `null`, `Date` values become ISO strings, and `undefined` + * values and functions are omitted. + */ export function trackEvent(name: string, properties: Record = {}) { if (!isNativeModuleLoaded(RNOneSignal)) return; if (isMissing(name, 'trackEvent: name')) return; @@ -646,10 +653,14 @@ export namespace OneSignal { return; } + // Native JSON serializers reject NaN and Infinity (Android throws, iOS drops the event), + // so send the JSON round-trip, where they become null. + const json = JSON.parse(JSON.stringify(properties)) as Record; + // The iOS TurboModule bridge drops dictionary entries whose value is // `null`. Encode nulls as a sentinel string so the native side can // restore them as `NSNull`. See SDK-4386. - const payload = Platform.OS === 'ios' ? encodeNullsForIOS(properties) : properties; + const payload = Platform.OS === 'ios' ? encodeNullsForIOS(json) : json; RNOneSignal.trackEvent(name, payload); } From dcb6bdf0d3946ba929f8a8c98c9abecd6a058dc5 Mon Sep 17 00:00:00 2001 From: Fadi George Date: Fri, 2 Oct 2026 18:03:28 -0700 Subject: [PATCH 09/12] refactor(sdk-5304): simplify hasMissingEntries and drop redundant callback guard --- src/helpers.ts | 5 +---- src/index.ts | 1 - 2 files changed, 1 insertion(+), 5 deletions(-) diff --git a/src/helpers.ts b/src/helpers.ts index 0eedaa46..9ce14bb2 100644 --- a/src/helpers.ts +++ b/src/helpers.ts @@ -41,10 +41,7 @@ export function hasMissingEntries( api: string, allowEmptyValue = false, ): boolean { - if (typeof values !== 'object' || values === null || Array.isArray(values)) { - console.error(`OneSignal: ${api}: argument must be an object`); - return true; - } + if (!isObject(values, `${api}: argument`)) return true; return Object.entries(values).some(([key, item]) => { if (isMissing(key, `${api}: key`)) return true; if (!allowEmptyValue) return isMissing(item, `${api}: value`); diff --git a/src/index.ts b/src/index.ts index d750f883..31c7a21c 100644 --- a/src/index.ts +++ b/src/index.ts @@ -759,7 +759,6 @@ export namespace OneSignal { RNOneSignal.addNotificationForegroundLifecycleListener(); eventManager.addEventListener(NOTIFICATION_WILL_DISPLAY, listener); } else if (event === 'permissionChange') { - isValidCallback(listener); RNOneSignal.addPermissionObserver(); eventManager.addEventListener(PERMISSION_CHANGED, listener); } From 386d342f27b28007352fe4c4439c1df848ac6ff2 Mon Sep 17 00:00:00 2001 From: Fadi George Date: Fri, 2 Oct 2026 18:09:13 -0700 Subject: [PATCH 10/12] fix(sdk-5304): guard boolean inputs across APIs --- src/helpers.test.ts | 13 ++++++++++++ src/helpers.ts | 6 ++++++ src/index.test.ts | 49 +++++++++++++++++++++++++++++++++++++++++++++ src/index.ts | 11 ++++++++-- 4 files changed, 77 insertions(+), 2 deletions(-) diff --git a/src/helpers.test.ts b/src/helpers.test.ts index 1c208faa..0eeeff18 100644 --- a/src/helpers.test.ts +++ b/src/helpers.test.ts @@ -6,6 +6,7 @@ import { encodeNullsForIOS, hasMissingEntries, hasMissingItems, + isBoolean, isNativeModuleLoaded, isMissing, isObjectSerializable, @@ -69,6 +70,18 @@ describe('helpers', () => { }); }); + describe('isBoolean', () => { + test.each([true, false])('should accept %s', (value) => { + expect(isBoolean(value, 'api: flag')).toBe(true); + expect(errorSpy).not.toHaveBeenCalled(); + }); + + test.each([undefined, null, 'true', 0, {}])('should reject %s', (value) => { + expect(isBoolean(value, 'api: flag')).toBe(false); + expect(errorSpy).toHaveBeenCalledWith('OneSignal: api: flag must be a boolean'); + }); + }); + describe('isMissing', () => { test.each([ { description: 'a non-empty string', value: 'id', expected: false }, diff --git a/src/helpers.ts b/src/helpers.ts index 9ce14bb2..d55ade68 100644 --- a/src/helpers.ts +++ b/src/helpers.ts @@ -24,6 +24,12 @@ export function isMissing(value: unknown, api: string): boolean { return true; } +export function isBoolean(value: unknown, api: string): value is boolean { + if (typeof value === 'boolean') return true; + console.error(`OneSignal: ${api} must be a boolean`); + return false; +} + export function isObject(value: unknown, api: string): value is Record { if (typeof value === 'object' && value !== null && !Array.isArray(value)) return true; console.error(`OneSignal: ${api} must be an object`); diff --git a/src/index.test.ts b/src/index.test.ts index 72cffe69..052f225a 100644 --- a/src/index.test.ts +++ b/src/index.test.ts @@ -231,6 +231,14 @@ describe('OneSignal', () => { OneSignal.setConsentRequired(true); expect(mockRNOneSignal.setPrivacyConsentRequired).not.toHaveBeenCalled(); }); + + test.each([undefined, null, 'true', 1])('should not set consent required with %s', (value) => { + OneSignal.setConsentRequired(value as unknown as boolean); + expect(mockRNOneSignal.setPrivacyConsentRequired).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith( + 'OneSignal: setConsentRequired: required must be a boolean', + ); + }); }); describe('setConsentGiven', () => { @@ -244,6 +252,14 @@ describe('OneSignal', () => { OneSignal.setConsentGiven(true); expect(mockRNOneSignal.setPrivacyConsentGiven).not.toHaveBeenCalled(); }); + + test.each([undefined, null, 'false', 0])('should not set consent given with %s', (value) => { + OneSignal.setConsentGiven(value as unknown as boolean); + expect(mockRNOneSignal.setPrivacyConsentGiven).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith( + 'OneSignal: setConsentGiven: granted must be a boolean', + ); + }); }); describe('Debug', () => { @@ -1292,6 +1308,22 @@ describe('OneSignal', () => { 'OneSignal native module not loaded', ); }); + + test('should default fallbackToSettings to false', async () => { + vi.mocked(mockRNOneSignal.requestNotificationPermission).mockResolvedValue(true); + await OneSignal.Notifications.requestPermission(); + expect(mockRNOneSignal.requestNotificationPermission).toHaveBeenCalledWith(false); + }); + + test.each([null, 'true', 1])('should reject fallbackToSettings %s', async (value) => { + await expect( + OneSignal.Notifications.requestPermission(value as unknown as boolean), + ).rejects.toThrow('fallbackToSettings must be a boolean'); + expect(mockRNOneSignal.requestNotificationPermission).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith( + 'OneSignal: requestPermission: fallbackToSettings must be a boolean', + ); + }); }); describe('canRequestPermission', () => { @@ -1587,6 +1619,11 @@ describe('OneSignal', () => { OneSignal.InAppMessages.removeEventListener(eventName as any, listener); expect(removeEventManagerListenerSpy).toHaveBeenCalledWith(eventConstant, listener); }); + + test('should not validate the listener', () => { + OneSignal.InAppMessages.removeEventListener('click', null as unknown as () => void); + expect(isValidCallbackSpy).not.toHaveBeenCalled(); + }); }); describe('addTrigger', () => { @@ -1708,6 +1745,12 @@ describe('OneSignal', () => { OneSignal.InAppMessages.setPaused(true); expect(mockRNOneSignal.paused).not.toHaveBeenCalled(); }); + + test.each([undefined, null, 'true', 1, {}])('should not set paused with %s', (value) => { + OneSignal.InAppMessages.setPaused(value as unknown as boolean); + expect(mockRNOneSignal.paused).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith('OneSignal: setPaused: pause must be a boolean'); + }); }); describe('getPaused', () => { @@ -1752,6 +1795,12 @@ describe('OneSignal', () => { OneSignal.Location.setShared(true); expect(mockRNOneSignal.setLocationShared).not.toHaveBeenCalled(); }); + + test.each([undefined, null, 'false', 0])('should not set shared with %s', (value) => { + OneSignal.Location.setShared(value as unknown as boolean); + expect(mockRNOneSignal.setLocationShared).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith('OneSignal: setShared: shared must be a boolean'); + }); }); describe('isShared', () => { diff --git a/src/index.ts b/src/index.ts index 31c7a21c..ffd0e2f6 100644 --- a/src/index.ts +++ b/src/index.ts @@ -19,6 +19,7 @@ import { encodeNullsForIOS, hasMissingEntries, hasMissingItems, + isBoolean, isNativeModuleLoaded, isFunction, isMissing, @@ -167,6 +168,7 @@ export namespace OneSignal { /** For GDPR users, your application should call this method before setting the App ID. */ export function setConsentRequired(required: boolean) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (!isBoolean(required, 'setConsentRequired: required')) return; RNOneSignal.setPrivacyConsentRequired(required); } @@ -178,6 +180,7 @@ export namespace OneSignal { */ export function setConsentGiven(granted: boolean) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (!isBoolean(granted, 'setConsentGiven: granted')) return; RNOneSignal.setPrivacyConsentGiven(granted); } @@ -691,10 +694,13 @@ export namespace OneSignal { * notification permission. Use the fallbackToSettings parameter to prompt to open the settings app if a user has already * declined push permissions. */ - export function requestPermission(fallbackToSettings: boolean): Promise { + export function requestPermission(fallbackToSettings = false): Promise { if (!isNativeModuleLoaded(RNOneSignal)) { return Promise.reject(new Error('OneSignal native module not loaded')); } + if (!isBoolean(fallbackToSettings, 'requestPermission: fallbackToSettings')) { + return Promise.reject(new Error('fallbackToSettings must be a boolean')); + } return RNOneSignal.requestNotificationPermission(fallbackToSettings); } @@ -849,7 +855,6 @@ export namespace OneSignal { */ export function removeEventListener(...[event, listener]: InAppMessageListeners): void { if (!isNativeModuleLoaded(RNOneSignal)) return; - isValidCallback(listener); if (event === 'click') { eventManager.removeEventListener(IN_APP_MESSAGE_CLICKED, listener); @@ -922,6 +927,7 @@ export namespace OneSignal { */ export function setPaused(pause: boolean) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (!isBoolean(pause, 'setPaused: pause')) return; RNOneSignal.paused(pause); } @@ -947,6 +953,7 @@ export namespace OneSignal { /** Disable or enable location collection (defaults to enabled if your app has location permission). */ export function setShared(shared: boolean) { if (!isNativeModuleLoaded(RNOneSignal)) return; + if (!isBoolean(shared, 'setShared: shared')) return; RNOneSignal.setLocationShared(shared); } From 1a52cbc9488aefe74d4e17835b5a8c808325363f Mon Sep 17 00:00:00 2001 From: Fadi George Date: Fri, 2 Oct 2026 18:16:26 -0700 Subject: [PATCH 11/12] fix(sdk-5304): guard integer inputs across APIs --- src/helpers.test.ts | 13 ++++++++++++ src/helpers.ts | 6 ++++++ src/index.test.ts | 48 +++++++++++++++++++++++++++++++++++---------- src/index.ts | 17 +++++++++------- 4 files changed, 67 insertions(+), 17 deletions(-) diff --git a/src/helpers.test.ts b/src/helpers.test.ts index 0eeeff18..b3823f3f 100644 --- a/src/helpers.test.ts +++ b/src/helpers.test.ts @@ -7,6 +7,7 @@ import { hasMissingEntries, hasMissingItems, isBoolean, + isInteger, isNativeModuleLoaded, isMissing, isObjectSerializable, @@ -82,6 +83,18 @@ describe('helpers', () => { }); }); + describe('isInteger', () => { + test.each([0, 5, -3])('should accept %s', (value) => { + expect(isInteger(value, 'api: id')).toBe(true); + expect(errorSpy).not.toHaveBeenCalled(); + }); + + test.each([undefined, null, '1', 1.5, NaN, Infinity])('should reject %s', (value) => { + expect(isInteger(value, 'api: id')).toBe(false); + expect(errorSpy).toHaveBeenCalledWith('OneSignal: api: id must be an integer'); + }); + }); + describe('isMissing', () => { test.each([ { description: 'a non-empty string', value: 'id', expected: false }, diff --git a/src/helpers.ts b/src/helpers.ts index d55ade68..816412f0 100644 --- a/src/helpers.ts +++ b/src/helpers.ts @@ -30,6 +30,12 @@ export function isBoolean(value: unknown, api: string): value is boolean { return false; } +export function isInteger(value: unknown, api: string): value is number { + if (Number.isInteger(value)) return true; + console.error(`OneSignal: ${api} must be an integer`); + return false; +} + export function isObject(value: unknown, api: string): value is Record { if (typeof value === 'object' && value !== null && !Array.isArray(value)) return true; console.error(`OneSignal: ${api} must be an object`); diff --git a/src/index.test.ts b/src/index.test.ts index 052f225a..4b24944a 100644 --- a/src/index.test.ts +++ b/src/index.test.ts @@ -275,14 +275,20 @@ describe('OneSignal', () => { expect(mockRNOneSignal.setLogLevel).not.toHaveBeenCalled(); }); - test.each([-1, 7, 2.5, '2', null, undefined, NaN])( - 'should not set log level for invalid level %s', + test.each([-1, 7])('should not set log level for out-of-range level %s', (level) => { + OneSignal.Debug.setLogLevel(level as LogLevel); + expect(mockRNOneSignal.setLogLevel).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith( + 'OneSignal: setLogLevel: level must be a LogLevel value', + ); + }); + + test.each([2.5, '2', null, undefined, NaN])( + 'should not set log level for non-integer level %s', (level) => { OneSignal.Debug.setLogLevel(level as unknown as LogLevel); expect(mockRNOneSignal.setLogLevel).not.toHaveBeenCalled(); - expect(errorSpy).toHaveBeenCalledWith( - 'OneSignal: setLogLevel: level must be a LogLevel value', - ); + expect(errorSpy).toHaveBeenCalledWith('OneSignal: setLogLevel: level must be an integer'); }, ); }); @@ -1315,7 +1321,13 @@ describe('OneSignal', () => { expect(mockRNOneSignal.requestNotificationPermission).toHaveBeenCalledWith(false); }); - test.each([null, 'true', 1])('should reject fallbackToSettings %s', async (value) => { + test('should treat null fallbackToSettings as false', async () => { + vi.mocked(mockRNOneSignal.requestNotificationPermission).mockResolvedValue(true); + await OneSignal.Notifications.requestPermission(null); + expect(mockRNOneSignal.requestNotificationPermission).toHaveBeenCalledWith(false); + }); + + test.each(['true', 1])('should reject fallbackToSettings %s', async (value) => { await expect( OneSignal.Notifications.requestPermission(value as unknown as boolean), ).rejects.toThrow('fallbackToSettings must be a boolean'); @@ -1486,6 +1498,14 @@ describe('OneSignal', () => { expect(mockRNOneSignal.removeNotification).toHaveBeenCalledWith(NOTIFICATION_ID); }); + test.each(['123', null, 1.5, NaN])('should not remove for invalid id %s', (id) => { + OneSignal.Notifications.removeNotification(id as unknown as number); + expect(mockRNOneSignal.removeNotification).not.toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith( + 'OneSignal: removeNotification: id must be an integer', + ); + }); + test('should not remove if native module is not loaded', () => { isNativeLoadedSpy.mockReturnValue(false); OneSignal.Notifications.removeNotification(NOTIFICATION_ID); @@ -1638,12 +1658,20 @@ describe('OneSignal', () => { expect(mockRNOneSignal.addTrigger).not.toHaveBeenCalled(); }); - test('should not add trigger if value is null', () => { - OneSignal.InAppMessages.addTrigger('key', null as unknown as string); - expect(errorSpy).toHaveBeenCalled(); - expect(mockRNOneSignal.addTrigger).not.toHaveBeenCalled(); + test('should allow an empty value', () => { + OneSignal.InAppMessages.addTrigger('key', ''); + expect(mockRNOneSignal.addTrigger).toHaveBeenCalledWith('key', ''); }); + test.each([null, undefined, false, 5, {}])( + 'should not add trigger for value %s', + (value) => { + OneSignal.InAppMessages.addTrigger('key', value as unknown as string); + expect(errorSpy).toHaveBeenCalledWith('OneSignal: addTrigger: value must be a string'); + expect(mockRNOneSignal.addTrigger).not.toHaveBeenCalled(); + }, + ); + test('should not add trigger if native module is not loaded', () => { isNativeLoadedSpy.mockReturnValue(false); OneSignal.InAppMessages.addTrigger('key', 'value'); diff --git a/src/index.ts b/src/index.ts index ffd0e2f6..7a06f432 100644 --- a/src/index.ts +++ b/src/index.ts @@ -20,6 +20,7 @@ import { hasMissingEntries, hasMissingItems, isBoolean, + isInteger, isNativeModuleLoaded, isFunction, isMissing, @@ -65,7 +66,8 @@ export enum LogLevel { // Native maps the level straight onto its own enum without a range check. function isValidLogLevel(level: unknown, api: string): boolean { - if (typeof level === 'number' && Number.isInteger(level) && level in LogLevel) return true; + if (!isInteger(level, `${api}: level`)) return false; + if (level in LogLevel) return true; console.error(`OneSignal: ${api}: level must be a LogLevel value`); return false; } @@ -694,15 +696,16 @@ export namespace OneSignal { * notification permission. Use the fallbackToSettings parameter to prompt to open the settings app if a user has already * declined push permissions. */ - export function requestPermission(fallbackToSettings = false): Promise { + export function requestPermission(fallbackToSettings?: boolean | null): Promise { if (!isNativeModuleLoaded(RNOneSignal)) { return Promise.reject(new Error('OneSignal native module not loaded')); } - if (!isBoolean(fallbackToSettings, 'requestPermission: fallbackToSettings')) { + const fallback = fallbackToSettings ?? false; + if (!isBoolean(fallback, 'requestPermission: fallbackToSettings')) { return Promise.reject(new Error('fallbackToSettings must be a boolean')); } - return RNOneSignal.requestNotificationPermission(fallbackToSettings); + return RNOneSignal.requestNotificationPermission(fallback); } /** @@ -800,6 +803,7 @@ export namespace OneSignal { if (!isNativeModuleLoaded(RNOneSignal)) return; if (Platform.OS === 'android') { + if (!isInteger(id, 'removeNotification: id')) return; RNOneSignal.removeNotification(id); } else { console.warn('removeNotification: this function is not supported on iOS'); @@ -876,10 +880,9 @@ export namespace OneSignal { export function addTrigger(key: string, value: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; - // false is a valid trigger value, so reject only null/undefined for value. if (isMissing(key, 'addTrigger: key')) return; - if (value == null) { - console.error('OneSignal: addTrigger: value is required'); + if (typeof value !== 'string') { + console.error('OneSignal: addTrigger: value must be a string'); return; } From 4a97eb0d0e986f3c5354ca04cfd65509b43f851d Mon Sep 17 00:00:00 2001 From: Fadi George Date: Fri, 2 Oct 2026 18:17:56 -0700 Subject: [PATCH 12/12] refactor(sdk-5304): use [OneSignal] log prefix --- src/helpers.test.ts | 6 +-- src/helpers.ts | 14 +++--- src/index.test.ts | 110 +++++++++++++++++++++++--------------------- src/index.ts | 32 +++++++------ 4 files changed, 84 insertions(+), 78 deletions(-) diff --git a/src/helpers.test.ts b/src/helpers.test.ts index b3823f3f..60c39f96 100644 --- a/src/helpers.test.ts +++ b/src/helpers.test.ts @@ -60,7 +60,7 @@ describe('helpers', () => { expect(result).toBe(false); expect(errorSpy).toHaveBeenCalledTimes(1); expect(errorSpy).toHaveBeenCalledWith( - 'Could not load RNOneSignal native module. Make sure native dependencies are properly linked.', + '[OneSignal] Could not load RNOneSignal native module. Make sure native dependencies are properly linked.', ); }, ); @@ -79,7 +79,7 @@ describe('helpers', () => { test.each([undefined, null, 'true', 0, {}])('should reject %s', (value) => { expect(isBoolean(value, 'api: flag')).toBe(false); - expect(errorSpy).toHaveBeenCalledWith('OneSignal: api: flag must be a boolean'); + expect(errorSpy).toHaveBeenCalledWith('[OneSignal] api: flag must be a boolean'); }); }); @@ -91,7 +91,7 @@ describe('helpers', () => { test.each([undefined, null, '1', 1.5, NaN, Infinity])('should reject %s', (value) => { expect(isInteger(value, 'api: id')).toBe(false); - expect(errorSpy).toHaveBeenCalledWith('OneSignal: api: id must be an integer'); + expect(errorSpy).toHaveBeenCalledWith('[OneSignal] api: id must be an integer'); }); }); diff --git a/src/helpers.ts b/src/helpers.ts index 816412f0..d51f360e 100644 --- a/src/helpers.ts +++ b/src/helpers.ts @@ -9,7 +9,7 @@ export function isValidCallback(handler: Function) { export function isNativeModuleLoaded(module: object | null | undefined): boolean { if (module == null) { console.error( - 'Could not load RNOneSignal native module. Make sure native dependencies are properly linked.', + '[OneSignal] Could not load RNOneSignal native module. Make sure native dependencies are properly linked.', ); return false; @@ -20,31 +20,31 @@ export function isNativeModuleLoaded(module: object | null | undefined): boolean export function isMissing(value: unknown, api: string): boolean { if (typeof value === 'string' && value.length > 0) return false; - console.error(`OneSignal: ${api} is required`); + console.error(`[OneSignal] ${api} is required`); return true; } export function isBoolean(value: unknown, api: string): value is boolean { if (typeof value === 'boolean') return true; - console.error(`OneSignal: ${api} must be a boolean`); + console.error(`[OneSignal] ${api} must be a boolean`); return false; } export function isInteger(value: unknown, api: string): value is number { if (Number.isInteger(value)) return true; - console.error(`OneSignal: ${api} must be an integer`); + console.error(`[OneSignal] ${api} must be an integer`); return false; } export function isObject(value: unknown, api: string): value is Record { if (typeof value === 'object' && value !== null && !Array.isArray(value)) return true; - console.error(`OneSignal: ${api} must be an object`); + console.error(`[OneSignal] ${api} must be an object`); return false; } export function isFunction(value: unknown, api: string): value is Function { if (typeof value === 'function') return true; - console.error(`OneSignal: ${api} must be a function`); + console.error(`[OneSignal] ${api} must be a function`); return false; } @@ -63,7 +63,7 @@ export function hasMissingEntries( export function hasMissingItems(values: unknown, api: string, item: string): boolean { if (!Array.isArray(values)) { - console.error(`OneSignal: ${api}: ${item}s must be an array of strings`); + console.error(`[OneSignal] ${api}: ${item}s must be an array of strings`); return true; } return values.some((value) => isMissing(value, `${api}: ${item}`)); diff --git a/src/index.test.ts b/src/index.test.ts index 4b24944a..d4354e79 100644 --- a/src/index.test.ts +++ b/src/index.test.ts @@ -116,13 +116,13 @@ describe('OneSignal', () => { test('should not initialize if appId is null', () => { OneSignal.initialize(null as unknown as string); expect(mockRNOneSignal.initialize).not.toHaveBeenCalled(); - expect(errorSpy).toHaveBeenCalledWith('OneSignal: initialize: appId is required'); + expect(errorSpy).toHaveBeenCalledWith('[OneSignal] initialize: appId is required'); }); test('should not initialize if appId is empty', () => { OneSignal.initialize(''); expect(mockRNOneSignal.initialize).not.toHaveBeenCalled(); - expect(errorSpy).toHaveBeenCalledWith('OneSignal: initialize: appId is required'); + expect(errorSpy).toHaveBeenCalledWith('[OneSignal] initialize: appId is required'); }); test('should keep a permission event that arrives before the startup read resolves', async () => { @@ -176,7 +176,7 @@ describe('OneSignal', () => { await flushPromises(); expect(console.warn).toHaveBeenCalledWith( - 'OneSignal: failed to read initial state', + '[OneSignal] failed to read initial state', expect.any(Error), ); }); @@ -197,13 +197,13 @@ describe('OneSignal', () => { test('should not login if externalId is null', () => { OneSignal.login(null as unknown as string); expect(mockRNOneSignal.login).not.toHaveBeenCalled(); - expect(errorSpy).toHaveBeenCalledWith('OneSignal: login: externalId is required'); + expect(errorSpy).toHaveBeenCalledWith('[OneSignal] login: externalId is required'); }); test('should not login if externalId is empty', () => { OneSignal.login(''); expect(mockRNOneSignal.login).not.toHaveBeenCalled(); - expect(errorSpy).toHaveBeenCalledWith('OneSignal: login: externalId is required'); + expect(errorSpy).toHaveBeenCalledWith('[OneSignal] login: externalId is required'); }); }); @@ -236,7 +236,7 @@ describe('OneSignal', () => { OneSignal.setConsentRequired(value as unknown as boolean); expect(mockRNOneSignal.setPrivacyConsentRequired).not.toHaveBeenCalled(); expect(errorSpy).toHaveBeenCalledWith( - 'OneSignal: setConsentRequired: required must be a boolean', + '[OneSignal] setConsentRequired: required must be a boolean', ); }); }); @@ -257,7 +257,7 @@ describe('OneSignal', () => { OneSignal.setConsentGiven(value as unknown as boolean); expect(mockRNOneSignal.setPrivacyConsentGiven).not.toHaveBeenCalled(); expect(errorSpy).toHaveBeenCalledWith( - 'OneSignal: setConsentGiven: granted must be a boolean', + '[OneSignal] setConsentGiven: granted must be a boolean', ); }); }); @@ -279,7 +279,7 @@ describe('OneSignal', () => { OneSignal.Debug.setLogLevel(level as LogLevel); expect(mockRNOneSignal.setLogLevel).not.toHaveBeenCalled(); expect(errorSpy).toHaveBeenCalledWith( - 'OneSignal: setLogLevel: level must be a LogLevel value', + '[OneSignal] setLogLevel: level must be a LogLevel value', ); }); @@ -288,7 +288,9 @@ describe('OneSignal', () => { (level) => { OneSignal.Debug.setLogLevel(level as unknown as LogLevel); expect(mockRNOneSignal.setLogLevel).not.toHaveBeenCalled(); - expect(errorSpy).toHaveBeenCalledWith('OneSignal: setLogLevel: level must be an integer'); + expect(errorSpy).toHaveBeenCalledWith( + '[OneSignal] setLogLevel: level must be an integer', + ); }, ); }); @@ -309,7 +311,7 @@ describe('OneSignal', () => { OneSignal.Debug.setAlertLevel(99 as LogLevel); expect(mockRNOneSignal.setAlertLevel).not.toHaveBeenCalled(); expect(errorSpy).toHaveBeenCalledWith( - 'OneSignal: setAlertLevel: level must be a LogLevel value', + '[OneSignal] setAlertLevel: level must be a LogLevel value', ); }); }); @@ -349,9 +351,9 @@ describe('OneSignal', () => { }); test.each([ - ['', 'token', 'OneSignal: enter: activityId is required'], - [123, 'token', 'OneSignal: enter: activityId is required'], - ['activity-id', null, 'OneSignal: enter: token is required'], + ['', 'token', '[OneSignal] enter: activityId is required'], + [123, 'token', '[OneSignal] enter: activityId is required'], + ['activity-id', null, '[OneSignal] enter: token is required'], ])('should not enter with activityId %s and token %s', (activityId, token, message) => { OneSignal.LiveActivities.enter(activityId as string, token as string); expect(mockRNOneSignal.enterLiveActivity).not.toHaveBeenCalled(); @@ -365,7 +367,7 @@ describe('OneSignal', () => { handler as unknown as (result: object) => void, ); expect(mockRNOneSignal.enterLiveActivity).not.toHaveBeenCalled(); - expect(errorSpy).toHaveBeenCalledWith('OneSignal: enter: handler must be a function'); + expect(errorSpy).toHaveBeenCalledWith('[OneSignal] enter: handler must be a function'); }); }); @@ -400,7 +402,7 @@ describe('OneSignal', () => { test.each([null, '', 1])('should not exit with activityId %s', (activityId) => { OneSignal.LiveActivities.exit(activityId as string); expect(mockRNOneSignal.exitLiveActivity).not.toHaveBeenCalled(); - expect(errorSpy).toHaveBeenCalledWith('OneSignal: exit: activityId is required'); + expect(errorSpy).toHaveBeenCalledWith('[OneSignal] exit: activityId is required'); }); test.each([null, 'cb'])('should not exit with handler %s', (handler) => { @@ -409,7 +411,7 @@ describe('OneSignal', () => { handler as unknown as (result: object) => void, ); expect(mockRNOneSignal.exitLiveActivity).not.toHaveBeenCalled(); - expect(errorSpy).toHaveBeenCalledWith('OneSignal: exit: handler must be a function'); + expect(errorSpy).toHaveBeenCalledWith('[OneSignal] exit: handler must be a function'); }); }); @@ -433,8 +435,8 @@ describe('OneSignal', () => { }); test.each([ - [undefined, 'token', 'OneSignal: setPushToStartToken: activityType is required'], - ['activity-type', 7, 'OneSignal: setPushToStartToken: token is required'], + [undefined, 'token', '[OneSignal] setPushToStartToken: activityType is required'], + ['activity-type', 7, '[OneSignal] setPushToStartToken: token is required'], ])('should not set token with %s and %s', (activityType, token, message) => { OneSignal.LiveActivities.setPushToStartToken(activityType as string, token as string); expect(mockRNOneSignal.setPushToStartToken).not.toHaveBeenCalled(); @@ -465,7 +467,7 @@ describe('OneSignal', () => { OneSignal.LiveActivities.removePushToStartToken(activityType as string); expect(mockRNOneSignal.removePushToStartToken).not.toHaveBeenCalled(); expect(errorSpy).toHaveBeenCalledWith( - 'OneSignal: removePushToStartToken: activityType is required', + '[OneSignal] removePushToStartToken: activityType is required', ); }); }); @@ -505,17 +507,17 @@ describe('OneSignal', () => { }); test.each([ - ['a string', 'abc', 'OneSignal: setupDefault: options must be an object'], - ['an array', [], 'OneSignal: setupDefault: options must be an object'], + ['a string', 'abc', '[OneSignal] setupDefault: options must be an object'], + ['an array', [], '[OneSignal] setupDefault: options must be an object'], [ 'a null flag', { enablePushToStart: null }, - 'OneSignal: setupDefault: enablePushToStart must be a boolean', + '[OneSignal] setupDefault: enablePushToStart must be a boolean', ], [ 'an object flag', { enablePushToUpdate: {} }, - 'OneSignal: setupDefault: enablePushToUpdate must be a boolean', + '[OneSignal] setupDefault: enablePushToUpdate must be a boolean', ], ])('should not setup with %s', (_description, options, message) => { OneSignal.LiveActivities.setupDefault(options as unknown as LiveActivitySetupOptions); @@ -550,10 +552,10 @@ describe('OneSignal', () => { }); test.each([ - [null, {}, {}, 'OneSignal: startDefault: activityId is required'], - ['activity-id', null, {}, 'OneSignal: startDefault: attributes must be an object'], - ['activity-id', {}, 'content', 'OneSignal: startDefault: content must be an object'], - ['activity-id', {}, [], 'OneSignal: startDefault: content must be an object'], + [null, {}, {}, '[OneSignal] startDefault: activityId is required'], + ['activity-id', null, {}, '[OneSignal] startDefault: attributes must be an object'], + ['activity-id', {}, 'content', '[OneSignal] startDefault: content must be an object'], + ['activity-id', {}, [], '[OneSignal] startDefault: content must be an object'], ])('should not start with %s, %s, %s', (activityId, attributes, content, message) => { OneSignal.LiveActivities.startDefault( activityId as string, @@ -616,7 +618,7 @@ describe('OneSignal', () => { const result = OneSignal.User.pushSubscription.getPushSubscriptionId(); expect(result).toBe(''); expect(console.warn).toHaveBeenCalledWith( - 'OneSignal: This method has been deprecated. Use getIdAsync instead for getting push subscription id.', + '[OneSignal] This method has been deprecated. Use getIdAsync instead for getting push subscription id.', ); // with a push id @@ -657,7 +659,7 @@ describe('OneSignal', () => { const result = OneSignal.User.pushSubscription.getPushSubscriptionToken(); expect(result).toBe(''); expect(console.warn).toHaveBeenCalledWith( - 'OneSignal: This method has been deprecated. Use getTokenAsync instead for getting push subscription token.', + '[OneSignal] This method has been deprecated. Use getTokenAsync instead for getting push subscription token.', ); // with a push token @@ -698,7 +700,7 @@ describe('OneSignal', () => { const result = OneSignal.User.pushSubscription.getOptedIn(); expect(result).toBe(false); expect(console.warn).toHaveBeenCalledWith( - 'OneSignal: This method has been deprecated. Use getOptedInAsync instead for getting push subscription opted in status.', + '[OneSignal] This method has been deprecated. Use getOptedInAsync instead for getting push subscription opted in status.', ); // with a opted in status @@ -921,14 +923,14 @@ describe('OneSignal', () => { test('should not remove aliases with an empty label', () => { OneSignal.User.removeAliases(['label', '']); expect(mockRNOneSignal.removeAliases).not.toHaveBeenCalled(); - expect(errorSpy).toHaveBeenCalledWith('OneSignal: removeAliases: label is required'); + expect(errorSpy).toHaveBeenCalledWith('[OneSignal] removeAliases: label is required'); }); test('should not remove aliases if labels is not an array', () => { OneSignal.User.removeAliases(null as unknown as string[]); expect(mockRNOneSignal.removeAliases).not.toHaveBeenCalled(); expect(errorSpy).toHaveBeenCalledWith( - 'OneSignal: removeAliases: labels must be an array of strings', + '[OneSignal] removeAliases: labels must be an array of strings', ); }); }); @@ -948,13 +950,13 @@ describe('OneSignal', () => { test('should not add email if email is null', () => { OneSignal.User.addEmail(null as unknown as string); expect(mockRNOneSignal.addEmail).not.toHaveBeenCalled(); - expect(errorSpy).toHaveBeenCalledWith('OneSignal: addEmail: email is required'); + expect(errorSpy).toHaveBeenCalledWith('[OneSignal] addEmail: email is required'); }); test('should not add email if email is empty', () => { OneSignal.User.addEmail(''); expect(mockRNOneSignal.addEmail).not.toHaveBeenCalled(); - expect(errorSpy).toHaveBeenCalledWith('OneSignal: addEmail: email is required'); + expect(errorSpy).toHaveBeenCalledWith('[OneSignal] addEmail: email is required'); }); }); @@ -1094,14 +1096,14 @@ describe('OneSignal', () => { test('should not remove tags with an empty key', () => { OneSignal.User.removeTags(['']); expect(mockRNOneSignal.removeTags).not.toHaveBeenCalled(); - expect(errorSpy).toHaveBeenCalledWith('OneSignal: removeTags: key is required'); + expect(errorSpy).toHaveBeenCalledWith('[OneSignal] removeTags: key is required'); }); test('should not remove tags if keys is not an array', () => { OneSignal.User.removeTags('key' as unknown as string[]); expect(mockRNOneSignal.removeTags).not.toHaveBeenCalled(); expect(errorSpy).toHaveBeenCalledWith( - 'OneSignal: removeTags: keys must be an array of strings', + '[OneSignal] removeTags: keys must be an array of strings', ); }); }); @@ -1186,7 +1188,7 @@ describe('OneSignal', () => { test.each(['', null, undefined])('should not track event with name %s', (name) => { OneSignal.User.trackEvent(name as unknown as string); expect(mockRNOneSignal.trackEvent).not.toHaveBeenCalled(); - expect(errorSpy).toHaveBeenCalledWith('OneSignal: trackEvent: name is required'); + expect(errorSpy).toHaveBeenCalledWith('[OneSignal] trackEvent: name is required'); }); test('should not track event if properties are not serializable', () => { @@ -1194,7 +1196,7 @@ describe('OneSignal', () => { circular.self = circular; OneSignal.User.trackEvent('event', circular); expect(errorSpy).toHaveBeenCalledWith( - 'OneSignal: trackEvent: properties must be a JSON-serializable object', + '[OneSignal] trackEvent: properties must be a JSON-serializable object', ); expect(mockRNOneSignal.trackEvent).not.toHaveBeenCalled(); }); @@ -1202,7 +1204,7 @@ describe('OneSignal', () => { test('should not track event if properties is not an object', () => { OneSignal.User.trackEvent('event', 'invalid' as unknown as Record); expect(errorSpy).toHaveBeenCalledWith( - 'OneSignal: trackEvent: properties must be a JSON-serializable object', + '[OneSignal] trackEvent: properties must be a JSON-serializable object', ); expect(mockRNOneSignal.trackEvent).not.toHaveBeenCalled(); }); @@ -1333,7 +1335,7 @@ describe('OneSignal', () => { ).rejects.toThrow('fallbackToSettings must be a boolean'); expect(mockRNOneSignal.requestNotificationPermission).not.toHaveBeenCalled(); expect(errorSpy).toHaveBeenCalledWith( - 'OneSignal: requestPermission: fallbackToSettings must be a boolean', + '[OneSignal] requestPermission: fallbackToSettings must be a boolean', ); }); }); @@ -1381,7 +1383,7 @@ describe('OneSignal', () => { OneSignal.Notifications.registerForProvisionalAuthorization(handler); expect(console.warn).toHaveBeenCalledWith( - 'registerForProvisionalAuthorization: this function is not supported on Android', + '[OneSignal] registerForProvisionalAuthorization: this function is not supported on Android', ); expect(mockRNOneSignal.registerForProvisionalAuthorization).not.toHaveBeenCalled(); }); @@ -1502,7 +1504,7 @@ describe('OneSignal', () => { OneSignal.Notifications.removeNotification(id as unknown as number); expect(mockRNOneSignal.removeNotification).not.toHaveBeenCalled(); expect(errorSpy).toHaveBeenCalledWith( - 'OneSignal: removeNotification: id must be an integer', + '[OneSignal] removeNotification: id must be an integer', ); }); @@ -1544,7 +1546,7 @@ describe('OneSignal', () => { expect(mockRNOneSignal.removeGroupedNotifications).not.toHaveBeenCalled(); expect(errorSpy).toHaveBeenCalledWith( - 'OneSignal: removeGroupedNotifications: id is required', + '[OneSignal] removeGroupedNotifications: id is required', ); }); @@ -1553,7 +1555,7 @@ describe('OneSignal', () => { OneSignal.Notifications.removeGroupedNotifications(GROUP_ID); expect(console.warn).toHaveBeenCalledWith( - 'removeGroupedNotifications: this function is not supported on iOS', + '[OneSignal] removeGroupedNotifications: this function is not supported on iOS', ); expect(mockRNOneSignal.removeGroupedNotifications).not.toHaveBeenCalled(); }); @@ -1667,7 +1669,7 @@ describe('OneSignal', () => { 'should not add trigger for value %s', (value) => { OneSignal.InAppMessages.addTrigger('key', value as unknown as string); - expect(errorSpy).toHaveBeenCalledWith('OneSignal: addTrigger: value must be a string'); + expect(errorSpy).toHaveBeenCalledWith('[OneSignal] addTrigger: value must be a string'); expect(mockRNOneSignal.addTrigger).not.toHaveBeenCalled(); }, ); @@ -1737,14 +1739,14 @@ describe('OneSignal', () => { test('should not remove triggers with an empty key', () => { OneSignal.InAppMessages.removeTriggers(['']); expect(mockRNOneSignal.removeTriggers).not.toHaveBeenCalled(); - expect(errorSpy).toHaveBeenCalledWith('OneSignal: removeTriggers: key is required'); + expect(errorSpy).toHaveBeenCalledWith('[OneSignal] removeTriggers: key is required'); }); test('should not remove triggers if keys is not an array', () => { OneSignal.InAppMessages.removeTriggers('key' as unknown as string[]); expect(mockRNOneSignal.removeTriggers).not.toHaveBeenCalled(); expect(errorSpy).toHaveBeenCalledWith( - 'OneSignal: removeTriggers: keys must be an array of strings', + '[OneSignal] removeTriggers: keys must be an array of strings', ); }); }); @@ -1777,7 +1779,7 @@ describe('OneSignal', () => { test.each([undefined, null, 'true', 1, {}])('should not set paused with %s', (value) => { OneSignal.InAppMessages.setPaused(value as unknown as boolean); expect(mockRNOneSignal.paused).not.toHaveBeenCalled(); - expect(errorSpy).toHaveBeenCalledWith('OneSignal: setPaused: pause must be a boolean'); + expect(errorSpy).toHaveBeenCalledWith('[OneSignal] setPaused: pause must be a boolean'); }); }); @@ -1827,7 +1829,7 @@ describe('OneSignal', () => { test.each([undefined, null, 'false', 0])('should not set shared with %s', (value) => { OneSignal.Location.setShared(value as unknown as boolean); expect(mockRNOneSignal.setLocationShared).not.toHaveBeenCalled(); - expect(errorSpy).toHaveBeenCalledWith('OneSignal: setShared: shared must be a boolean'); + expect(errorSpy).toHaveBeenCalledWith('[OneSignal] setShared: shared must be a boolean'); }); }); @@ -1866,7 +1868,7 @@ describe('OneSignal', () => { test.each(['', null])('should not add outcome with name %s', (name) => { OneSignal.Session.addOutcome(name as unknown as string); expect(mockRNOneSignal.addOutcome).not.toHaveBeenCalled(); - expect(errorSpy).toHaveBeenCalledWith('OneSignal: addOutcome: name is required'); + expect(errorSpy).toHaveBeenCalledWith('[OneSignal] addOutcome: name is required'); }); }); @@ -1885,7 +1887,7 @@ describe('OneSignal', () => { test('should not add unique outcome with an empty name', () => { OneSignal.Session.addUniqueOutcome(''); expect(mockRNOneSignal.addUniqueOutcome).not.toHaveBeenCalled(); - expect(errorSpy).toHaveBeenCalledWith('OneSignal: addUniqueOutcome: name is required'); + expect(errorSpy).toHaveBeenCalledWith('[OneSignal] addUniqueOutcome: name is required'); }); }); @@ -1917,7 +1919,7 @@ describe('OneSignal', () => { OneSignal.Session.addOutcomeWithValue(OUTCOME_NAME, value as unknown as number); expect(mockRNOneSignal.addOutcomeWithValue).not.toHaveBeenCalled(); expect(errorSpy).toHaveBeenCalledWith( - 'OneSignal: addOutcomeWithValue: value must be a finite number', + '[OneSignal] addOutcomeWithValue: value must be a finite number', ); }, ); @@ -1925,7 +1927,9 @@ describe('OneSignal', () => { test('should not add outcome with an empty name', () => { OneSignal.Session.addOutcomeWithValue('', 1); expect(mockRNOneSignal.addOutcomeWithValue).not.toHaveBeenCalled(); - expect(errorSpy).toHaveBeenCalledWith('OneSignal: addOutcomeWithValue: name is required'); + expect(errorSpy).toHaveBeenCalledWith( + '[OneSignal] addOutcomeWithValue: name is required', + ); }); }); }); diff --git a/src/index.ts b/src/index.ts index 7a06f432..c057a2ec 100644 --- a/src/index.ts +++ b/src/index.ts @@ -68,7 +68,7 @@ export enum LogLevel { function isValidLogLevel(level: unknown, api: string): boolean { if (!isInteger(level, `${api}: level`)) return false; if (level in LogLevel) return true; - console.error(`OneSignal: ${api}: level must be a LogLevel value`); + console.error(`[OneSignal] ${api}: level must be a LogLevel value`); return false; } @@ -77,7 +77,7 @@ function isValidSetupOptions(options: unknown): boolean { if (!isObject(options, 'setupDefault: options')) return false; return (['enablePushToStart', 'enablePushToUpdate'] as const).every((flag) => { if (options[flag] === undefined || typeof options[flag] === 'boolean') return true; - console.error(`OneSignal: setupDefault: ${flag} must be a boolean`); + console.error(`[OneSignal] setupDefault: ${flag} must be a boolean`); return false; }); } @@ -142,7 +142,7 @@ export namespace OneSignal { RNOneSignal.initialize(appId); void Promise.all([_addPermissionObserver(), _addPushSubscriptionObserver()]).catch((error) => { - console.warn('OneSignal: failed to read initial state', error); + console.warn('[OneSignal] failed to read initial state', error); }); } @@ -385,7 +385,7 @@ export namespace OneSignal { return ''; } console.warn( - 'OneSignal: This method has been deprecated. Use getIdAsync instead for getting push subscription id.', + '[OneSignal] This method has been deprecated. Use getIdAsync instead for getting push subscription id.', ); return pushSub.id ? pushSub.id : ''; @@ -407,7 +407,7 @@ export namespace OneSignal { return ''; } console.warn( - 'OneSignal: This method has been deprecated. Use getTokenAsync instead for getting push subscription token.', + '[OneSignal] This method has been deprecated. Use getTokenAsync instead for getting push subscription token.', ); return pushSub.token ? pushSub.token : ''; @@ -430,7 +430,7 @@ export namespace OneSignal { return false; } console.warn( - 'OneSignal: This method has been deprecated. Use getOptedInAsync instead for getting push subscription opted in status.', + '[OneSignal] This method has been deprecated. Use getOptedInAsync instead for getting push subscription opted in status.', ); return pushSub.optedIn ?? false; @@ -510,7 +510,7 @@ export namespace OneSignal { export function setLanguage(language: string) { if (!isNativeModuleLoaded(RNOneSignal)) return; if (typeof language !== 'string') { - console.error('OneSignal: setLanguage: language is required'); + console.error('[OneSignal] setLanguage: language is required'); return; } @@ -596,7 +596,7 @@ export namespace OneSignal { if (isMissing(key, 'addTag: key')) return; if (value == null) { - console.error('OneSignal: addTag: value is required'); + console.error('[OneSignal] addTag: value is required'); return; } @@ -654,7 +654,7 @@ export namespace OneSignal { if (isMissing(name, 'trackEvent: name')) return; if (!isObjectSerializable(properties)) { - console.error('OneSignal: trackEvent: properties must be a JSON-serializable object'); + console.error('[OneSignal] trackEvent: properties must be a JSON-serializable object'); return; } @@ -677,7 +677,7 @@ export namespace OneSignal { */ export function hasPermission(): boolean { console.warn( - 'OneSignal: This method has been deprecated. Use getPermissionAsync instead for getting notification permission status.', + '[OneSignal] This method has been deprecated. Use getPermissionAsync instead for getting notification permission status.', ); return notificationPermission; @@ -733,7 +733,7 @@ export namespace OneSignal { RNOneSignal.registerForProvisionalAuthorization(handler); } else { console.warn( - 'registerForProvisionalAuthorization: this function is not supported on Android', + '[OneSignal] registerForProvisionalAuthorization: this function is not supported on Android', ); } } @@ -806,7 +806,7 @@ export namespace OneSignal { if (!isInteger(id, 'removeNotification: id')) return; RNOneSignal.removeNotification(id); } else { - console.warn('removeNotification: this function is not supported on iOS'); + console.warn('[OneSignal] removeNotification: this function is not supported on iOS'); } } @@ -822,7 +822,9 @@ export namespace OneSignal { if (isMissing(id, 'removeGroupedNotifications: id')) return; RNOneSignal.removeGroupedNotifications(id); } else { - console.warn('removeGroupedNotifications: this function is not supported on iOS'); + console.warn( + '[OneSignal] removeGroupedNotifications: this function is not supported on iOS', + ); } } } @@ -882,7 +884,7 @@ export namespace OneSignal { if (isMissing(key, 'addTrigger: key')) return; if (typeof value !== 'string') { - console.error('OneSignal: addTrigger: value must be a string'); + console.error('[OneSignal] addTrigger: value must be a string'); return; } @@ -1002,7 +1004,7 @@ export namespace OneSignal { const numericValue = typeof value === 'string' && value.trim() !== '' ? Number(value) : value; if (typeof numericValue !== 'number' || !Number.isFinite(numericValue)) { - console.error('OneSignal: addOutcomeWithValue: value must be a finite number'); + console.error('[OneSignal] addOutcomeWithValue: value must be a finite number'); return; }