fix: Mirror Apple SDK sha256 alias semantics (split slots, null pass-through)

Aligns the email_sha256/mobile_sha256 aliases with the final Apple SDK
behavior after mparticle-apple-sdk #756 + #761:

- Map mobile_sha256 to other2 (was: other) so the two aliases use distinct
  canonical slots and no longer clobber each other.
- Pass null through to the canonical slot instead of dropping it, so a
  Modify call with `<alias>: null` actually clears the slot — matching the
  null=clear contract honored by removeFalsyIdentityValues and validators.
- Hoist the alias-key array to a module-level frozen constant.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: rmi22186

src/identity-utils.ts

@@ -289,26 +289,32 @@ const getExpireTimestamp = (maxAge: number = ONE_DAY_IN_SECONDS): number =>
 const parseIdentityResponse = (responseText: string): IdentityResultBody =>
     responseText ? JSON.parse(responseText) : ({} as IdentityResultBody);
 
-// Maps convenience identity key names to their canonical server-side names.
-// Mirrors the emailSha256/mobileSha256 helpers added in the Apple SDK (PR #756).
-const SHA256_IDENTITY_ALIASES: Readonly<Record<string, string>> = {
+// Maps convenience identity key names to their canonical server-side slots.
+// Mirrors the Apple SDK helpers (PRs #756 and #761): email_sha256 → other,
+// mobile_sha256 → other2. Null on an alias clears the canonical slot, matching
+// the existing null=clear contract honored by removeFalsyIdentityValues.
+const SHA256_IDENTITY_ALIASES = Object.freeze({
     email_sha256: 'other',
-    mobile_sha256: 'other',
-};
+    mobile_sha256: 'other2',
+} as const);
+
+const SHA256_ALIAS_KEYS = Object.freeze(
+    Object.keys(SHA256_IDENTITY_ALIASES) as Array<
+        keyof typeof SHA256_IDENTITY_ALIASES
+    >
+);
 
 export const normalizeUserIdentityKeys = (
     userIdentities: UserIdentities
 ): UserIdentities => {
     const normalized: Record<string, string | null | undefined> = {
         ...(userIdentities as Record<string, string | null | undefined>),
     };
-    for (const alias of Object.keys(SHA256_IDENTITY_ALIASES)) {
+    for (const alias of SHA256_ALIAS_KEYS) {
         if (alias in normalized) {
             const value = normalized[alias];
             delete normalized[alias];
-            if (value !== null) {
-                normalized[SHA256_IDENTITY_ALIASES[alias]] = value;
-            }
+            normalized[SHA256_IDENTITY_ALIASES[alias]] = value;
         }
     }
     return normalized as UserIdentities;

src/types.ts

@@ -208,7 +208,7 @@ export const IdentityType = {
             case 'email_sha256':
                 return IdentityType.Other;
             case 'mobile_sha256':
-                return IdentityType.Other;
+                return IdentityType.Other2;
             default:
                 return false;
         }

test/jest/identity-utils.spec.ts

@@ -6,17 +6,22 @@ describe('normalizeUserIdentityKeys', () => {
         expect(result).toEqual({ other: 'abc123hash' });
     });
 
-    it('maps mobile_sha256 to other', () => {
-        const result = normalizeUserIdentityKeys({ mobile_sha256: 'mobilehash456' });
-        expect(result).toEqual({ other: 'mobilehash456' });
+    it('maps mobile_sha256 to other2', () => {
+        const result = normalizeUserIdentityKeys({
+            mobile_sha256: 'mobilehash456',
+        });
+        expect(result).toEqual({ other2: 'mobilehash456' });
     });
 
-    it('last sha256 alias wins when both are set (same slot)', () => {
+    it('maps both aliases to distinct canonical slots', () => {
         const result = normalizeUserIdentityKeys({
             email_sha256: 'emailhash',
             mobile_sha256: 'mobilehash',
         });
-        expect(result).toEqual({ other: 'mobilehash' });
+        expect(result).toEqual({
+            other: 'emailhash',
+            other2: 'mobilehash',
+        });
     });
 
     it('preserves other canonical identity keys alongside sha256 aliases', () => {
@@ -35,12 +40,28 @@ describe('normalizeUserIdentityKeys', () => {
     it('does not modify identities without sha256 aliases', () => {
         const input = { email: 'user@example.com', customerid: 'cust123' };
         const result = normalizeUserIdentityKeys(input);
-        expect(result).toEqual({ email: 'user@example.com', customerid: 'cust123' });
+        expect(result).toEqual({
+            email: 'user@example.com',
+            customerid: 'cust123',
+        });
     });
 
-    it('drops null values for sha256 aliases', () => {
+    it('passes null on email_sha256 through to other (clears canonical slot)', () => {
         const result = normalizeUserIdentityKeys({ email_sha256: null });
-        expect(result).toEqual({});
+        expect(result).toEqual({ other: null });
+    });
+
+    it('passes null on mobile_sha256 through to other2 (clears canonical slot)', () => {
+        const result = normalizeUserIdentityKeys({ mobile_sha256: null });
+        expect(result).toEqual({ other2: null });
+    });
+
+    it('alias overwrites a same-slot canonical value (silent last-write-wins)', () => {
+        const result = normalizeUserIdentityKeys({
+            other: 'preexisting',
+            email_sha256: 'aliasvalue',
+        });
+        expect(result).toEqual({ other: 'aliasvalue' });
     });
 
     it('does not mutate the original object', () => {

test/jest/types.spec.ts

@@ -440,7 +440,7 @@ describe('IdentityType', () => {
             expect(getIdentityType('phone_number_2')).toBe(PhoneNumber2);
             expect(getIdentityType('phone_number_3')).toBe(PhoneNumber3);
             expect(getIdentityType('email_sha256')).toBe(Other);
-            expect(getIdentityType('mobile_sha256')).toBe(Other);
+            expect(getIdentityType('mobile_sha256')).toBe(Other2);
         });
 
         it('returns false if the identity name is not found', () => {