feat: set server side cookies

packages/analytics-js-common/src/types/LoadOptions.ts

@@ -149,8 +149,8 @@ export type LoadOptions = {
   consentManagement?: ConsentManagementOptions;
   sameDomainCookiesOnly?: boolean;
   externalAnonymousIdCookieName?: string;
-  useServerSideCookie?: boolean;
-  cookieServerUrl?: string;
+  useServerSideCookies?: boolean;
+  dataServerUrl?: string;
 };
 
 export type ConsentOptions = {

packages/analytics-js-common/src/types/Source.ts

@@ -18,4 +18,5 @@ export type Source = {
   id: string;
   config?: SourceConfig;
   dataplanes?: Record<ResidencyServerRegion, RegionDetails[]>;
+  workspaceId: string;
 };

packages/analytics-js/.size-limit.js

@@ -26,6 +26,6 @@ module.exports = [
   {
     name: 'Core - CDN',
     path: 'dist/cdn/modern/iife/rsa.min.js',
-    limit: '23 KiB',
+    limit: '23.5 KiB',
   },
 ];

packages/analytics-js/__fixtures__/msw.handlers.ts

@@ -77,7 +77,7 @@ const handlers = [
       },
     });
   }),
-  http.post(`${dummyDataplaneHost}/setCookie`, () => {
+  http.post(`${dummyDataplaneHost}/rsaRequest`, () => {
     return new HttpResponse(null, {
       status: 200,
       headers: {

packages/analytics-js/__tests__/components/configManager/ConfigManager.test.ts

@@ -174,6 +174,7 @@ describe('ConfigManager', () => {
     const expectedSourceState = {
       id: dummySourceConfigResponse.source.id,
       config: dummySourceConfigResponse.source.config,
+      workspaceId: dummySourceConfigResponse.source.workspaceId,
     };
     state.lifecycle.dataPlaneUrl.value = sampleDataPlaneUrl;
 

packages/analytics-js/__tests__/components/userSessionManager/UserSessionManager.test.ts

@@ -1374,12 +1374,12 @@ describe('User session manager', () => {
   });
 
   describe('getExternalAnonymousIdByCookieName', () => {
-    it('Should return null if the cookie value does not exists', () => {
+    it('should return null if the cookie value does not exists', () => {
       const externalAnonymousId =
         userSessionManager.getExternalAnonymousIdByCookieName('anonId_cookie');
       expect(externalAnonymousId).toEqual(null);
     });
-    it('Should return the cookie value if exists', () => {
+    it('should return the cookie value if exists', () => {
       document.cookie = 'anonId_cookie=sampleAnonymousId12345';
       const externalAnonymousId =
         userSessionManager.getExternalAnonymousIdByCookieName('anonId_cookie');
@@ -1388,12 +1388,21 @@ describe('User session manager', () => {
   });
 
   describe('syncValueToStorage', () => {
-    it('Should call setServerSideCookie method in case useServerSideCookie load option is set to true', () => {
-      state.loadOptions.value.useServerSideCookie = true;
+    it('should not call setServerSideCookie method in case useServerSideCookies load option is not set', () => {
       state.storage.entries.value = entriesWithOnlyCookieStorage;
       const spy = jest.spyOn(userSessionManager, 'setServerSideCookie');
       userSessionManager.syncValueToStorage('anonymousId', 'dummy_anonymousId');
-      expect(spy).toHaveBeenCalledWith('rl_anonymous_id', '"dummy_anonymousId"');
+      expect(spy).not.toHaveBeenCalled();
+    });
+    it('should call setServerSideCookie method in case useServerSideCookies load option is set to true', () => {
+      state.loadOptions.value.useServerSideCookies = true;
+      state.storage.entries.value = entriesWithOnlyCookieStorage;
+      const spy = jest.spyOn(userSessionManager, 'setServerSideCookie');
+      userSessionManager.syncValueToStorage('anonymousId', 'dummy_anonymousId');
+      expect(spy).toHaveBeenCalledWith(
+        [{ name: 'rl_anonymous_id', value: 'dummy_anonymousId' }],
+        expect.any(Object),
+      );
     });
   });
 
@@ -1405,61 +1414,95 @@ describe('User session manager', () => {
     afterAll(() => {
       server.close();
     });
-    it('Should make external request to exposed endpoint', () => {
+    const mockCookieStore = {
+      encrypt: jest.fn(val => `encrypted_${JSON.parse(val)}`),
+      set: jest.fn(),
+    };
+    it('should make external request to exposed endpoint', () => {
       state.lifecycle.activeDataplaneUrl.value = 'https://dummy.dataplane.host.com';
+      state.source.value = { workspaceId: 'sample_workspaceId' };
       state.storage.cookie.value = {
         maxage: 10 * 60 * 1000, // 10 min
         path: '/',
         domain: 'example.com',
         samesite: 'Lax',
       };
       const spy = jest.spyOn(defaultHttpClient, 'getAsyncData');
-      userSessionManager.setServerSideCookie('key', 'sample_cookie_value_1234');
+      userSessionManager.setServerSideCookie(
+        [{ name: 'key', value: 'sample_cookie_value_1234' }],
+        mockCookieStore,
+      );
       expect(spy).toHaveBeenCalledWith({
-        url: `https://dummy.dataplane.host.com/setCookie`,
+        url: `https://dummy.dataplane.host.com/rsaRequest`,
         options: {
           method: 'POST',
           data: JSON.stringify({
-            key: 'key',
-            value: 'sample_cookie_value_1234',
-            options: {
-              maxage: 10 * 60 * 1000,
-              path: '/',
-              domain: 'example.com',
-              samesite: 'Lax',
+            reqType: 'setCookies',
+            workspaceId: 'sample_workspaceId',
+            data: {
+              options: {
+                maxAge: 10 * 60 * 1000,
+                path: '/',
+                domain: 'example.com',
+                sameSite: 'Lax',
+                secure: undefined,
+              },
+              cookies: [
+                {
+                  name: 'key',
+                  value: 'encrypted_sample_cookie_value_1234',
+                },
+              ],
             },
           }),
           sendRawData: true,
         },
+        isRawResponse: true,
+        callback: expect.any(Function),
       });
     });
-    it('Should use provided server url to make external request for setting cookie', () => {
+    it('should use provided server url to make external request for setting cookie', () => {
       state.lifecycle.activeDataplaneUrl.value = 'https://dummy.dataplane.host.com';
-      state.loadOptions.value.cookieServerUrl = 'https://example.com';
+      state.source.value = { workspaceId: 'sample_workspaceId' };
+      state.loadOptions.value.dataServerUrl = 'https://example.com';
       state.storage.cookie.value = {
         maxage: 10 * 60 * 1000, // 10 min
         path: '/',
         domain: 'example.com',
         samesite: 'Lax',
       };
       const spy = jest.spyOn(defaultHttpClient, 'getAsyncData');
-      userSessionManager.setServerSideCookie('key', 'sample_cookie_value_1234');
+      userSessionManager.setServerSideCookie(
+        [{ name: 'key', value: 'sample_cookie_value_1234' }],
+        mockCookieStore,
+      );
       expect(spy).toHaveBeenCalledWith({
-        url: `https://example.com/setCookie`,
+        url: `https://example.com/rsaRequest`,
         options: {
           method: 'POST',
           data: JSON.stringify({
-            key: 'key',
-            value: 'sample_cookie_value_1234',
-            options: {
-              maxage: 10 * 60 * 1000,
-              path: '/',
-              domain: 'example.com',
-              samesite: 'Lax',
+            reqType: 'setCookies',
+            workspaceId: 'sample_workspaceId',
+            data: {
+              options: {
+                maxAge: 10 * 60 * 1000,
+                path: '/',
+                domain: 'example.com',
+                sameSite: 'Lax',
+                secure: undefined,
+              },
+              cookies: [
+                {
+                  name: 'key',
+                  value: 'encrypted_sample_cookie_value_1234',
+                },
+              ],
             },
           }),
           sendRawData: true,
         },
+        isRawResponse: true,
+        callback: expect.any(Function),
       });
     });
   });

packages/analytics-js/public/index.html

@@ -79,7 +79,7 @@
         configUrl: '__CONFIG_SERVER_HOST__',
         destSDKBaseURL:
           '__DEST_SDK_BASE_URL__' + window.rudderAnalyticsBuildType + '/js-integrations',
-        // pluginsSDKBaseURL: '__PLUGINS_BASE_URL__' + window.rudderAnalyticsBuildType + '/plugins',
+        pluginsSDKBaseURL: '__PLUGINS_BASE_URL__' + window.rudderAnalyticsBuildType + '/plugins',
         // useServerSideCookie:true,        
         // queueOptions: {
         //   batch: {

packages/analytics-js/src/components/configManager/ConfigManager.ts

@@ -9,7 +9,11 @@
 import type { Destination } from '@rudderstack/analytics-js-common/types/Destination';
 import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
 import { CONFIG_MANAGER } from '@rudderstack/analytics-js-common/constants/loggerContexts';
-import { isValidSourceConfig, validateLoadArgs } from './util/validate';
+import {
+  isValidSourceConfig,
+  validateLoadArgs,
+  validateAndReturnCookieServerUrl,
+} from './util/validate';
 import {
   DATA_PLANE_URL_ERROR,
   SOURCE_CONFIG_FETCH_ERROR,
@@ -91,6 +95,13 @@
         lockIntegrationsVersion,
         this.logger,
       );
+      if (state.loadOptions.value.dataServerUrl) {
+        state.loadOptions.value.dataServerUrl = validateAndReturnCookieServerUrl(
+          state.loadOptions.value.useServerSideCookies,
+          state.loadOptions.value.dataServerUrl,
+          this.logger,
+        );
+      }
     });
 
     this.getConfig();
@@ -160,6 +171,7 @@
       state.source.value = {
         config: res.source.config,
         id: res.source.id,
+        workspaceId: res.source.workspaceId,
       };
 
       // set device mode destination related information in state

packages/analytics-js/src/components/configManager/util/validate.ts

@@ -4,9 +4,11 @@
   SUPPORTED_STORAGE_TYPES,
   type StorageType,
 } from '@rudderstack/analytics-js-common/types/Storage';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
 import {
   WRITE_KEY_VALIDATION_ERROR,
   DATA_PLANE_URL_VALIDATION_ERROR,
+  COOKIE_SERVER_URL_INVALID_ERROR,
 } from '../../../constants/logMessages';
 import { isValidUrl } from '../../utilities/url';
 
@@ -37,10 +39,25 @@
 const isValidStorageType = (storageType?: StorageType): boolean =>
   typeof storageType === 'string' && SUPPORTED_STORAGE_TYPES.includes(storageType);
 
+const validateAndReturnCookieServerUrl = (
+  useServerSideCookies?: boolean,
+  dataServerUrl?: string,
+  logger?: ILogger,
+) => {
+  if (useServerSideCookies && dataServerUrl) {
+    if (isValidUrl(dataServerUrl)) {
+      return dataServerUrl;
+    }
+    logger?.error(COOKIE_SERVER_URL_INVALID_ERROR('dataServerUrl'));
+  }
+  return 'invalid';
+};
+
 export {
   validateLoadArgs,
   isValidSourceConfig,
   isValidStorageType,
   validateWriteKey,
   validateDataPlaneUrl,
+  validateAndReturnCookieServerUrl,
 };