@mparticle/web-sdk 2.50.1 → 2.52.0

package/src/roktManager.ts

@@ -252,15 +252,51 @@ export default class RoktManager {
         }
     }
 
-    public hashAttributes(attributes: IRoktPartnerAttributes): Promise<IRoktPartnerAttributes> {
-        if (!this.isReady()) {
-            return this.deferredCall<IRoktPartnerAttributes>('hashAttributes', attributes);
-        }
-
+    /**
+     * Hashes attributes and returns both original and hashed versions
+     * with Rokt-compatible key names (like emailsha256, mobilesha256)
+     * 
+     * 
+     * @param {IRoktPartnerAttributes} attributes - Attributes to hash
+     * @returns {Promise<IRoktPartnerAttributes>} Object with both original and hashed attributes
+     * 
+     */
+    public async hashAttributes(attributes: IRoktPartnerAttributes): Promise<IRoktPartnerAttributes> {
         try {
-            return this.kit.hashAttributes(attributes);
+            if (!attributes || typeof attributes !== 'object') {
+                return {};
+            }
+            
+            // Get own property keys only
+            const keys = Object.keys(attributes);
+            
+            if (keys.length === 0) {
+                return {};
+            }
+            
+            // Hash all attributes in parallel
+            const hashPromises = keys.map(async (key) => {
+                const attributeValue = attributes[key];
+                const hashedValue = await this.hashSha256(attributeValue);
+                return { key, attributeValue, hashedValue };
+            });
+            
+            const results = await Promise.all(hashPromises);
+            
+            // Build the result object
+            const hashedAttributes: IRoktPartnerAttributes = {};
+            for (const { key, attributeValue, hashedValue } of results) {
+                hashedAttributes[key] = attributeValue;
+                if (hashedValue) {
+                    hashedAttributes[`${key}sha256`] = hashedValue;
+                }
+            }
+            return hashedAttributes;
+            
         } catch (error) {
-            return Promise.reject(error instanceof Error ? error : new Error('Unknown error occurred'));
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Failed to hashAttributes, returning an empty object: ${errorMessage}`);
+            return {};
         }
     }
 
@@ -290,6 +326,29 @@ export default class RoktManager {
         }
     }
 
+    /**
+     * Hashes an attribute using SHA-256
+     * 
+     * @param {string | number | boolean | undefined | null} attribute - The value to hash
+     * @returns {Promise<string | undefined | null>} SHA-256 hashed value or undefined/null
+     * 
+     */
+    public async hashSha256(attribute: string | number | boolean | undefined | null): Promise<string | undefined | null> {
+        if (attribute === null || attribute === undefined) {
+            this.logger.warning(`hashSha256 received null/undefined as input`);
+            return attribute as null | undefined;
+        }
+        
+        try {
+            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 to hashSha256, returning undefined: ${errorMessage}`);
+            return undefined;
+        }
+    }
+
     public getLocalSessionAttributes(): LocalSessionAttributes {
         return this.store.getLocalSessionAttributes();
     }
@@ -400,6 +459,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
      * 

package/src/sessionManager.ts

@@ -33,31 +33,24 @@ export default function SessionManager(
 
     this.initialize = function (): void {
         if (mpInstance._Store.sessionId) {
-            const sessionTimeoutInMilliseconds: number =
-                mpInstance._Store.SDKConfig.sessionTimeout * 60000;
-
-            if (
-                new Date() >
-                new Date(
-                    mpInstance._Store.dateLastEventSent.getTime() +
-                        sessionTimeoutInMilliseconds
-                )
-            ) {
+            const { dateLastEventSent, SDKConfig } = mpInstance._Store;
+            const { sessionTimeout } = SDKConfig;
+                
+            if (hasSessionTimedOut(dateLastEventSent?.getTime(), sessionTimeout)) {
                 self.endSession();
                 self.startNewSession();
             } else {
                 // https://go.mparticle.com/work/SQDSDKS-6045
                 // https://go.mparticle.com/work/SQDSDKS-6323
                 const currentUser = mpInstance.Identity.getCurrentUser();
-                const sdkIdentityRequest =
-                    mpInstance._Store.SDKConfig.identifyRequest;
+                const sdkIdentityRequest = SDKConfig.identifyRequest;
 
                 if (
                     hasIdentityRequestChanged(currentUser, sdkIdentityRequest)
                 ) {
                     mpInstance.Identity.identify(
-                        mpInstance._Store.SDKConfig.identifyRequest,
-                        mpInstance._Store.SDKConfig.identityCallback
+                        sdkIdentityRequest,
+                        SDKConfig.identityCallback
                     );
                     mpInstance._Store.identifyCalled = true;
                     mpInstance._Store.SDKConfig.identityCallback = null;
@@ -134,12 +127,7 @@ export default function SessionManager(
         );
 
         if (override) {
-            mpInstance._Events.logEvent({
-                messageType: Types.MessageType.SessionEnd,
-            });
-
-            mpInstance._Store.nullifySession();
-            mpInstance._timeOnSiteTimer?.resetTimer();
+            performSessionEnd();
             return;
         }
 
@@ -152,13 +140,9 @@ export default function SessionManager(
                 Messages.InformationMessages.AbandonEndSession
             );
             mpInstance._timeOnSiteTimer?.resetTimer();
-
             return;
         }
 
-        let sessionTimeoutInMilliseconds: number;
-        let timeSinceLastEventSent: number;
-
         const cookies: IPersistenceMinified =
             mpInstance._Persistence.getPersistence();
 
@@ -167,7 +151,6 @@ export default function SessionManager(
                 Messages.InformationMessages.NoSessionToEnd
             );
             mpInstance._timeOnSiteTimer?.resetTimer();
-
             return;
         }
 
@@ -177,24 +160,15 @@ export default function SessionManager(
         }
 
         if (cookies?.gs?.les) {
-            sessionTimeoutInMilliseconds =
-                mpInstance._Store.SDKConfig.sessionTimeout * 60000;
-            const newDate: number = new Date().getTime();
-            timeSinceLastEventSent = newDate - cookies.gs.les;
-
-            if (timeSinceLastEventSent < sessionTimeoutInMilliseconds) {
-                self.setSessionTimer();
+            const sessionTimeout = mpInstance._Store.SDKConfig.sessionTimeout;
+            
+            if (hasSessionTimedOut(cookies.gs.les, sessionTimeout)) {
+                performSessionEnd();
             } else {
-                mpInstance._Events.logEvent({
-                    messageType: Types.MessageType.SessionEnd,
-                });
-
-                mpInstance._Store.sessionStartDate = null;
-                mpInstance._Store.nullifySession();
+                self.setSessionTimer();
+                mpInstance._timeOnSiteTimer?.resetTimer();
             }
         }
-
-        mpInstance._timeOnSiteTimer?.resetTimer();
     };
 
     this.setSessionTimer = function (): void {
@@ -234,4 +208,35 @@ export default function SessionManager(
             }
         }
     };
+
+    /**
+     * Checks if the session has expired based on the last event timestamp
+     * @param lastEventTimestamp - Unix timestamp in milliseconds of the last event
+     * @param sessionTimeout - Session timeout in minutes
+     * @returns true if the session has expired, false otherwise
+     */
+    function hasSessionTimedOut(lastEventTimestamp: number, sessionTimeout: number): boolean {
+        if (!lastEventTimestamp || !sessionTimeout || sessionTimeout <= 0) {
+            return false;
+        }
+
+        const sessionTimeoutInMilliseconds: number = sessionTimeout * 60000;
+        const timeSinceLastEvent: number = Date.now() - lastEventTimestamp;
+
+        return timeSinceLastEvent >= sessionTimeoutInMilliseconds;
+    }
+
+    /**
+     * Performs session end operations:
+     * - Logs a SessionEnd event
+     * - Nullifies the session ID and related data
+     * - Resets the time-on-site timer
+     */
+    function performSessionEnd(): void {
+        mpInstance._Events.logEvent({
+            messageType: Types.MessageType.SessionEnd,
+        });
+        mpInstance._Store.nullifySession();
+        mpInstance._timeOnSiteTimer?.resetTimer();
+    }
 }

package/src/store.ts

@@ -683,6 +683,7 @@ export default function Store(
     this.nullifySession = (): void => {
         this.sessionId = null;
         this.dateLastEventSent = null;
+        this.sessionStartDate = null;
         this.sessionAttributes = {};
         this.localSessionAttributes = {};
         mpInstance._Persistence.update();

package/src/stub/mparticle.stub.js

@@ -166,6 +166,7 @@ function createAliasRequest() {
         destinationMpid: 'b',
         startTime: new Date().getTime(),
         endTime: new Date().getTime(),
+        scope: 'device',
     };
 }
 

package/src/utils.ts

@@ -206,18 +206,28 @@ const replaceAmpWithAmpersand = (value: string): string => value.replace(/&/
 const createCookieSyncUrl = (
     mpid: MPID,
     pixelUrl: string,
-    redirectUrl?: string
+    redirectUrl?: string,
+    domain?: string
 ): string => {
     const modifiedPixelUrl = replaceAmpWithAmpersand(pixelUrl);
     const modifiedDirectUrl = redirectUrl
         ? replaceAmpWithAmpersand(redirectUrl)
         : null;
 
-    const url = replaceMPID(modifiedPixelUrl, mpid);
+    let url = replaceMPID(modifiedPixelUrl, mpid);
+    
     const redirect = modifiedDirectUrl
         ? replaceMPID(modifiedDirectUrl, mpid)
         : '';
-    return url + encodeURIComponent(redirect);
+    
+    let fullUrl = url + encodeURIComponent(redirect);
+    
+    if (domain) {
+        const separator = fullUrl.includes('?') ? '&' : '?';
+        fullUrl += `${separator}domain=${domain}`;
+    }
+    
+    return fullUrl;
 };
 
 // FIXME: REFACTOR for V3