kv-test-lib 1.0.0

package/dist/payloads/install.js

@@ -0,0 +1,148 @@
+/*
+  Authored by Brett Barinaga on 11/17/21.
+  Copyright (c) Kochava, Inc. All rights reserved.
+*/
+import * as http from "../http";
+import * as utils from "../utils/utils";
+import * as browser from "../browser/browser";
+import { Log } from "../utils/log";
+import { constructPayload } from "./payload";
+import { getPersistedIdentityLinks, PersistKey, readAndUpdatePersistedValue, updatePersistedValue } from "../browser/persist";
+let timeOut;
+let canceled = false;
+export const build = (instance) => {
+    const payload = constructPayload("install", instance);
+    instance.installStarted = true;
+    payload.data = constructInstallData(instance);
+    Log.debug("Install Payload", JSON.stringify(payload));
+    if (instance.kochavaConfig.privacy) {
+        instance.kochavaConfig.privacy.deny_datapoints.forEach(denyPoint => {
+            for (const point in payload.data) {
+                const key = point;
+                if (key === denyPoint)
+                    delete payload.data[key];
+            }
+            for (const point in payload) {
+                const key = point;
+                if (key === denyPoint)
+                    delete payload[key];
+            }
+        });
+    }
+    return payload;
+};
+export const cancelRetries = () => {
+    canceled = true;
+    clearTimeout(timeOut);
+};
+export const send = async (instance, payload, retries = 0) => {
+    canceled = false;
+    let success = false;
+    let resp;
+    do {
+        const sendTime = utils.getCurrTimeMS() - instance.startTimeMS;
+        Log.diagDebug(`Sending install at ${utils.formatTime(sendTime / 1000)} seconds`);
+        const respStr = await http.sendRequest(payload, (instance.overrideUrls.install) ?
+            instance.overrideUrls.install : instance.kochavaConfig.networking.urls.install);
+        const respTime = utils.getCurrTimeMS() - instance.startTimeMS;
+        Log.diagDebug(`Completed install at ${new Date().toLocaleTimeString()} 
+      seconds with a network duration of ${utils.formatTime((respTime - sendTime) / 1000)} seconds`);
+        if (canceled) {
+            Log.trace("Can no longer retry install, cancelling.");
+            return false;
+        }
+        try {
+            Log.trace("Install Response string:", respStr);
+            resp = JSON.parse(respStr);
+            Log.debug("Install Response:", respStr);
+            success = http.wasRespSuccess(resp.success);
+        }
+        catch (e) {
+            Log.error("Error parsing Install Response", e);
+            success = false;
+        }
+        if (success) {
+            Log.info("Install success!");
+            return success;
+        }
+        if (!canceled) {
+            const retryWaterfall = instance.kochavaConfig.networking.retry_waterfall;
+            const retryIndex = (retries > retryWaterfall.length - 1) ? retryWaterfall.length - 1 : retries;
+            const retrySec = retryWaterfall[retryIndex];
+            Log.error(`Install failed, attempting again in ${retrySec} seconds`);
+            await new Promise(resolve => { timeOut = setTimeout(resolve, retrySec * 1000); });
+            retries++;
+        }
+    } while (!success && !canceled);
+};
+export const onSuccess = (instance) => {
+    instance.kochavaInstallDate = utils.getCurrTimeMS();
+    updatePersistedValue(PersistKey.InstallSentDate, String(instance.kochavaInstallDate), instance.useCookies);
+};
+const constructInstallData = (instance) => {
+    const currTime = Math.floor(Date.now() / 1000);
+    let uptime = (currTime - instance.startTimeMS) / 1000;
+    if (uptime < 0.0)
+        uptime = 0.0;
+    let returnObj = {
+        starttime: instance.startTimeMS / 1000,
+        uptime: uptime,
+        usertime: determineInstallUserTime(instance, currTime),
+        device_orientation: browser.getDeviceOrientation(),
+        package: browser.getPackageName(),
+        disp_w: browser.getDeviceWidth(),
+        disp_h: browser.getDeviceHeight(),
+        language: browser.getLanguage(),
+    };
+    if (instance.utm) {
+        returnObj = Object.assign(Object.assign({}, returnObj), { conversion_data: { utm_source: instance.utm } });
+    }
+    if (instance.customValues.length > 0)
+        returnObj.device_ids = {};
+    instance.customValues.forEach((custom) => {
+        const customKey = Object.keys(custom.data)[0];
+        if (instance.kochavaConfig.privacy) {
+            let keyAllowed = false;
+            for (const allowed of instance.kochavaConfig.privacy.allow_custom_ids) {
+                if (customKey === allowed) {
+                    keyAllowed = true;
+                }
+            }
+            if (keyAllowed) {
+                if (custom.isDeviceId)
+                    returnObj.device_ids = Object.assign(Object.assign({}, returnObj.device_ids), custom.data);
+                else
+                    returnObj = Object.assign(Object.assign({}, custom.data), returnObj);
+            }
+        }
+    });
+    // add the persisted identityLinks
+    const persistedIdLinks = getPersistedIdentityLinks();
+    if (persistedIdLinks) {
+        returnObj.identity_link = {};
+        for (const key in persistedIdLinks) {
+            let includeKey = true;
+            for (const denyIdLinkKey of instance.kochavaConfig.privacy.deny_identity_links) {
+                if (denyIdLinkKey === key) {
+                    Log.debug(`Denied identity_link ${denyIdLinkKey}, dropping from install.`);
+                    includeKey = false;
+                }
+            }
+            if (includeKey)
+                returnObj.identity_link[key] = persistedIdLinks[key];
+        }
+    }
+    return returnObj;
+};
+const determineInstallUserTime = (instance, currTime) => {
+    const firstStartStr = readAndUpdatePersistedValue(PersistKey.FirstStartDate, instance.useCookies);
+    if (firstStartStr) {
+        const firstStart = JSON.parse(firstStartStr);
+        // If its been 30 days since the sdk started
+        if ((currTime - firstStart) > 2592000) {
+            return currTime;
+        }
+        return firstStart;
+    }
+    return currTime;
+};

package/dist/payloads/kvinit.d.ts

@@ -0,0 +1,5 @@
+import { KochavaInstance } from "../kochava";
+import { KvinitResponse } from "../interfaces";
+export declare const cancelRetries: () => void;
+export declare const send: (instance: KochavaInstance, retryWaterfall: number[], retries?: number) => Promise<boolean>;
+export declare const applyKvinitResp: (instance: KochavaInstance, resp: KvinitResponse) => void;

package/dist/payloads/kvinit.js

@@ -0,0 +1,134 @@
+/*
+  Authored by Brett Barinaga on 11/17/21.
+  Copyright (c) Kochava, Inc. All rights reserved.
+*/
+import * as http from "../http";
+import * as utils from "../utils/utils";
+import { getPackageName } from "../browser/browser";
+import { Log } from "../utils/log";
+import { constructPayload } from "./payload";
+import { DEFAULTS } from "../interfaces";
+import { PersistKey, updatePersistedValue } from "../browser/persist";
+let timeOut;
+let canceled = false;
+const build = (instance) => {
+    const payload = constructPayload("init", instance);
+    payload.build_date = instance.buildDate;
+    payload.data = constructKvinitData(instance);
+    Log.debug("Kvinit Payload", JSON.stringify(payload));
+    return payload;
+};
+export const cancelRetries = () => {
+    canceled = true;
+    clearTimeout(timeOut);
+};
+export const send = async (instance, retryWaterfall, retries = 0) => {
+    canceled = false;
+    const payload = build(instance);
+    let success = false;
+    let resp;
+    do {
+        Log.trace("Kvinit endpoint:", instance.kochavaConfig.networking.urls.init);
+        const sendTime = utils.getCurrTimeMS() - instance.startTimeMS;
+        Log.diagDebug(`Sending kvinit at ${utils.formatTime(sendTime / 1000)} seconds`);
+        const respStr = await http.sendRequest(payload, (instance.overrideUrls.init) ?
+            instance.overrideUrls.init : instance.kochavaConfig.networking.urls.init);
+        const respTime = utils.getCurrTimeMS() - instance.startTimeMS;
+        Log.diagDebug(`Completed kvinit at ${utils.formatTime(respTime / 1000)}
+      seconds with a network duration of ${utils.formatTime((respTime - sendTime) / 1000)} seconds`);
+        if (canceled) {
+            Log.trace("Can no longer retry kvinit, cancelling.");
+            return false;
+        }
+        try {
+            resp = JSON.parse(respStr);
+            Log.debug("Kvinit Response:", resp);
+            success = http.wasRespSuccess(resp.success);
+        }
+        catch (e) {
+            Log.error("Error parsing Kvinit Response", e);
+            success = false;
+        }
+        if (success) {
+            Log.info("Kvinit success!");
+            updatePersistedValue(PersistKey.LastKvinit, JSON.stringify(resp), instance.useCookies);
+            return success;
+        }
+        if (!canceled) {
+            // retry kvinit
+            const retryIndex = (retries > retryWaterfall.length - 1) ? retryWaterfall.length - 1 : retries;
+            const retrySec = retryWaterfall[retryIndex];
+            Log.error(`Kvinit failed, attempting again in ${retrySec} seconds`);
+            await new Promise(resolve => { timeOut = setTimeout(resolve, retrySec * 1000); });
+            retries++;
+        }
+    } while (!success && !canceled);
+};
+export const applyKvinitResp = (instance, resp) => {
+    if (resp.general) {
+        if (resp.general.device_id_override) {
+            Log.trace(`Device_id override found, going from ${instance.kochavaDeviceId} to
+        ${resp.general.device_id_override}`);
+            instance.kochavaConfig.general.device_id_override = resp.general.device_id_override;
+            instance.kochavaDeviceId = resp.general.device_id_override;
+            updatePersistedValue(PersistKey.OverrideDeviceId, resp.general.device_id_override, instance.useCookies);
+        }
+        if (resp.general.app_id_override) {
+            Log.trace(`App_id override found, going from ${instance.appGuid} to
+        ${resp.general.app_id_override}`);
+            instance.kochavaConfig.general.app_id_override = resp.general.app_id_override;
+            instance.appGuid = resp.general.app_id_override;
+            updatePersistedValue(PersistKey.OverrideAppId, resp.general.app_id_override, instance.useCookies);
+        }
+    }
+    if (resp.config) {
+        instance.kochavaConfig.config = {
+            init_token: resp.config.init_token || DEFAULTS.config.init_token,
+            refresh_minimum: (resp.config.refresh_minimum !== undefined &&
+                resp.config.refresh_minimum !== null) ? resp.config.refresh_minimum :
+                DEFAULTS.config.refresh_minimum,
+        };
+    }
+    if (resp.install) {
+        if (resp.install.resend_id) {
+            instance.kochavaConfig.install.resend_id = resp.install.resend_id;
+        }
+        instance.kochavaConfig.install.updates_enabled =
+            resp.install.updates_enabled || DEFAULTS.install.updates_enabled;
+    }
+    if (resp.networking) {
+        instance.kochavaConfig.networking.retry_waterfall =
+            resp.networking.retry_waterfall || DEFAULTS.networking.retry_waterfall;
+        instance.retryWaterfall =
+            instance.kochavaConfig.networking.retry_waterfall;
+        if (resp.networking.urls) {
+            instance.kochavaConfig.networking.urls = {
+                init: resp.networking.urls.init || DEFAULTS.networking.urls.init,
+                install: resp.networking.urls.install || DEFAULTS.networking.urls.install,
+                event: resp.networking.urls.event || DEFAULTS.networking.urls.event,
+                identityLink: resp.networking.urls.identityLink || DEFAULTS.networking.urls.identityLink,
+            };
+        }
+    }
+    if (resp.privacy) {
+        instance.kochavaConfig.privacy = {
+            allow_custom_ids: resp.privacy.allow_custom_ids || DEFAULTS.privacy.allow_custom_ids,
+            deny_datapoints: resp.privacy.deny_datapoints || DEFAULTS.privacy.deny_datapoints,
+            deny_event_names: resp.privacy.deny_event_names || DEFAULTS.privacy.deny_event_names,
+            deny_identity_links: resp.privacy.deny_identity_links || DEFAULTS.privacy.deny_identity_links,
+        };
+    }
+};
+const constructKvinitData = (instance) => {
+    const currTime = Math.floor(Date.now() / 1000);
+    let uptime = (currTime - instance.startTimeMS) / 1000;
+    if (uptime < 0.0)
+        uptime = 0.0;
+    return {
+        package: getPackageName(),
+        platform: "web",
+        starttime: instance.startTimeMS / 1000,
+        uptime,
+        usertime: currTime,
+    };
+};

package/dist/payloads/payload.d.ts

@@ -0,0 +1,33 @@
+import { Json } from '../interfaces';
+import { KochavaInstance } from "../kochava";
+export interface Payload {
+    action: string;
+    kochava_app_id: string;
+    kochava_device_id: string;
+    sdk_version: string;
+    sdk_protocol: string;
+    nt_id: string;
+    build_date?: string;
+    init_token?: string;
+    data?: Json;
+}
+export interface PreStartBody {
+    action: string;
+    sdk_version: string;
+    sdk_protocol: string;
+    init_token?: string;
+    data?: Json;
+}
+export interface PostStartBody {
+    kochava_app_id: string;
+    kochava_device_id: string;
+    nt_id: string;
+    data?: Json;
+}
+export interface CommonData {
+    starttime: number;
+    uptime: number;
+    usertime: number;
+}
+export declare const constructPayload: (action: string, instance: KochavaInstance, originalNtId?: string) => Payload;
+export declare const constructCommonData: (instance: KochavaInstance) => CommonData;

package/dist/payloads/payload.js

@@ -0,0 +1,33 @@
+/*
+  Authored by Brett Barinaga on 11/17/21.
+  Copyright (c) Kochava, Inc. All rights reserved.
+*/
+import * as utils from "../utils/utils";
+import { Log } from "../utils/log";
+export const constructPayload = (action, instance, originalNtId) => {
+    let nt_id = `${instance.kochavaSession}-${instance.kochavaSessionCount}-${utils.uuidv4()}`;
+    if (originalNtId) {
+        Log.debug("Persisted call found with nt_id:", originalNtId);
+        nt_id = originalNtId;
+    }
+    return {
+        action: action,
+        kochava_app_id: instance.appGuid,
+        kochava_device_id: instance.kochavaDeviceId,
+        sdk_version: instance.version,
+        sdk_protocol: "17",
+        nt_id: nt_id,
+        init_token: (instance.kochavaConfig.config.init_token) || undefined,
+    };
+};
+export const constructCommonData = (instance) => {
+    const currTime = utils.getCurrTimeMS();
+    let uptime = (currTime - instance.startTimeMS) / 1000;
+    if (uptime < 0.0)
+        uptime = 0.0;
+    return {
+        starttime: instance.startTimeMS / 1000,
+        uptime: uptime,
+        usertime: currTime / 1000,
+    };
+};

package/dist/utils/log.d.ts

@@ -0,0 +1,30 @@
+declare enum Level {
+    Off = "Off",
+    Error = "Error",
+    Warn = "Warn",
+    Info = "Info",
+    Debug = "Debug",
+    Trace = "Trace"
+}
+declare class Logger {
+    private currLevel;
+    private logObjects;
+    private levelPrio;
+    private logsFilteredOut;
+    static instance: Logger;
+    constructor();
+    setLogLevel(input: string): void;
+    getLogLevel(): string;
+    setLogObjects(enable: boolean): void;
+    disableLogType(input: string): void;
+    error(msg: string, ...args: any): void;
+    warn(msg: string, ...args: any): void;
+    info(msg: string, ...args: any): void;
+    debug(msg: string, ...args: any): void;
+    trace(msg: string, ...args: any): void;
+    diagInfo(msg: string, ...args: any): void;
+    diagDebug(msg: string, ...args: any): void;
+    print(lvl: Level, msg: string, ...args: any): void;
+}
+export declare const Log: Logger;
+export {};

package/dist/utils/log.js

@@ -0,0 +1,104 @@
+/*
+  Authored by Brett Barinaga on 11/17/21.
+  Copyright (c) Kochava, Inc. All rights reserved.
+*/
+import { getMsTime } from "./utils";
+var Level;
+(function (Level) {
+    Level["Off"] = "Off";
+    Level["Error"] = "Error";
+    Level["Warn"] = "Warn";
+    Level["Info"] = "Info";
+    Level["Debug"] = "Debug";
+    Level["Trace"] = "Trace";
+})(Level || (Level = {}));
+class Logger {
+    constructor() {
+        if (Logger.instance)
+            return;
+        this.levelPrio = {
+            Off: 0,
+            Error: 1,
+            Warn: 2,
+            Info: 3,
+            Debug: 4,
+            Trace: 5,
+        };
+        this.currLevel = Level.Info;
+        this.logObjects = false;
+        this.logsFilteredOut = {
+            Off: false,
+            Error: false,
+            Warn: false,
+            Info: false,
+            Debug: false,
+            Trace: false,
+            Diag: false,
+        };
+        Logger.instance = this;
+    }
+    setLogLevel(input) {
+        const levelStr = input[0].toUpperCase() + input.substring(1).toLowerCase();
+        const key = levelStr;
+        const level = Level[key];
+        if (level !== undefined && level !== null) {
+            this.currLevel = level;
+        }
+        else {
+            console.log(`Invalid logLevel ${level} passed in, defaulting to info.`);
+            this.currLevel = Level.Info;
+        }
+    }
+    getLogLevel() {
+        return this.currLevel.toString();
+    }
+    setLogObjects(enable) {
+        this.logObjects = enable;
+    }
+    disableLogType(input) {
+        const levelStr = input[0].toUpperCase() + input.substring(1).toLowerCase();
+        const key = levelStr;
+        this.logsFilteredOut[key] = true;
+    }
+    error(msg, ...args) {
+        this.print(Level.Error, msg, ...args);
+    }
+    warn(msg, ...args) {
+        this.print(Level.Warn, msg, ...args);
+    }
+    info(msg, ...args) {
+        this.print(Level.Info, msg, ...args);
+    }
+    debug(msg, ...args) {
+        this.print(Level.Debug, msg, ...args);
+    }
+    trace(msg, ...args) {
+        this.print(Level.Trace, msg, ...args);
+    }
+    diagInfo(msg, ...args) {
+        if (!this.logsFilteredOut.Diag)
+            this.print(Level.Info, "Kochava Diagnostic - " + msg, ...args);
+    }
+    diagDebug(msg, ...args) {
+        if (!this.logsFilteredOut.Diag)
+            this.print(Level.Debug, "Kochava Diagnostic - " + msg, ...args);
+    }
+    print(lvl, msg, ...args) {
+        if (this.levelPrio[this.currLevel.toString()] >= this.levelPrio[lvl.toString()] &&
+            !this.logsFilteredOut[lvl.toString()]) {
+            try {
+                const obj = JSON.parse(args[0]);
+                if (this.logObjects && obj) {
+                    console.log(`KVA :: ${getMsTime()} ${lvl.toString()}:`, msg, obj);
+                }
+                else {
+                    console.log(`KVA :: ${getMsTime()} ${lvl.toString()}:`, msg, ...args);
+                }
+            }
+            catch (_a) {
+                console.log(`KVA :: ${getMsTime()} ${lvl.toString()}:`, msg, ...args);
+            }
+        }
+    }
+}
+export const Log = new Logger();

package/dist/utils/utils.d.ts

@@ -0,0 +1,5 @@
+export declare const uuidv4: () => string;
+export declare const getCurrTimeMS: () => number;
+export declare const getCurrTimeSec: () => number;
+export declare const formatTime: (num: number) => string;
+export declare const getMsTime: () => string;

package/dist/utils/utils.js

@@ -0,0 +1,21 @@
+/*
+  Authored by Brett Barinaga on 11/17/21.
+  Copyright (c) Kochava, Inc. All rights reserved.
+*/
+export const uuidv4 = () => {
+    return (`${1e7}-${1e3}-${4e3}-${8e3}-${1e11}`).replace(/[018]/g, (c) => (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16));
+};
+// returns the number of milliseconds elapsed since January 1, 1970 
+export const getCurrTimeMS = () => Math.floor(Date.now());
+// returns the number of seconds elapsed since January 1, 1970 
+export const getCurrTimeSec = () => Math.floor(Date.now() / 1000);
+export const formatTime = (num) => {
+    if (num < 10 && num % 10 <= 9)
+        return "0" + num.toFixed(1).toString();
+    else
+        return num.toFixed(1).toString();
+};
+export const getMsTime = () => {
+    const date = new Date();
+    return `${date.getHours()}:${date.getMinutes()}:${date.getSeconds()}:${date.getMilliseconds()}`;
+};

package/package.json

@@ -0,0 +1,16 @@
+{
+  "type": "module",
+  "name": "kv-test-lib",
+  "version": "1.0.0",
+  "description": "",
+  "scripts": {
+    "build": "tsc -p ../../src/tsconfig.node.json",
+    "test": "tsc -p ."
+  },
+  "devDependencies": {
+    "playwright": "^1.16.3",
+    "typescript": "^4.5.5"
+  },
+  "author": "",
+  "license": "ISC"
+}

package/webpack.config.js

@@ -0,0 +1,64 @@
+// Generated using webpack-cli https://github.com/webpack/webpack-cli
+
+const path = require('path');
+// import * as path from 'path';
+
+const isProduction = process.env.NODE_ENV == 'production';
+
+const kochavaConfig = {
+  entry: '../../src/kochava.ts',
+  plugins: [
+    // Add your plugins here
+    // Learn more about plugins from https://webpack.js.org/configuration/plugins/
+  ],
+  output: {
+    filename: 'kochava.js',
+    path: path.resolve(__dirname, 'dist'),
+    clean: true,
+  },
+  target: 'web',
+  module: {
+    rules: [
+      {
+        test: /\.(ts|tsx)$/i,
+        loader: 'ts-loader',
+        exclude: ['/node_modules/'],
+        options: {
+          configFile: "tsconfig.node.json"
+        }
+      },
+      {
+        test: /\.(eot|svg|ttf|woff|woff2|png|jpg|gif)$/i,
+        type: 'asset',
+      },
+
+      // Add your rules for custom modules here
+      // Learn more about loaders from https://webpack.js.org/loaders/
+    ],
+  },
+  resolve: {
+    extensions: ['.ts', '.js'],
+  },
+  mode: (isProduction) ? 'production' : 'development',
+  devtool: 'source-map',
+};
+
+
+module.exports = [
+  kochavaConfig,
+];
+module.exports.parallelism = 2;
+
+
+
+
+
+// module.exports = () => {
+//   if (isProduction) {
+//     config.mode = 'production';
+//   } else {
+//     config.mode = 'development';
+//   }
+//   return config;
+// };
+