noibu-react-native 0.2.6 → 0.2.8

package/dist/api/InputManager.js

@@ -0,0 +1,156 @@
+import { __awaiter } from 'tslib';
+import MetroplexSocket from './MetroplexSocket.js';
+import { saveErrorToPagevisit } from '../pageVisit/pageVisitEventError.js';
+import HelpCode from './HelpCode.js';
+import { Singleton } from '../monitors/BaseMonitor.js';
+import '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
+import { PageVisitErrorSource } from '../node_modules/@noibu/metroplex-ts-bindings/dist/PageVisitErrorSource.js';
+import { WebsocketMessageType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/WebsocketMessageType.js';
+
+// maximum ids that a user can add to a pagevisit
+const MAX_CUSTOM_IDS_PER_PAGEVISIT = 10;
+const MAX_CUSTOM_ERRORS_PER_PAGEVISIT = 500;
+const TOO_MANY_IDS_ADDED_MSG = 'TOO_MANY_IDS_ADDED';
+const ID_NAME_ALREADY_ADDED_MSG = 'ID_NAME_ALREADY_ADDED';
+const NAME_TOO_LONG_MSG = 'NAME_TOO_LONG';
+const VALUE_TOO_LONG_MSG = 'VALUE_TOO_LONG';
+const INVALID_NAME_TYPE_MSG = 'INVALID_NAME_TYPE';
+const INVALID_VALUE_TYPE_MSG = 'INVALID_VALUE_TYPE';
+const NAME_HAS_NO_LENGTH_MSG = 'NAME_HAS_NO_LENGTH';
+const VALUE_HAS_NO_LENGTH_MSG = 'VALUE_HAS_NO_LENGTH';
+const SUCCESS_MSG = 'SUCCESS';
+const ERROR_HAS_NO_MSG_MSG = 'ERROR_HAS_NO_MSG';
+const ERROR_HAS_NO_STACK_MSG = 'ERROR_HAS_NO_STACK';
+const NULL_CUSTOM_ERR_MSG = 'NULL_CUSTOM_ERROR';
+const TOO_MANY_ERRORS_RECEIVED_PER_PAGEVISIT_MSG = 'TOO_MANY_ERRORS_RECEIVED_PER_PAGEVISIT';
+/** this class controls the input that customers can inject into
+ * our script via the NoibuJS SDK
+ */
+class InputManager extends Singleton {
+    constructor() {
+        super(...arguments);
+        this.customIDs = {};
+        this.customErrorsCount = 0;
+    }
+    /** exposes functions to the window of the browser for the clients
+     * to interact with on their end
+     */
+    exposeFunctions() {
+        return {
+            // adding all the functions and binding the current context
+            // so that we can use the exposed function as if they are running`
+            // in the noibujs script
+            requestHelpCode: this._requestHelpCode.bind(this),
+            addCustomAttribute: this._addCustomAttribute.bind(this),
+            addError: this._addCustomError.bind(this),
+            addJsSdkError: this._addErrorFromJSSdk.bind(this),
+        };
+    }
+    /** validates the custom error that was passed */
+    getErrorValidationError(customError) {
+        if (!customError) {
+            return NULL_CUSTOM_ERR_MSG;
+        }
+        if (!customError.message) {
+            return ERROR_HAS_NO_MSG_MSG;
+        }
+        if (!customError.stack) {
+            return ERROR_HAS_NO_STACK_MSG;
+        }
+        return SUCCESS_MSG;
+    }
+    /** Validates and sets the custom error to our internal trackers */
+    _validateAndSetCustomError(customError) {
+        // we cap the number of errors allowed to be sent
+        if (this.customErrorsCount >= MAX_CUSTOM_ERRORS_PER_PAGEVISIT) {
+            return TOO_MANY_ERRORS_RECEIVED_PER_PAGEVISIT_MSG;
+        }
+        // need to validate first before we start operating with the received
+        // data
+        const validationResult = this.getErrorValidationError(customError);
+        if (validationResult !== SUCCESS_MSG) {
+            return validationResult;
+        }
+        this.customErrorsCount += 1;
+        return SUCCESS_MSG;
+    }
+    /** adds an error from a JS Sdk to the session */
+    _addErrorFromJSSdk(customError, errorSource) {
+        const validationAndSettingResult = this._validateAndSetCustomError(customError);
+        if (validationAndSettingResult !== SUCCESS_MSG) {
+            return validationAndSettingResult;
+        }
+        saveErrorToPagevisit({ error: customError, type: `${errorSource}` });
+        return validationAndSettingResult;
+    }
+    /** adds a custom Error to the session */
+    _addCustomError(customError) {
+        const validationAndSettingResult = this._validateAndSetCustomError(customError);
+        if (validationAndSettingResult !== SUCCESS_MSG) {
+            return validationAndSettingResult;
+        }
+        // customError is validated at this point
+        saveErrorToPagevisit({ type: PageVisitErrorSource.CustomError, error: customError });
+        return validationAndSettingResult;
+    }
+    /**
+     * adds a custom id to the session
+     * todo wrong param types, should be unknown
+     */
+    _addCustomAttribute(name, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // we return if we are over the limit of ids
+            if (Object.keys(this.customIDs).length >= MAX_CUSTOM_IDS_PER_PAGEVISIT) {
+                return TOO_MANY_IDS_ADDED_MSG;
+            }
+            // need to validate first before we start operating with the received
+            // data
+            const validationResult = this.getValidationError(name, value);
+            if (validationResult !== SUCCESS_MSG) {
+                return validationResult;
+            }
+            // we do not want to keep sending something that was already sent
+            if (name in this.customIDs) {
+                return ID_NAME_ALREADY_ADDED_MSG;
+            }
+            this.customIDs[name] = value;
+            yield MetroplexSocket.getInstance().sendMessage({
+                type: WebsocketMessageType.PageVisitMeta,
+                payload: {
+                    id_name: name,
+                    id_val: value,
+                },
+            });
+            return SUCCESS_MSG;
+        });
+    }
+    /** validation function for customer input */
+    getValidationError(name, value) {
+        // all ids need to be strings and less than 50 chars and more than 0 chars
+        if (typeof name !== 'string') {
+            return INVALID_NAME_TYPE_MSG;
+        }
+        if (typeof value !== 'string') {
+            return INVALID_VALUE_TYPE_MSG;
+        }
+        if (value.length > 50) {
+            return VALUE_TOO_LONG_MSG;
+        }
+        if (name.length > 50) {
+            return NAME_TOO_LONG_MSG;
+        }
+        if (value.length === 0) {
+            return VALUE_HAS_NO_LENGTH_MSG;
+        }
+        if (name.length === 0) {
+            return NAME_HAS_NO_LENGTH_MSG;
+        }
+        return SUCCESS_MSG;
+    }
+    /** Requests a help code from the HelpCode instance. */
+    _requestHelpCode() {
+        return HelpCode.getInstance().requestHelpCode();
+    }
+}
+
+export { InputManager as default };

package/dist/{src/api/metroplexSocket.d.ts → api/MetroplexSocket.d.ts}

@@ -1,7 +1,10 @@
-import { PAGE_VISIT_PART_ATT_NAME, PAGE_VISIT_VID_FRAG_ATT_NAME } from '../constants';
-import { CompletePageVisit, InboundMessageType, OutboundMessageType, OutboundMessageTypeMap, PageVisitFrag, PageVisitInfo, SlidingMessage, VideoFrag } from '../../types/Metroplex.types';
-import { PVEventMessage } from '../../types/PageVisitEvents.types';
+import { MetroplexInputRouteMap, MetroplexRoute, PageInformation, PageVisitEvent, VideoRecorder, WebsocketMessageType } from '@noibu/metroplex-ts-bindings';
 import { Singleton } from '../monitors/BaseMonitor';
+import { NoSeqNumSlidingMessage, RetryQueueWSMessage } from '../types/Metroplex';
+/**
+ * Grab the video recorder type based on the device we run the app on.
+ */
+export declare function getVideoRecorderType(): Promise<VideoRecorder>;
 /**
  * Implements rolling window of specified size,
  * but only makes a cut once array length exceeds 150%.
@@ -16,8 +19,8 @@ export default class MetroplexSocket extends Singleton {
     previousMessageType: string;
     currentConnectionAttempts: number;
     connectionCount: number;
-    sessionStartTime: any;
-    connectionPromise: Promise<void> | null;
+    sessionStartTime: number;
+    connectionPromise: Promise<void>;
     pageVisitInfoSent: boolean;
     connectionURL: string;
     postURL: string;
@@ -25,8 +28,8 @@ export default class MetroplexSocket extends Singleton {
     latestReceivedSeqNumber: number;
     isRetryLoopDisabled: boolean;
     /** messages that need to be resent to metroplex since they are lacking confirmation */
-    retryMessageQueue: SlidingMessage<keyof OutboundMessageTypeMap>[];
-    metroplexTypeLock: Record<OutboundMessageType, boolean>;
+    retryMessageQueue: RetryQueueWSMessage[];
+    metroplexTypeLock: Record<WebsocketMessageType, boolean>;
     initialURL: string;
     initialReferringURL: string;
     sessionTimestamp: Date;
@@ -37,7 +40,7 @@ export default class MetroplexSocket extends Singleton {
     socketCloseCodes: string[];
     socketOpens: string[];
     ackedOnce: boolean;
-    metroRetryFrequencyMS: 30000;
+    metroRetryFrequencyMS: number;
     retryMetroplexInterval: ReturnType<typeof setTimeout> | null;
     private helpCodeCb;
     /**
@@ -45,12 +48,18 @@ export default class MetroplexSocket extends Singleton {
      * id of script, to make sure only a single socket is open
      */
     constructor(scriptInstanceId?: string);
-    private static readonly typeToPayloadPropMap;
+    /**
+     * connectSocket will establish a websocket connection to the metroplex
+     * service
+     */
+    connectSocket(): Promise<void>;
+    /** sets up events that will trigger the event queue to be emptied */
+    _setupOffloadEvents(): void;
     /**
      * Adds the seq num field to the given payload depending on whether its
      * a page visit part or video frag
      */
-    _addSeqNumToPayload<T>(type: OutboundMessageType, payload: T): T;
+    _addSeqNumToPayload<T extends RetryQueueWSMessage>(message: NoSeqNumSlidingMessage<T>): Promise<T>;
     /** requests help code and saves a callback to be called on response */
     requestHelpCode(cb: typeof this.helpCodeCb): Promise<boolean>;
     /**
@@ -58,10 +67,10 @@ export default class MetroplexSocket extends Singleton {
      * Queues the message if the connection isn't open yet.
      * returns true if message was sent succefully, false otherwise
      */
-    sendMessage<T extends OutboundMessageType>(type: T, payload: OutboundMessageTypeMap[T]): Promise<boolean>;
+    sendMessage(message: NoSeqNumSlidingMessage<RetryQueueWSMessage<WebsocketMessageType>>): Promise<boolean>;
     /** Updates the latest pv message sent timestamp if events contain any user steps
      */
-    _updateLatestPvTimestamp(events: PVEventMessage[]): Promise<void>;
+    _updateLatestPvTimestamp(events: PageVisitEvent[]): Promise<void>;
     /** returns true if the socket is either connecting or connected to metroplex */
     isConnected(): boolean;
     /** returns true if we are connecting to the socket */
@@ -71,27 +80,19 @@ export default class MetroplexSocket extends Singleton {
     /** Connects the web socket to metroplex and calls callback upon successfully connecting
      */
     handleConnect(forceOpen: boolean): Promise<void>;
-    /**
-     * connectSocket will establish a websocket connection to the metroplex
-     * service
-     */
-    connectSocket(): Promise<void>;
-    /** Calculates and sets the end_at field of the payload
-     * @param  {} payload
-     * @param  {} isPageVisit
-     */
-    addEndTimeToPayload<T extends VideoFrag | PageVisitFrag>(payload: T, isPageVisit: boolean): T;
+    /** Calculates and sets the end_at field of the payload   */
+    addEndTimeToPayload<T>(payload: T, isPageVisit: boolean): T & {
+        end_at: string;
+    };
     /** open handler for socket */
     _onSocketOpen(): Promise<void>;
-    /** message handler for socket
-     * @param  {} event
-     */
-    _onSocketMessage(event: InboundMessageType): Promise<void>;
+    /** message handler for socket  */
+    _onSocketMessage(event: WebSocketMessageEvent): Promise<void>;
     /**
      * Returns true if the message's payload has the payload type given and has a sequence
      * number higher than seqNum
      */
-    _messagePayloadHasLargerSeqNum(message: SlidingMessage, payloadType: typeof PAGE_VISIT_PART_ATT_NAME | typeof PAGE_VISIT_VID_FRAG_ATT_NAME, seqNum: number): boolean;
+    _messagePayloadHasLargerSeqNum(message: RetryQueueWSMessage, seqNum: number): boolean | 0;
     /**
      * removes messages from the retry queue that are smaller than the
      * latest stored message in metroplex
@@ -101,8 +102,6 @@ export default class MetroplexSocket extends Singleton {
     _sendUnconfirmedMessages(socketWasAlreadyOpen: boolean): Promise<void>;
     /** sets up the interval to empty the queue as we receive confirmation messages from metroplex */
     setupRetryMechanism(): void;
-    /** sets up events that will trigger the event queue to be emptied */
-    _setupOffloadEvents(): void;
     /**
      * will handle the final moments of a page being active. It
      * will try to empty both the queues with beacons.
@@ -113,25 +112,21 @@ export default class MetroplexSocket extends Singleton {
      * will try to empty both the queues with beacons.
      */
     postFullPageVisit(maxMessageSize: number): Promise<void>;
-    /**
-     * will send a message to metroplex via a post request that will outlive the current page
-     */
-    postMessage(msg: CompletePageVisit): Promise<void>;
+    /** will send a message to metroplex via a post request that will outlive the current page */
+    postMessage(msg: MetroplexInputRouteMap[MetroplexRoute.PageVisit]): Promise<void>;
     /**
      * Stringifies the payload into JSON, sends it to the back end if the session
      * is active and returns true. If inactive the session and socket are closed
      * and this method returns false.
      */
-    _sendSocketMessage<T extends ValueOf<OutboundMessageTypeMap>>(payload: T): Promise<void>;
+    private sendSocketMessage;
     /**
      * Closes the socket connection if the session is inactive. Returns true if the
      * session is inactive
      */
     closeIfInactive(): Promise<boolean>;
     /** will get page information, calling this will increase the connection count */
-    getPageInformation(): Promise<PageVisitInfo>;
-    /**
-     * Try to parse help code response and fire custom event
-     */
+    getPageInformation(): Promise<PageInformation>;
+    /** Try to parse help code response and fire custom event */
     _tryProcessHelpCodeResponse(response: unknown): boolean;
 }