@mparticle/web-sdk 2.60.1 → 2.62.0

package/src/internal-types.ts

@@ -0,0 +1,66 @@
+/**
+ * Internal types for @mparticle/web-sdk
+ *
+ * These types are shared between mParticle and Rokt SDKs but are NOT part of
+ * the public API. They may change without notice between minor versions.
+ *
+ * Usage:
+ *   import type { IKitFilterSettings, IRoktKit, SDKProduct } from '@mparticle/web-sdk/internal';
+ *
+ * This entry point re-exports all public types so that internal consumers
+ * only need a single import path.
+ *
+ * Customers should NOT import from this path.
+ */
+
+// Re-export all public types so internal consumers have a single import path
+export * from './public-types';
+
+export type {
+    KitInterface,
+} from './forwarders.interfaces';
+
+// Rokt integration types
+export type {
+    RoktAttributeValue,
+    RoktAttributeValueType,
+    RoktAttributeValueArray,
+    RoktAttributes,
+    IRoktPartnerExtensionData,
+    IRoktSelectPlacementsOptions,
+    IRoktSelection,
+    IRoktLauncher,
+    IRoktMessage,
+    RoktKitFilterSettings,
+    IRoktKitSettings,
+    IRoktKit,
+    IRoktOptions,
+    IRoktLauncherOptions,
+} from './roktManager';
+
+// Reporting / Error types (type-only to avoid runtime mismatch with entry point)
+export type {
+    ErrorCodes,
+    WSDKErrorSeverity,
+} from './reporting/types';
+
+export type {
+    ISDKError,
+    ISDKLogEntry,
+    IErrorReportingService,
+    ILoggingService,
+} from './reporting/types';
+
+// SDK internals shared between kits
+export type {
+    SDKEvent,
+    SDKProductAction,
+    SDKProductActionType,
+    SDKPromotionAction,
+    SDKShoppingCart,
+    SDKGeoLocation,
+    SDKDataPlan,
+    SDKLoggerApi,
+    SDKConfigApi,
+    IMParticleInstanceManager,
+} from './sdkRuntimeModels';

package/src/logger.ts

@@ -1,6 +1,4 @@
 import { LogLevelType, SDKInitConfig, SDKLoggerApi } from './sdkRuntimeModels';
-import { ReportingLogger } from './logging/reportingLogger';
-import { ErrorCodes } from './logging/types';
 
 export type ILoggerConfig = Pick<SDKInitConfig, 'logLevel' | 'logger'>;
 export type IConsoleLogger = Partial<Pick<SDKLoggerApi, 'error' | 'warning' | 'verbose'>>;
@@ -8,18 +6,14 @@ export type IConsoleLogger = Partial<Pick<SDKLoggerApi, 'error' | 'warning' | 'v
 export class Logger {
     private logLevel: LogLevelType;
     private logger: IConsoleLogger;
-    private reportingLogger: ReportingLogger;
 
-    constructor(config: ILoggerConfig,
-        reportingLogger?: ReportingLogger,
-    ) {
+    constructor(config: ILoggerConfig) {
         this.logLevel = config.logLevel ?? LogLevelType.Warning;
         this.logger = config.logger ?? new ConsoleLogger();
-        this.reportingLogger = reportingLogger;
     }
 
     public verbose(msg: string): void {
-        if(this.logLevel === LogLevelType.None) 
+        if(this.logLevel === LogLevelType.None)
             return;
 
         if (this.logger.verbose && this.logLevel === LogLevelType.Verbose) {
@@ -37,15 +31,12 @@ export class Logger {
         }
     }
 
-    public error(msg: string, codeForReporting?: ErrorCodes): void {
+    public error(msg: string): void {
         if(this.logLevel === LogLevelType.None)
             return;
 
         if (this.logger.error) {
             this.logger.error(msg);
-            if (codeForReporting) {
-                this.reportingLogger?.error(msg, codeForReporting);
-            }
         }
     }
 

package/src/mp-instance.ts

@@ -52,7 +52,9 @@ import ForegroundTimer from './foregroundTimeTracker';
 import RoktManager, { IRoktOptions } from './roktManager';
 import filteredMparticleUser from './filteredMparticleUser';
 import CookieConsentManager, { ICookieConsentManager } from './cookieConsentManager';
-import { ReportingLogger } from './logging/reportingLogger';
+import { ErrorReportingDispatcher } from './reporting/errorReportingDispatcher';
+import { LoggingDispatcher } from './reporting/loggingDispatcher';
+import { IErrorReportingService, ILoggingService } from './reporting/types';
 
 export interface IErrorLogMessage {
     message?: string;
@@ -85,7 +87,8 @@ export interface IMParticleWebSDKInstance extends MParticleWebSDK {
     _NativeSdkHelpers: INativeSdkHelpers;
     _Persistence: IPersistence;
     _CookieConsentManager: ICookieConsentManager;
-    _ReportingLogger: ReportingLogger;
+    _ErrorReportingDispatcher: ErrorReportingDispatcher;
+    _LoggingDispatcher: LoggingDispatcher;
     _RoktManager: RoktManager;
     _SessionManager: ISessionManager;
     _ServerModel: IServerModel;
@@ -138,6 +141,9 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
         forwarderConstructors: [],
     };
 
+    this._ErrorReportingDispatcher = new ErrorReportingDispatcher();
+    this._LoggingDispatcher = new LoggingDispatcher();
+
     this._RoktManager = new RoktManager();
     
     this._RoktManager.setOnReadyCallback(() => {
@@ -266,14 +272,16 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
         }
     };
 
-    this._resetForTests = function(config, keepPersistence, instance, reportingLogger?: ReportingLogger) {
+    this._resetForTests = function(config, keepPersistence, instance) {
         if (instance._Store) {
             delete instance._Store;
         }
-        instance.Logger = new Logger(config, reportingLogger);
+        instance._ErrorReportingDispatcher = new ErrorReportingDispatcher();
+        instance._LoggingDispatcher = new LoggingDispatcher();
+        instance.Logger = new Logger(config);
+        instance._ErrorReportingDispatcher.logger = instance.Logger;
+        instance._LoggingDispatcher.logger = instance.Logger;
         instance._Store = new Store(config, instance);
-        // Update ReportingLogger with the new Store reference to avoid stale data
-        reportingLogger?.setStore(instance._Store);
         instance._Store.isLocalStorageAvailable = instance._Persistence.determineLocalStorageAvailability(
             window.localStorage
         );
@@ -1406,6 +1414,14 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
         }
     };
 
+    this._registerErrorReportingService = function(service: IErrorReportingService) {
+        self._ErrorReportingDispatcher.register(service);
+    };
+
+    this._registerLoggingService = function(service: ILoggingService) {
+        self._LoggingDispatcher.register(service);
+    };
+
     const launcherInstanceGuidKey = Constants.Rokt.LauncherInstanceGuidKey;
     this.setLauncherInstanceGuid = function() {
         if (!window[launcherInstanceGuidKey] 
@@ -1504,7 +1520,9 @@ function completeSDKInitialization(apiKey, config, mpInstance) {
                 mpInstance._Store,
                 mpInstance.Logger,
                 roktOptions,
-                mpInstance.captureTiming
+                mpInstance.captureTiming,
+                mpInstance._ErrorReportingDispatcher,
+                mpInstance._LoggingDispatcher
             );
         }
 
@@ -1626,16 +1644,11 @@ function createIdentityCache(mpInstance) {
 }
 
 function runPreConfigFetchInitialization(mpInstance, apiKey, config) {
-    mpInstance._ReportingLogger = new ReportingLogger(
-        config,
-        Constants.sdkVersion,
-        undefined,
-        mpInstance.getLauncherInstanceGuid(),
-    );
-    mpInstance.Logger = new Logger(config, mpInstance._ReportingLogger);
+    mpInstance.Logger = new Logger(config);
+    mpInstance._ErrorReportingDispatcher.logger = mpInstance.Logger;
+    mpInstance._LoggingDispatcher.logger = mpInstance.Logger;
     mpInstance._Store = new Store(config, mpInstance, apiKey);
     window.mParticle.Store = mpInstance._Store;
-    mpInstance._ReportingLogger.setStore(mpInstance._Store);
     mpInstance.Logger.verbose(StartingInitialization);
 
     // Initialize CookieConsentManager with privacy flags from launcherOptions

package/src/mparticle-instance-manager.ts

@@ -487,6 +487,12 @@ function mParticleInstanceManager(this: IMParticleInstanceManager) {
     this._setWrapperSDKInfo = function(name, version) {
         self.getInstance()._setWrapperSDKInfo(name, version);
     };
+    this._registerErrorReportingService = function(service) {
+        self.getInstance()._registerErrorReportingService(service);
+    };
+    this._registerLoggingService = function(service) {
+        self.getInstance()._registerLoggingService(service);
+    };
 }
 
 const mParticleManager = new mParticleInstanceManager();

package/src/public-types.ts

@@ -0,0 +1,84 @@
+/**
+ * Public types for @mparticle/web-sdk
+ *
+ * These types are part of the stable public API and are safe for customers
+ * to import. Only add types here that are intended for external consumption.
+ *
+ * Usage:
+ *   import type { SDKInitConfig, EventType } from '@mparticle/web-sdk';
+ *
+ * Note: Types from @types/mparticle__web-sdk (e.g., MPConfiguration, MPID,
+ * ConsentState) are NOT re-exported here to avoid circular references.
+ * Consumers get those automatically via DefinitelyTyped until they are
+ * natively defined in this SDK and the DT package is deprecated.
+ */
+
+// Re-export types from @mparticle/event-models
+// Consumers should not need to install @mparticle/event-models directly
+export type {
+    Batch,
+} from '@mparticle/event-models';
+
+// Enums / Constants (type-only to avoid runtime mismatch with entry point)
+export type {
+    EventType,
+    CommerceEventType,
+    IdentityType,
+    ProductActionType,
+    PromotionActionType,
+    MessageType,
+} from './types';
+
+// Configuration
+export type {
+    SDKInitConfig,
+    DataPlanConfig,
+    BaseEvent,
+    SDKEventCustomFlags,
+    LogLevelType,
+    MParticleWebSDK,
+} from './sdkRuntimeModels';
+
+// User & Identity
+export type {
+    IMParticleUser,
+    IdentityCallback,
+    IdentityResult,
+    IdentityResultBody,
+    IdentityModifyResultBody,
+    ISDKUserIdentity,
+    ISDKUserAttributes,
+} from './identity-user-interfaces';
+
+export type {
+    SDKIdentityApi,
+    IAliasRequest,
+    IAliasCallback,
+    IAliasResult,
+    SDKIdentityTypeEnum,
+} from './identity.interfaces';
+
+// eCommerce
+export type {
+    SDKECommerceAPI,
+    SDKCart,
+} from './ecommerce.interfaces';
+
+export type {
+    SDKProduct,
+    SDKPromotion,
+    SDKImpression,
+    SDKProductImpression,
+} from './sdkRuntimeModels';
+
+// Consent
+export type {
+    SDKConsentApi,
+    SDKConsentState,
+    SDKConsentStateData,
+    SDKGDPRConsentState,
+    SDKCCPAConsentState,
+} from './consent';
+
+// Utilities
+export type { Dictionary, valueof } from './utils';

package/src/reporting/errorReportingDispatcher.ts

@@ -0,0 +1,21 @@
+import { SDKLoggerApi } from '../sdkRuntimeModels';
+import { IErrorReportingService, ISDKError } from './types';
+
+export class ErrorReportingDispatcher implements IErrorReportingService {
+    private readonly services: IErrorReportingService[] = [];
+    public logger?: SDKLoggerApi;
+
+    public register(service: IErrorReportingService): void {
+        this.services.push(service);
+    }
+
+    public report(error: ISDKError): void {
+        this.services.forEach(s => {
+            try {
+                s.report(error);
+            } catch (e) {
+                this.logger?.error('Error in ErrorReportingService: ' + e);
+            }
+        });
+    }
+}

package/src/reporting/loggingDispatcher.ts

@@ -0,0 +1,21 @@
+import { SDKLoggerApi } from '../sdkRuntimeModels';
+import { ILoggingService, ISDKLogEntry } from './types';
+
+export class LoggingDispatcher implements ILoggingService {
+    private readonly services: ILoggingService[] = [];
+    public logger?: SDKLoggerApi;
+
+    public register(service: ILoggingService): void {
+        this.services.push(service);
+    }
+
+    public log(entry: ISDKLogEntry): void {
+        this.services.forEach(s => {
+            try {
+                s.log(entry);
+            } catch (e) {
+                this.logger?.error('Error in LoggingService: ' + e);
+            }
+        });
+    }
+}

package/src/reporting/types.ts

@@ -0,0 +1,45 @@
+import { valueof } from '../utils';
+
+export const ErrorCodes = {
+    UNKNOWN_ERROR: 'UNKNOWN_ERROR',
+    UNHANDLED_EXCEPTION: 'UNHANDLED_EXCEPTION',
+    IDENTITY_REQUEST: 'IDENTITY_REQUEST',
+    IDENTITY_MISMATCH: 'IDENTITY_MISMATCH',
+    ROKT_KIT_ATTACHED: 'ROKT_KIT_ATTACHED',
+} as const;
+
+export type ErrorCodes = valueof<typeof ErrorCodes>;
+
+export const WSDKErrorSeverity = {
+    ERROR: 'ERROR',
+    INFO: 'INFO',
+    WARNING: 'WARNING',
+} as const;
+
+export type WSDKErrorSeverity = (typeof WSDKErrorSeverity)[keyof typeof WSDKErrorSeverity];
+
+/** Structured error object for reporting. */
+export interface ISDKError {
+    message: string;
+    code?: ErrorCodes;
+    severity: WSDKErrorSeverity;
+    stackTrace?: string;
+    additionalInformation?: Record<string, string>;
+}
+
+/** Structured log entry for informational logging. */
+export interface ISDKLogEntry {
+    message: string;
+    code?: ErrorCodes;
+    additionalInformation?: Record<string, string>;
+}
+
+/** Contract for error/warning reporting services. */
+export interface IErrorReportingService {
+    report(error: ISDKError): void;
+}
+
+/** Contract for informational logging services. */
+export interface ILoggingService {
+    log(entry: ISDKLogEntry): void;
+}

package/src/roktManager.ts

@@ -16,6 +16,7 @@ import { SDKLoggerApi } from "./sdkRuntimeModels";
 import { IStore, LocalSessionAttributes } from "./store";
 import { UserIdentities } from "@mparticle/web-sdk";
 import { IdentityType, PerformanceMarkType } from "./types";
+import { ErrorCodes, IErrorReportingService, ILoggingService, WSDKErrorSeverity } from "./reporting/types";
 
 // https://docs.rokt.com/developers/integration-guides/web/library/attributes
 export type RoktAttributeValueArray = Array<string | number | boolean>;
@@ -108,6 +109,8 @@ export default class RoktManager {
     private store: IStore;
     private launcherOptions?: IRoktLauncherOptions;
     private logger: SDKLoggerApi;
+    private errorReporter: IErrorReportingService;
+    private loggingService: ILoggingService;
     private domain?: string;
     private mappedEmailShaIdentityType?: string | null;
     private captureTiming?: (metricsName: string) => void;
@@ -130,17 +133,21 @@ export default class RoktManager {
      * @param {SDKLoggerApi} logger - The mParticle Logger instance
      * @param {IRoktOptions} options - Options for the RoktManager
      * @param {Function} captureTiming - Function to capture performance timing marks
-     * 
+     * @param {IErrorReportingService} errorReporter - Dispatcher for error/warning reporting
+     * @param {ILoggingService} loggingService - Dispatcher for informational logging
+     *
      * @throws Logs error to console if placementAttributesMapping parsing fails
      */
     public init(
-        roktConfig: IKitConfigs, 
-        filteredUser: IMParticleUser, 
+        roktConfig: IKitConfigs,
+        filteredUser: IMParticleUser,
         identityService: SDKIdentityApi,
         store: IStore,
         logger?: SDKLoggerApi,
         options?: IRoktOptions,
-        captureTiming?: (metricsName: string) => void
+        captureTiming?: (metricsName: string) => void,
+        errorReporter?: IErrorReportingService,
+        loggingService?: ILoggingService
     ): void {
         const { userAttributeFilters, settings } = roktConfig || {};
         const { placementAttributesMapping, hashedEmailUserIdentityType } = settings || {};
@@ -149,6 +156,8 @@ export default class RoktManager {
         this.identityService = identityService;
         this.store = store;
         this.logger = logger;
+        this.errorReporter = errorReporter;
+        this.loggingService = loggingService;
         this.captureTiming = captureTiming;
 
         this.captureTiming?.(PerformanceMarkType.JointSdkRoktKitInit);
@@ -199,6 +208,11 @@ export default class RoktManager {
             this.store?.setIntegrationName(kit.integrationName);
         }
 
+        this.loggingService?.log({
+            message: 'RoktManager: Kit attached, Rokt is ready',
+            code: ErrorCodes.ROKT_KIT_ATTACHED,
+        });
+
         this.processMessageQueue();
 
         try {
@@ -269,13 +283,25 @@ export default class RoktManager {
             if (emailChanged) {
                 newIdentities.email = newEmail;
                 if (newEmail) {
-                    this.logger.warning(`Email mismatch detected. Current email differs from email passed to selectPlacements call. Proceeding to call identify with email from selectPlacements call. Please verify your implementation.`);
+                    const msg = 'Email mismatch detected. Current email differs from email passed to selectPlacements call. Proceeding to call identify with email from selectPlacements call. Please verify your implementation.';
+                    this.logger.warning(msg);
+                    this.errorReporter?.report({
+                        message: msg,
+                        code: ErrorCodes.IDENTITY_MISMATCH,
+                        severity: WSDKErrorSeverity.WARNING,
+                    });
                 }
             }
 
             if (hashedEmailChanged) {
                 newIdentities[this.mappedEmailShaIdentityType] = newHashedEmail;
-                this.logger.warning(`emailsha256 mismatch detected. Current mParticle hashedEmail differs from hashedEmail passed to selectPlacements call. Proceeding to call identify with hashedEmail from selectPlacements call. Please verify your implementation.`);
+                const msg = 'emailsha256 mismatch detected. Current mParticle hashedEmail differs from hashedEmail passed to selectPlacements call. Proceeding to call identify with hashedEmail from selectPlacements call. Please verify your implementation.';
+                this.logger.warning(msg);
+                this.errorReporter?.report({
+                    message: msg,
+                    code: ErrorCodes.IDENTITY_MISMATCH,
+                    severity: WSDKErrorSeverity.WARNING,
+                });
             }
             
             if (!isEmpty(newIdentities)) {

package/src/sdkRuntimeModels.ts

@@ -51,7 +51,7 @@ import {
 import Constants from './constants';
 import RoktManager, { IRoktLauncherOptions } from './roktManager';
 import { IConsoleLogger } from './logger';
-import { ErrorCodes } from './logging/types';
+import { ErrorCodes, IErrorReportingService, ILoggingService } from './reporting/types';
 
 // TODO: Resolve this with version in @mparticle/web-sdk
 export type SDKEventCustomFlags = Dictionary<any>;
@@ -260,6 +260,8 @@ export interface MParticleWebSDK {
     ): void;
     getIntegrationAttributes(integrationModuleId: number): IntegrationAttribute;
     captureTiming(metricName: string): void;
+    _registerErrorReportingService(service: IErrorReportingService): void;
+    _registerLoggingService(service: ILoggingService): void;
 }
 
 // https://go.mparticle.com/work/SQDSDKS-4805

package/src/serverModel.ts

@@ -302,7 +302,7 @@ export default function ServerModel(
                     //  events do not have names, but are denoted by their `event_type`
                     EventName:
                         event.name ||
-                        ((event.messageType as unknown) as string),
+                        String(event.messageType),
                     EventCategory: event.eventType,
                     EventAttributes: mpInstance._Helpers.sanitizeAttributes(
                         event.data,

package/src/store.ts

@@ -96,8 +96,6 @@ export interface SDKConfig {
     webviewBridgeName?: string;
     workspaceToken?: string;
     requiredWebviewBridgeName?: string;
-    loggingUrl?: string;
-    errorUrl?: string;
     isLoggingEnabled?: boolean;
 }
 
@@ -862,7 +860,7 @@ function processDirectBaseUrls(
     for (let baseUrlKey in defaultBaseUrls) {
         // Any custom endpoints passed to mpConfig will take priority over direct
         // mapping to the silo.  The most common use case is a customer provided CNAME.
-        if (baseUrlKey === 'configUrl' || baseUrlKey === 'loggingUrl' || baseUrlKey === 'errorUrl') {
+        if (baseUrlKey === 'configUrl') {
             directBaseUrls[baseUrlKey] =
                 config[baseUrlKey] || defaultBaseUrls[baseUrlKey];
             continue;