@dotcms/experiments 0.0.1-alpha.39 → 0.0.1-alpha.41

package/src/lib/shared/parser/parser.ts

@@ -1,171 +0,0 @@
-import { Experiment, ExperimentParsed, FetchExperiments } from '../models';
-
-/**
- * This arrow function parses a given set of assigned experiments for analytics.
- *
- * This process involves iterating over the experiments, which are currently in the "Running" state as received from the DotCMS endpoint,
- * analyzing each experiment's relevant data such as running ID, variant name, and look back window value.
- * It also performs regular expression verification for both 'isExperimentPage' and 'isTargetPage' against the current URL.
- *
- * The parsed data is useful for tracking and understanding the user's interaction with the experiment-targeted components during their visit.
- *
- * Contains an object with experiments information.
- *
- * @param experiments
- * @param {Location} location - This parameter is the object representing the current location (URL) of the user.
- * Mostly employed for matching the regular expressions to detect whether the current page is an 'ExperimentPage' or a 'TargetPage'.
- *
- * @returns {ExperimentParsed} - The function returns an object with the original URL and an array of each experiment's comprehensive detail.
- * The return object is suitable for further analytical operations. Each experiment's detail includes the experiment ID, running ID, variant name,
- * look back window value, and booleans that represent whether current URL is 'isExperimentPage' or 'isTargetPage' for the respective experiment.
- */
-export const parseDataForAnalytics = (
-    experiments: Experiment[],
-    location: Location
-): ExperimentParsed => {
-    const currentHref = location.href;
-
-    return {
-        href: currentHref,
-        experiments: experiments.map((experiment) => ({
-            experiment: experiment.id,
-            runningId: experiment.runningId,
-            variant: experiment.variant.name,
-            lookBackWindow: experiment.lookBackWindow.value,
-            isExperimentPage: verifyRegex(experiment.regexs.isExperimentPage, currentHref),
-            isTargetPage: verifyRegex(experiment.regexs.isTargetPage, currentHref)
-        }))
-    };
-};
-
-/**
- * This utility function performs regular expression (regex) matching on a supplied URL.
- *
- * @param {string | null} regexToCheck - The regular expression to match against the URL.
- * @param {string} href - This is the target URL, which is aimed to be matched against the provided regular expression.
- * @returns {boolean} -The function returns a Boolean value.
- */
-export const verifyRegex = (regexToCheck: string | null, href: string): boolean => {
-    if (regexToCheck === null || href === null) {
-        return false;
-    }
-
-    try {
-        const regexExp = new RegExp(regexToCheck);
-
-        const url = new URL(href);
-
-        const sanitizedHref = `${url.origin}${url.pathname.toLowerCase()}${url.search}`;
-
-        return regexExp.test(sanitizedHref);
-    } catch (error) {
-        console.warn(`The regex ${regexToCheck} it is not a valid regex to check. ${error}`);
-
-        return false;
-    }
-};
-
-/**
- * This function merges newly fetched data with the data stored from IndexedDB, preparing it for re-storage in IndexedDB.
- *
- * @param { AssignedExperiments | null } fetchExperiments - The experiment data fetched from the API.
- * @param { AssignedExperiments | null } storedExperiments - The experiment data currently stored in IndexedDB.
- *
- * @returns { AssignedExperiments } - The parsed experiment data ready for storing.
- *
- * Following cases are handled -
- * 1) When new Data is received without Old data. This is assumed to be the first time data is received.
- * 2) When only old data is received, implying that the timestamp hasn't expired and the data is available in IndexedDB.
- *    The data is verified and any expired experiment is removed before being assigned to dataToStorage.
- * 3) When both old data and new data is present. This implies that the record existed in IndexedDB but was fetched because the flag had expired.
- *    Additional operations are performed to add expiry time to experiments, merging all experiments, and storing them.
- *
- * There could be scenarios where none of these conditions are met, in that case, dataToStorage will be the default empty object.
- */
-export const parseData = (
-    fetchExperiments: FetchExperiments,
-    storedExperiments: Experiment[] | undefined
-): Experiment[] => {
-    let dataToStorage: Experiment[] = {} as Experiment[];
-
-    const { excludedExperimentIdsEnded } = fetchExperiments;
-
-    if (fetchExperiments && !storedExperiments) {
-        // TODO: Use fetchExperiment instead fetchExperimentsNoNoneExperimentID when the endpoint dont retrieve NONE experiment
-        // https://github.com/dotCMS/core/issues/27905
-        const fetchExperimentsNoNoneExperimentID: Experiment[] = fetchExperiments.experiments
-            ? fetchExperiments.experiments.filter((experiment) => experiment.id !== 'NONE')
-            : [];
-
-        dataToStorage = addExpireTimeToExperiments(fetchExperimentsNoNoneExperimentID);
-    }
-
-    if (!fetchExperiments && storedExperiments) {
-        dataToStorage = getUnexpiredExperiments(storedExperiments, excludedExperimentIdsEnded);
-    }
-
-    if (fetchExperiments && storedExperiments) {
-        // TODO: Use fetchExperiment instead fetchExperimentsNoNoneExperimentID when the endpoint dont retrieve NONE experiment
-        // https://github.com/dotCMS/core/issues/27905
-        const fetchExperimentsNoNoneExperimentID: Experiment[] = fetchExperiments.experiments
-            ? fetchExperiments.experiments.filter((experiment) => experiment.id !== 'NONE')
-            : [];
-
-        dataToStorage = [
-            ...addExpireTimeToExperiments(fetchExperimentsNoNoneExperimentID),
-            ...getUnexpiredExperiments(storedExperiments, excludedExperimentIdsEnded)
-        ];
-    }
-
-    return dataToStorage;
-};
-
-/**
- * Retrieves the array of experiment IDs from the given AssignedExperiments..
- *
- * @returns {string[]} Returns an array of experiment IDs if available, otherwise an empty array.
- * @param experiments
- */
-export const getExperimentsIds = (experiments: Experiment[]): string[] =>
-    experiments.map((experiment: Experiment) => experiment.id) || [];
-
-/**
- * Sets the expire time for new experiments based on the current time.
- * The expire time is calculated by adding the expireMillis value of each experiment's lookBackWindow to the current time (Date.now()).
- *
- * @param {Array<Experiment>} experiments - An array of experiments to set the expire time for.
- * @returns {Array<Experiment>} - An updated array of experiments with expire time set.
- */
-const addExpireTimeToExperiments = (experiments: Experiment[]): Experiment[] => {
-    const now = Date.now();
-
-    return experiments.map((experiment) => ({
-        ...experiment,
-        lookBackWindow: {
-            ...experiment.lookBackWindow,
-            expireTime: now + experiment.lookBackWindow.expireMillis
-        }
-    }));
-};
-
-/**
- * Returns an array of experiments that have not expired yet.
- *
- * @param {Experiment[]} experiments - An array of experiments to filter.
- * @param excludedExperimentIdsEnded -  Array of Experiments ids that have been manually ended.
- * @returns {Experiment[]} An array of unexpired experiments.
- */
-const getUnexpiredExperiments = (
-    experiments: Experiment[],
-    excludedExperimentIdsEnded: string[]
-): Experiment[] => {
-    const now = Date.now();
-
-    return experiments.filter((experiment) => {
-        const expireTime = experiment.lookBackWindow?.expireTime;
-
-        return expireTime
-            ? expireTime > now && !excludedExperimentIdsEnded.includes(experiment.id)
-            : false;
-    });
-};

package/src/lib/shared/persistence/index-db-database-handler.spec.ts

@@ -1,100 +0,0 @@
-import fakeIndexedDB from 'fake-indexeddb';
-
-import { IndexDBDatabaseHandler } from './index-db-database-handler';
-
-import {
-    EXPERIMENT_ALREADY_CHECKED_KEY,
-    EXPERIMENT_DB_KEY_PATH,
-    EXPERIMENT_DB_STORE_NAME
-} from '../constants';
-import { IsUserIncludedResponse } from '../mocks/mock';
-import { checkFlagExperimentAlreadyChecked } from '../utils/utils';
-
-if (!globalThis.structuredClone) {
-    globalThis.structuredClone = function (obj) {
-        return JSON.parse(JSON.stringify(obj));
-    };
-}
-
-let persistDatabaseHandler: IndexDBDatabaseHandler;
-
-beforeAll(() => {
-    Object.defineProperty(window, 'indexedDB', {
-        writable: true,
-        value: fakeIndexedDB
-    });
-
-    persistDatabaseHandler = new IndexDBDatabaseHandler({
-        db_store: EXPERIMENT_DB_STORE_NAME,
-        db_name: EXPERIMENT_DB_STORE_NAME,
-        db_key_path: EXPERIMENT_DB_KEY_PATH
-    });
-});
-
-describe('IndexedDB tests', () => {
-    it('saveData successfully saves data to the store', async () => {
-        const key = await persistDatabaseHandler.persistData(IsUserIncludedResponse.entity);
-
-        expect(key).toBe(EXPERIMENT_DB_KEY_PATH);
-    });
-
-    it('getDataByKey successfully retrieves data from the store', async () => {
-        await persistDatabaseHandler.persistData(IsUserIncludedResponse.entity);
-
-        const data = await persistDatabaseHandler.getData();
-
-        expect(data).toEqual(IsUserIncludedResponse.entity);
-    });
-});
-
-describe('SessionStorage EXPERIMENT_ALREADY_CHECKED_KEY handle', () => {
-    Object.defineProperty(window, 'sessionStorage', {
-        value: {
-            setItem: jest.fn(),
-            getItem: jest.fn()
-        },
-        writable: true
-    });
-    it('should set true to sessionStorage key `EXPERIMENT_ALREADY_CHECKED_KEY` ', () => {
-        const value = 'true';
-
-        persistDatabaseHandler.setFlagExperimentAlreadyChecked();
-
-        expect(window.sessionStorage.setItem).toHaveBeenLastCalledWith(
-            EXPERIMENT_ALREADY_CHECKED_KEY,
-            value
-        );
-    });
-
-    it('should set true to sessionStorage key `EXPERIMENT_ALREADY_CHECKED_KEY` ', () => {
-        const value = 'true';
-
-        persistDatabaseHandler.setFlagExperimentAlreadyChecked();
-
-        expect(window.sessionStorage.setItem).toHaveBeenLastCalledWith(
-            EXPERIMENT_ALREADY_CHECKED_KEY,
-            value
-        );
-    });
-
-    describe('checkFlagExperimentAlreadyChecked', () => {
-        const getItemMock = window.sessionStorage.getItem as jest.MockedFunction<
-            typeof window.sessionStorage.getItem
-        >;
-
-        const testCases = [
-            { value: '', expected: false, description: 'sessionStorage value is ""' },
-            { value: 'true', expected: true, description: 'sessionStorage value is "true"' },
-            { value: null, expected: false, description: 'sessionStorage value is null' }
-        ];
-
-        testCases.forEach(({ description, value, expected }) => {
-            it(`returns ${expected} when ${description}`, () => {
-                getItemMock.mockReturnValue(value);
-
-                expect(checkFlagExperimentAlreadyChecked()).toBe(expected);
-                expect(getItemMock).toHaveBeenCalledWith(EXPERIMENT_ALREADY_CHECKED_KEY);
-            });
-        });
-    });
-});

package/src/lib/shared/persistence/index-db-database-handler.ts

@@ -1,218 +0,0 @@
-/**
- * Represents the configuration for a database connection.
- * @interface
- */
-import {
-    EXPERIMENT_ALREADY_CHECKED_KEY,
-    EXPERIMENT_FETCH_EXPIRE_TIME_KEY,
-    LOCAL_STORAGE_TIME_DURATION_MILLISECONDS
-} from '../constants';
-
-/**
- * Represents the configuration for a database connection.
- * @interface
- */
-interface DbConfig {
-    db_name: string;
-    db_store: string;
-    db_key_path: string;
-}
-
-/**
- * The default version of the database.
- *
- * @type {number}
- * @constant
- */
-const DB_DEFAULT_VERSION = 1;
-
-/**
- * The `DatabaseHandler` class offers specific methods to store and get data
- * from IndexedDB.
- *
- * @example
- * // To fetch data from the IndexedDB
- * const data = await DatabaseHandler.getData();
- *
- * @example
- * // To store an object of type AssignedExperiments to IndexedDB
- * await DatabaseHandler.persistData(anAssignedExperiment);
- *
- * @example
- * // To get an object of type AssignedExperiments to IndexedDB
- * await DatabaseHandler.persistData(anAssignedExperiment);
- *
- */
-
-export class IndexDBDatabaseHandler {
-    constructor(private config: DbConfig) {
-        if (!config) {
-            throw new Error('Config is required');
-        }
-
-        const { db_name, db_store, db_key_path } = config;
-
-        if (!db_name) {
-            throw new Error("'db_name' is required in config");
-        }
-
-        if (!db_store) {
-            throw new Error("'db_store' is required in config");
-        }
-
-        if (!db_key_path) {
-            throw new Error("'db_key_path' is required in config");
-        }
-    }
-
-    /**
-     * Saves the provided data to indexDB.
-     *
-     * @async
-     * @param {AssignedExperiments} data - The data to be saved.
-     * @returns {Promise<any>} - The result of the save operation.
-     */
-    public async persistData<T>(data: T): Promise<IDBValidKey> {
-        const db = await this.openDB();
-
-        return await new Promise((resolve, reject) => {
-            const transaction = db.transaction([this.config.db_store], 'readwrite');
-
-            const store = transaction.objectStore(this.config.db_store);
-
-            const clearRequest = store.clear();
-
-            clearRequest.onerror = () => reject(clearRequest.error);
-            clearRequest.onsuccess = () => {
-                const request = store.put(data, this.config.db_key_path);
-
-                request.onsuccess = () => resolve(request.result);
-                request.onerror = () => reject(request.error);
-            };
-        });
-    }
-
-    /**
-     * Retrieves data from the database using a specific key.
-     *
-     * @async
-     * @returns {Promise<any>} A promise that resolves with the data retrieved from the database.
-     */
-    public async getData<T>(): Promise<T> {
-        const db = await this.openDB();
-
-        return await new Promise((resolve, reject) => {
-            const transaction = db.transaction([this.config.db_store], 'readonly');
-
-            const store = transaction.objectStore(this.config.db_store);
-
-            const request = store.get(this.config.db_key_path);
-
-            request.onsuccess = () => resolve(request.result as T);
-            request.onerror = () => reject(request.error);
-        });
-    }
-
-    /**
-     * Deletes all the data from the IndexedDB store.
-     *
-     * @async
-     * @returns {Promise<void>} - The result of the delete operation.
-     */
-    public async clearData(): Promise<void> {
-        const db = await this.openDB();
-
-        return await new Promise((resolve, reject) => {
-            const transaction = db.transaction([this.config.db_store], 'readwrite');
-
-            const store = transaction.objectStore(this.config.db_store);
-
-            const request = store.clear();
-
-            request.onsuccess = () => resolve();
-            request.onerror = () => reject(request.error);
-        });
-    }
-
-    /**
-     * Sets the flag indicating that the experiment has already been checked.
-     *
-     * @function setFlagExperimentAlreadyChecked
-     * @returns {void}
-     */
-    setFlagExperimentAlreadyChecked(): void {
-        sessionStorage.setItem(EXPERIMENT_ALREADY_CHECKED_KEY, 'true');
-    }
-
-    /**
-     * Sets the fetch expired time in the local storage.
-     *
-     * @return {void}
-     */
-    setFetchExpiredTime(): void {
-        const expireTime = Date.now() + LOCAL_STORAGE_TIME_DURATION_MILLISECONDS;
-
-        localStorage.setItem(EXPERIMENT_FETCH_EXPIRE_TIME_KEY, expireTime.toString());
-    }
-
-    /**
-     * Builds an error message based on the provided error object.
-     * @param {DOMException | null} error - The error object to build the message from.
-     * @returns {string} The constructed error message.
-     */
-    private getOnErrorMessage(error: DOMException | null): string {
-        let errorMessage =
-            'A database error occurred while using IndexedDB. Your browser may not support IndexedDB or IndexedDB might not be enabled.';
-
-        if (error) {
-            errorMessage += error.name ? ` Error Name: ${error.name}` : '';
-            errorMessage += error.message ? ` Error Message: ${error.message}` : '';
-            errorMessage += error.code ? ` Error Code: ${error.code}` : '';
-        }
-
-        return errorMessage;
-    }
-
-    /**
-     * Creates or opens a IndexedDB database with the specified version.
-     *
-     *
-     * @returns {Promise<IDBDatabase>} A promise that resolves to the opened database.
-     * The promise will be rejected with an error message if there was a database error.
-     */
-    private openDB(): Promise<IDBDatabase> {
-        return new Promise<IDBDatabase>((resolve, reject) => {
-            const request = indexedDB.open(this.config.db_name, DB_DEFAULT_VERSION);
-
-            request.onupgradeneeded = (event: IDBVersionChangeEvent) => {
-                const db = this.getRequestResult(event);
-
-                if (!db.objectStoreNames.contains(this.config.db_store)) {
-                    db.createObjectStore(this.config.db_store);
-                }
-            };
-
-            request.onerror = (event) => {
-                const errorMsj = this.getOnErrorMessage((event.target as IDBRequest).error);
-
-                reject(errorMsj);
-            };
-
-            request.onsuccess = (event: Event) => {
-                const db = this.getRequestResult(event);
-
-                resolve(db);
-            };
-        });
-    }
-
-    /**
-     * Retrieves the result of a database request from an Event object.
-     *
-     * @param {Event} event - The Event object containing the database request.
-     * @returns {IDBDatabase} - The result of the database request, casted as an IDBDatabase object.
-     */
-    private getRequestResult(event: Event): IDBDatabase {
-        return (event.target as IDBRequest).result as IDBDatabase;
-    }
-}

package/src/lib/shared/utils/DotLogger.ts

@@ -1,57 +0,0 @@
-/**
- * Logger for the dotCMS SDK
- */
-export class DotLogger {
-    private readonly isDebug: boolean;
-    private readonly packageName: string;
-
-    constructor(isDebug: boolean, packageName: string) {
-        this.isDebug = isDebug;
-        this.packageName = packageName;
-    }
-
-    public group(label: string) {
-        if (this.isDebug) {
-            // eslint-disable-next-line no-console
-            console.group(label);
-        }
-    }
-
-    public groupEnd() {
-        if (this.isDebug) {
-            // eslint-disable-next-line no-console
-            console.groupEnd();
-        }
-    }
-
-    public time(label: string) {
-        if (this.isDebug) {
-            // eslint-disable-next-line no-console
-            console.time(label);
-        }
-    }
-
-    public timeEnd(label: string) {
-        if (this.isDebug) {
-            // eslint-disable-next-line no-console
-            console.timeEnd(label);
-        }
-    }
-
-    public log(message: string) {
-        if (this.isDebug) {
-            // eslint-disable-next-line no-console
-            console.log(`[dotCMS ${this.packageName}] ${message}`);
-        }
-    }
-
-    public warn(message: string) {
-        if (this.isDebug) {
-            console.warn(`[dotCMS ${this.packageName}] ${message}`);
-        }
-    }
-
-    public error(message: string) {
-        console.error(`[dotCMS ${this.packageName}] ${message}`);
-    }
-}

package/src/lib/shared/utils/memoize.spec.ts

@@ -1,49 +0,0 @@
-import { renderHook } from '@testing-library/react-hooks';
-
-import { useMemoizedObject } from './memoize';
-
-describe('useMemoizedObject', () => {
-    it('should return the same object if it has not changed', () => {
-        const initialObject = { a: 1, b: 2 };
-
-        const { result, rerender } = renderHook(({ obj }) => useMemoizedObject(obj), {
-            initialProps: { obj: initialObject }
-        });
-
-        const firstRenderResult = result.current;
-
-        rerender({ obj: initialObject });
-        expect(result.current).toBe(firstRenderResult);
-    });
-
-    it('should return a new object if it has changed', () => {
-        const initialObject = { a: 1, b: 2 };
-
-        const newObject = { a: 1, b: 3 };
-
-        const { result, rerender } = renderHook(({ obj }) => useMemoizedObject(obj), {
-            initialProps: { obj: initialObject }
-        });
-
-        const firstRenderResult = result.current;
-
-        rerender({ obj: newObject });
-        expect(result.current).not.toBe(firstRenderResult);
-        expect(result.current).toBe(newObject);
-    });
-
-    it('should return the same object if a deeply equal but different reference is passed', () => {
-        const initialObject = { a: 1, b: 2 };
-
-        const newObject = { a: 1, b: 2 };
-
-        const { result, rerender } = renderHook(({ obj }) => useMemoizedObject(obj), {
-            initialProps: { obj: initialObject }
-        });
-
-        const firstRenderResult = result.current;
-
-        rerender({ obj: newObject });
-        expect(result.current).toBe(firstRenderResult);
-    });
-});

package/src/lib/shared/utils/memoize.ts

@@ -1,49 +0,0 @@
-import { useRef } from 'react';
-
-/**
- * Compares two objects and returns true if they are equal, false otherwise.
- * @param objA The first object to compare.
- * @param objB The second object to compare.
- * @returns
- */
-function shallowEqual<T>(objA: T, objB: T): boolean {
-    if (Object.is(objA, objB)) {
-        return true;
-    }
-
-    if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
-        return false;
-    }
-
-    const keysA = Object.keys(objA) as Array<keyof T>;
-
-    const keysB = Object.keys(objB) as Array<keyof T>;
-
-    if (keysA.length !== keysB.length) {
-        return false;
-    }
-
-    for (const key of keysA) {
-        if (!Object.prototype.hasOwnProperty.call(objB, key) || !Object.is(objA[key], objB[key])) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-/**
- * Memoizes an object and returns the memoized object.
- * Mantaing the same reference if the object is the same independently if is called inside any component.
- * @param object
- * @returns
- */
-export function useMemoizedObject<T extends object>(object: T): T {
-    const ref = useRef<T>(object);
-
-    if (!shallowEqual(ref.current, object)) {
-        ref.current = object;
-    }
-
-    return ref.current;
-}