feat: Add hashSha256 method for SHA-256 hashing and related test

Author: jaissica12

src/roktManager.ts

@@ -264,6 +264,28 @@ export default class RoktManager {
         }
     }
 
+    /**
+     * Hashes a single value using SHA-256
+     * Accepts the same types as IRoktPartnerAttributes values
+     * 
+     * @param {string | number | boolean | undefined | null} attribute - The value to hash
+     * @returns {Promise<string>} The SHA-256 hex digest of the normalized value
+     * 
+     */
+    public async hashSha256(attribute: string | number | boolean | undefined | null): Promise<string> {
+        try {
+            if (attribute === undefined || attribute === null) {
+                return Promise.reject(new Error('Value cannot be null or undefined'));
+            }
+            const normalizedValue = String(attribute).trim().toLocaleLowerCase();
+            return await this.sha256Hex(normalizedValue);
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger.error('Failed hashSha256: ' + errorMessage);
+            return Promise.reject(new Error(String(error)));
+        }
+    }
+
     public setExtensionData<T>(extensionData: IRoktPartnerExtensionData<T>): void {
         if (!this.isReady()) {
             this.deferredCall<void>('setExtensionData', extensionData);
@@ -400,6 +422,37 @@ export default class RoktManager {
         this.messageQueue.delete(messageId);
     }
 
+    /**
+     * Hashes a string input using SHA-256 and returns the hex digest
+     * Uses the Web Crypto API for secure hashing
+     * 
+     * @param {string} input - The string to hash
+     * @returns {Promise<string>} The SHA-256 hash as a hexadecimal string
+     */
+    private async sha256Hex(input: string): Promise<string> {
+        const encoder = new TextEncoder();
+        const encodedInput = encoder.encode(input);
+        const digest = await crypto.subtle.digest('SHA-256', encodedInput);
+        return this.arrayBufferToHex(digest);
+    }
+
+    /**
+     * Converts an ArrayBuffer to a hexadecimal string representation
+     * Each byte is converted to a 2-character hex string with leading zeros
+     * 
+     * @param {ArrayBuffer} buffer - The buffer to convert
+     * @returns {string} The hexadecimal string representation
+     */
+    private arrayBufferToHex(buffer: ArrayBuffer): string {
+        const bytes = new Uint8Array(buffer);
+        let hexString = '';
+        for (let i = 0; i < bytes.length; i++) {
+            const hexByte = bytes[i].toString(16).padStart(2, '0');
+            hexString += hexByte;
+        }
+        return hexString;
+    }
+
     /**
      * Checks if an identity value has changed by comparing current and new values
      * 

test/jest/roktManager.spec.ts

@@ -210,6 +210,112 @@ describe('RoktManager', () => {
         });
     });
 
+    describe('#hashSha256', () => {
+        interface Hasher {
+            sha256Hex(input: string): Promise<string>
+        }
+
+        const nodeCrypto = require('crypto');
+        let shaSpy: jest.SpyInstance;
+
+        beforeEach(() => {
+            shaSpy = jest.spyOn(roktManager as unknown as Hasher, 'sha256Hex');
+            shaSpy.mockImplementation((s: any) =>
+                Promise.resolve(nodeCrypto.createHash('sha256').update(String(s)).digest('hex')),
+            );
+        });
+
+        afterEach(() => {
+            shaSpy.mockRestore();
+        });
+
+        it('should hash a single string value using SHA-256', async () => {
+            const result = await roktManager.hashSha256('[email protected]');
+            const expected = nodeCrypto.createHash('sha256').update('[email protected]').digest('hex');
+
+            expect(result).toBe(expected);
+            expect(shaSpy).toHaveBeenCalledWith('[email protected]');
+            expect(shaSpy).toHaveBeenCalledTimes(1);
+        });
+
+        it('should hash values without kit being attached', async () => {
+            // Verify kit is not attached
+            expect(roktManager['kit']).toBeNull();
+
+            const result = await roktManager.hashSha256('[email protected]');
+            const expected = nodeCrypto.createHash('sha256').update('[email protected]').digest('hex');
+
+            expect(result).toBe(expected);
+        });
+
+        it('should handle empty string', async () => {
+            const emptyStringHash = await roktManager.hashSha256('');
+            
+            // Empty string after trim becomes '', hash of empty string
+            expect(emptyStringHash).toBe('e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855');
+        });
+
+        it('should reject when value is null', async () => {
+            await expect(roktManager.hashSha256(null)).rejects.toThrow('Value cannot be null or undefined');
+        });
+
+        it('should reject when value is undefined', async () => {
+            await expect(roktManager.hashSha256(undefined)).rejects.toThrow('Value cannot be null or undefined');
+        });
+
+        it('should log error when hashing fails', async () => {
+            shaSpy.mockRejectedValue(new Error('Hash failed'));
+
+            await expect(roktManager.hashSha256('[email protected]')).rejects.toThrow();
+            expect(mockMPInstance.Logger.error).toHaveBeenCalledWith(expect.stringContaining('Failed hashSha256'));
+        });
+
+        it('should hash firstName to known SHA-256 value', async () => {
+            const hashedFirstName = await roktManager.hashSha256('jane');
+            
+            // Expected SHA-256 hash of 'jane'
+            expect(hashedFirstName).toBe('81f8f6dde88365f3928796ec7aa53f72820b06db8664f5fe76a7eb13e24546a2');
+        });
+
+        it('should produce same hash for different case and whitespace variations', async () => {
+            const lowercaseEmail = await roktManager.hashSha256('[email protected]');
+            const mixedCaseEmail = await roktManager.hashSha256('[email protected]');
+            const emailWithWhitespace = await roktManager.hashSha256(' [email protected]   ');
+
+            // All should normalize to same hash
+            expect(lowercaseEmail).toBe(mixedCaseEmail);
+            expect(mixedCaseEmail).toBe(emailWithWhitespace);
+            expect(lowercaseEmail).toBe('831f6494ad6be4fcb3a724c3d5fef22d3ceffa3c62ef3a7984e45a0ea177f982');
+        });
+
+        it('should handle numeric values and match known SHA-256', async () => {
+            const hashedNumber = await roktManager.hashSha256(42);
+            const hashedString = await roktManager.hashSha256('42');
+
+            // Numeric value should be converted to string and produce same hash
+            expect(hashedNumber).toBe(hashedString);
+            // Expected SHA-256 hash of '42'
+            expect(hashedNumber).toBe('73475cb40a568e8da8a045ced110137e159f890ac4da883b6b17dc651b3a8049');
+        });
+
+        it('should handle boolean values and match known SHA-256', async () => {
+            const hashedBoolean = await roktManager.hashSha256(true);
+            const hashedString = await roktManager.hashSha256('true');
+
+            // Boolean value should be converted to string and produce same hash
+            expect(hashedBoolean).toBe(hashedString);
+            // Expected SHA-256 hash of 'true'
+            expect(hashedBoolean).toBe('b5bea41b6c623f7c09f1bf24dcae58ebab3c0cdd90ad966bc43a45b44867e12b');
+        });
+
+        it('should hash phone number to known SHA-256 value', async () => {
+            const hashedPhone = await roktManager.hashSha256('1234567890');
+            
+            // Expected SHA-256 hash of '1234567890'
+            expect(hashedPhone).toBe('c775e7b757ede630cd0aa1113bd102661ab38829ca52a6422ab782862f268646');
+        });
+    });
+
     describe('#init', () => {
         it('should initialize the manager with defaults when no config is provided', () => {
             roktManager.init(