@croct/sdk 0.13.0 → 0.15.0

package/src/contentFetcher.ts

@@ -3,6 +3,8 @@ import {EvaluationContext} from './evaluator';
 import {Token} from './token';
 import {BASE_ENDPOINT_URL, CLIENT_LIBRARY} from './constants';
 import {formatMessage} from './error';
+import {Logger, NullLogger} from './logging';
+import {ApiKey} from './apiKey';
 
 export type ErrorResponse = {
     type: string,
@@ -51,6 +53,10 @@ export type DynamicContentOptions = BasicOptions & {
     static?: false,
     clientId?: string,
     clientIp?: string,
+    clientAgent?: string,
+    /**
+     * @deprecated Use `clientAgent` instead. This option will be removed in future releases.
+     */
     userAgent?: string,
     userToken?: Token|string,
     previewToken?: Token|string,
@@ -71,25 +77,34 @@ export type FetchResponse<P extends JsonObject = JsonObject> = {
 
 export type Configuration = {
     appId?: string,
-    apiKey?: string,
+    apiKey?: string|ApiKey,
     baseEndpointUrl?: string,
+    logger?: Logger,
+};
+
+type InternalConfiguration = {
+    appId?: string,
+    apiKey?: ApiKey,
 };
 
 export class ContentFetcher {
-    private readonly configuration: Configuration;
+    private readonly configuration: InternalConfiguration;
 
     private readonly dynamicEndpoint: string;
 
     private readonly staticEndpoint: string;
 
+    private readonly logger: Logger;
+
     public constructor(configuration: Configuration) {
         if ((configuration.appId === undefined) === (configuration.apiKey === undefined)) {
             throw new Error('Either the application ID or the API key must be provided.');
         }
 
-        this.configuration = configuration;
-
-        const {apiKey, baseEndpointUrl} = this.configuration;
+        const {baseEndpointUrl} = configuration;
+        const apiKey = configuration.apiKey !== undefined
+            ? ApiKey.from(configuration.apiKey)
+            : undefined;
 
         // eslint-disable-next-line prefer-template -- Better readability
         const baseEndpoint = (baseEndpointUrl ?? BASE_ENDPOINT_URL).replace(/\/+$/, '')
@@ -98,6 +113,11 @@ export class ContentFetcher {
 
         this.dynamicEndpoint = `${baseEndpoint}/content`;
         this.staticEndpoint = `${baseEndpoint}/static-content`;
+        this.logger = configuration.logger ?? new NullLogger();
+        this.configuration = {
+            appId: configuration.appId,
+            apiKey: apiKey,
+        };
     }
 
     public fetch<P extends JsonObject>(slotId: string, options: FetchOptions = {}): Promise<FetchResponse<P>> {
@@ -173,7 +193,7 @@ export class ContentFetcher {
         }
 
         if (apiKey !== undefined) {
-            headers['X-Api-Key'] = apiKey;
+            headers['X-Api-Key'] = apiKey.getIdentifier();
         }
 
         const payload: FetchPayload = {
@@ -191,6 +211,15 @@ export class ContentFetcher {
         const dynamic = ContentFetcher.isDynamicContent(options);
 
         if (dynamic) {
+            if (options.userAgent !== undefined) {
+                this.logger.warn(
+                    'The `userAgent` option is deprecated and '
+                    + 'will be removed in future releases. '
+                    + 'Please update the part of your code calling the `fetch` method '
+                    + 'to use the `clientAgent` option instead.',
+                );
+            }
+
             if (options.clientId !== undefined) {
                 headers['X-Client-Id'] = options.clientId;
             }
@@ -203,8 +232,10 @@ export class ContentFetcher {
                 headers['X-Token'] = options.userToken.toString();
             }
 
-            if (options.userAgent !== undefined) {
-                headers['User-Agent'] = options.userAgent;
+            const clientAgent = options.clientAgent ?? options.userAgent;
+
+            if (clientAgent !== undefined) {
+                headers['X-Client-Agent'] = clientAgent;
             }
 
             if (options.context !== undefined) {

package/src/context.ts

@@ -3,7 +3,7 @@ import {Tab, UrlSanitizer} from './tab';
 import {uuid4} from './uuid';
 import {EventDispatcher} from './eventManager';
 import {SdkEventMap} from './sdkEvents';
-import {LocalStorageCache} from './cache';
+import {Cache, ObservableCache} from './cache';
 
 export type TokenScope = 'isolated' | 'global' | 'contextual';
 
@@ -12,9 +12,9 @@ export type Configuration = {
     urlSanitizer?: UrlSanitizer,
     eventDispatcher: ContextEventDispatcher,
     cache: {
-        tabId: LocalStorageCache,
-        tabToken: LocalStorageCache,
-        browserToken: LocalStorageCache,
+        tabId: Cache,
+        tabToken: Cache,
+        browserToken: Cache,
     },
 };
 
@@ -63,7 +63,9 @@ export class Context {
             case 'global': {
                 const context = new Context(tab, new CachedTokenStore(cache.browserToken), eventDispatcher);
 
-                cache.browserToken.addListener(context.syncToken);
+                if (ObservableCache.isObservable(cache.browserToken)) {
+                    cache.browserToken.addListener(context.syncToken);
+                }
 
                 return context;
             }

package/src/evaluator.ts

@@ -3,6 +3,8 @@ import {Token} from './token';
 import {BASE_ENDPOINT_URL, CLIENT_LIBRARY, MAX_QUERY_LENGTH} from './constants';
 import {formatMessage} from './error';
 import {getLength, getLocation, Location} from './sourceLocation';
+import {Logger, NullLogger} from './logging';
+import {ApiKey} from './apiKey';
 
 export type Campaign = {
     name?: string,
@@ -34,6 +36,10 @@ type ExtraFetchOptions<T extends keyof RequestInit = AllowedFetchOptions> = Pick
 export type EvaluationOptions = {
     clientId?: string,
     clientIp?: string,
+    clientAgent?: string,
+    /**
+     * @deprecated Use `clientAgent` instead. This option will be removed in future releases.
+     */
     userAgent?: string,
     userToken?: Token|string,
     timeout?: number,
@@ -89,30 +95,44 @@ export class QueryError extends EvaluationError<QueryErrorResponse> {
 
 export type Configuration = {
     appId?: string,
-    apiKey?: string,
+    apiKey?: string|ApiKey,
     baseEndpointUrl?: string,
+    logger?: Logger,
+};
+
+type InternalConfiguration = {
+    appId?: string,
+    apiKey?: ApiKey,
 };
 
 export class Evaluator {
     public static readonly MAX_QUERY_LENGTH = MAX_QUERY_LENGTH;
 
-    private readonly configuration: Configuration;
+    private readonly configuration: InternalConfiguration;
 
     private readonly endpoint: string;
 
+    private readonly logger: Logger;
+
     public constructor(configuration: Configuration) {
         if ((configuration.appId === undefined) === (configuration.apiKey === undefined)) {
             throw new Error('Either the application ID or the API key must be provided.');
         }
 
-        const {baseEndpointUrl, apiKey} = configuration;
+        const {baseEndpointUrl} = configuration;
+        const apiKey = configuration.apiKey !== undefined
+            ? ApiKey.from(configuration.apiKey)
+            : undefined;
 
         // eslint-disable-next-line prefer-template -- Better readability
         this.endpoint = (baseEndpointUrl ?? BASE_ENDPOINT_URL).replace(/\/+$/, '')
             + (apiKey === undefined ? '/client' : '/external')
             + '/web/evaluate';
-
-        this.configuration = configuration;
+        this.logger = configuration.logger ?? new NullLogger();
+        this.configuration = {
+            appId: configuration.appId,
+            apiKey: apiKey,
+        };
     }
 
     public evaluate(query: string, options: EvaluationOptions = {}): Promise<JsonValue> {
@@ -215,7 +235,17 @@ export class Evaluator {
 
     private fetch(body: JsonObject, signal: AbortSignal, options: EvaluationOptions): Promise<Response> {
         const {appId, apiKey} = this.configuration;
-        const {clientId, clientIp, userAgent, userToken} = options;
+        const {clientId, clientIp, userToken} = options;
+        const clientAgent = options.clientAgent ?? options.userAgent;
+
+        if (options.userAgent !== undefined) {
+            this.logger.warn(
+                'The `userAgent` option is deprecated and '
+                + 'will be removed in future releases. '
+                + 'Please update the part of your code calling the `evaluate` method '
+                + 'to use the `clientAgent` option instead.',
+            );
+        }
 
         const headers: Record<string, string> = {
             'Content-Type': 'application/json',
@@ -224,7 +254,7 @@ export class Evaluator {
         headers['X-Client-Library'] = CLIENT_LIBRARY;
 
         if (apiKey !== undefined) {
-            headers['X-Api-Key'] = apiKey;
+            headers['X-Api-Key'] = apiKey.getIdentifier();
         } else if (appId !== undefined) {
             headers['X-App-Id'] = appId;
         }
@@ -241,8 +271,8 @@ export class Evaluator {
             headers['X-Token'] = userToken.toString();
         }
 
-        if (userAgent !== undefined) {
-            headers['User-Agent'] = userAgent;
+        if (clientAgent !== undefined) {
+            headers['X-Client-Agent'] = clientAgent;
         }
 
         return fetch(this.endpoint, {

package/src/eventSubjectProcessor.ts

@@ -0,0 +1,85 @@
+import {QueuedEventInfo, TrackingEventProcessor} from './tracker';
+import {Token} from './token';
+import {Logger} from './logging';
+import {TrackingEvent} from './trackingEvents';
+
+export class EventSubjectProcessor implements TrackingEventProcessor {
+    private currentToken?: Token|null;
+
+    private logger: Logger;
+
+    public constructor(logger: Logger) {
+        this.logger = logger;
+    }
+
+    public process(event: QueuedEventInfo): QueuedEventInfo[] {
+        const {currentToken} = this;
+
+        this.currentToken = event.userToken ?? null;
+
+        if (currentToken === undefined) {
+            // This is the first event, no subject to compare.
+            // If the user is already identified at this point,
+            // assume that the event was previously tracked.
+            return [event];
+        }
+
+        if (EventSubjectProcessor.isIdentificationEvent(event.event)) {
+            return [event];
+        }
+
+        const currentSubject = currentToken?.getSubject() ?? null;
+        const newSubject = event.userToken?.getSubject() ?? null;
+
+        if (newSubject === currentSubject) {
+            // No change in subject
+            return [event];
+        }
+
+        const events: QueuedEventInfo[] = [];
+
+        if (currentToken !== null && currentSubject !== null) {
+            this.logger.info('External user sign out automatically tracked');
+
+            events.push({
+                timestamp: event.timestamp,
+                context: event.context,
+                userToken: currentToken,
+                event: {
+                    type: 'userSignedOut',
+                    userId: currentSubject,
+                },
+            });
+        }
+
+        if (newSubject !== null) {
+            this.logger.info('External user sign in automatically tracked');
+
+            events.push({
+                timestamp: event.timestamp,
+                context: event.context,
+                userToken: event.userToken,
+                event: {
+                    type: 'userSignedIn',
+                    userId: newSubject,
+                },
+            });
+        }
+
+        events.push(event);
+
+        return events;
+    }
+
+    private static isIdentificationEvent(event: TrackingEvent): boolean {
+        switch (event.type) {
+            case 'userSignedIn':
+            case 'userSignedUp':
+            case 'userSignedOut':
+                return true;
+
+            default:
+                return false;
+        }
+    }
+}

package/src/facade/contentFetcherFacade.ts

@@ -21,7 +21,11 @@ function validate(options: unknown): asserts options is FetchOptions {
     }
 }
 
-export type Configuration = {
+type Options = {
+    preferredLocale?: string,
+};
+
+export type Configuration = Options & {
     contentFetcher: ContentFetcher,
     contextFactory: ContextFactory,
     previewTokenProvider: TokenProvider,
@@ -40,12 +44,17 @@ export class ContentFetcherFacade {
 
     private readonly cidAssigner: CidAssigner;
 
+    private readonly options: Options;
+
     public constructor(configuration: Configuration) {
         this.fetcher = configuration.contentFetcher;
         this.previewTokenProvider = configuration.previewTokenProvider;
         this.userTokenProvider = configuration.userTokenProvider;
         this.cidAssigner = configuration.cidAssigner;
         this.contextFactory = configuration.contextFactory;
+        this.options = {
+            preferredLocale: configuration.preferredLocale,
+        };
     }
 
     public async fetch<P extends JsonObject>(slotId: string, options: FetchOptions = {}): Promise<FetchResponse<P>> {
@@ -61,9 +70,9 @@ export class ContentFetcherFacade {
             userToken: this.userTokenProvider.getToken() ?? undefined,
             previewToken: this.previewTokenProvider.getToken() ?? undefined,
             version: options.version,
-            preferredLocale: options.preferredLocale,
             context: this.contextFactory.createContext(options.attributes),
             timeout: options.timeout,
+            preferredLocale: options.preferredLocale ?? this.options.preferredLocale,
         });
     }
 }

package/src/facade/sdkFacade.ts

@@ -14,8 +14,14 @@ import {CidAssigner} from '../cid';
 import {PartialTrackingEvent} from '../trackingEvents';
 import {UrlSanitizer} from '../tab';
 import {ContentFetcherFacade} from './contentFetcherFacade';
+import {CookieCacheConfiguration} from '../cache/cookieCache';
+import {EventSubjectProcessor} from '../eventSubjectProcessor';
 
-export type Configuration = {
+type Options = {
+    preferredLocale?: string,
+};
+
+export type Configuration = Options & {
     appId: string,
     tokenScope?: TokenScope,
     debug?: boolean,
@@ -30,6 +36,10 @@ export type Configuration = {
     baseEndpointUrl?: string,
     disableCidMirroring?: boolean,
     cidAssignerEndpointUrl?: string,
+    cookie?: {
+        clientId?: CookieCacheConfiguration,
+        userToken?: CookieCacheConfiguration,
+    },
 };
 
 function validateConfiguration(configuration: unknown): asserts configuration is Configuration {
@@ -53,14 +63,17 @@ export class SdkFacade {
 
     private contentFetcherFacade?: ContentFetcherFacade;
 
-    private constructor(sdk: Sdk) {
+    private readonly options: Options;
+
+    private constructor(sdk: Sdk, options: Options = {}) {
         this.sdk = sdk;
+        this.options = options;
     }
 
     public static init(configuration: Configuration): SdkFacade {
         validateConfiguration(configuration);
 
-        const {track = true, userId, token, ...containerConfiguration} = configuration;
+        const {track = true, userId, token, preferredLocale, ...containerConfiguration} = configuration;
 
         if (userId !== undefined && token !== undefined) {
             throw new Error('Either the user ID or token can be specified, but not both.');
@@ -73,7 +86,11 @@ export class SdkFacade {
                 debug: containerConfiguration.debug ?? false,
                 test: containerConfiguration.test ?? false,
                 disableCidMirroring: containerConfiguration.disableCidMirroring ?? false,
+                eventProcessor: container => new EventSubjectProcessor(container.getLogger('EventSubjectProcessor')),
             }),
+            {
+                preferredLocale: preferredLocale,
+            },
         );
 
         if (userId !== undefined) {
@@ -166,6 +183,7 @@ export class SdkFacade {
                 cidAssigner: this.sdk.cidAssigner,
                 previewTokenProvider: this.sdk.previewTokenStore,
                 userTokenProvider: this.sdk.userTokenStore,
+                preferredLocale: this.options.preferredLocale,
             });
         }
 

package/src/schema/sdkFacadeSchemas.ts

@@ -1,6 +1,6 @@
 import {ObjectType, StringType, BooleanType, UnionType, NullType, FunctionType} from '../validation';
 import {tokenScopeSchema} from './contextSchemas';
-import {eventMetadataSchema} from './sdkSchemas';
+import {cookieOptionsSchema, eventMetadataSchema} from './sdkSchemas';
 import {loggerSchema} from './loggerSchema';
 
 export const sdkFacadeConfigurationSchema = new ObjectType({
@@ -38,5 +38,14 @@ export const sdkFacadeConfigurationSchema = new ObjectType({
         cidAssignerEndpointUrl: new StringType({
             format: 'url',
         }),
+        cookie: new ObjectType({
+            properties: {
+                clientId: cookieOptionsSchema,
+                userToken: cookieOptionsSchema,
+            },
+        }),
+        preferredLocale: new StringType({
+            pattern: /^[a-z]{2,3}([-_][a-z]{2,3})?$/i,
+        }),
     },
 });

package/src/schema/sdkSchemas.ts

@@ -14,6 +14,29 @@ export const eventMetadataSchema = new ObjectType({
     }),
 });
 
+export const cookieOptionsSchema = new ObjectType({
+    required: ['name'],
+    properties: {
+        name: new StringType({
+            minLength: 1,
+        }),
+        domain: new StringType({
+            minLength: 1,
+        }),
+        path: new StringType({
+            minLength: 1,
+        }),
+        secure: new BooleanType(),
+        sameSite: new StringType({
+            enumeration: ['strict', 'lax', 'none'],
+        }),
+        maxAge: new NumberType({
+            minimum: 0,
+            integer: true,
+        }),
+    },
+});
+
 export const sdkConfigurationSchema = new ObjectType({
     required: ['appId', 'tokenScope', 'disableCidMirroring', 'debug', 'test'],
     properties: {
@@ -35,10 +58,17 @@ export const sdkConfigurationSchema = new ObjectType({
             integer: true,
         }),
         disableCidMirroring: new BooleanType(),
+        cookie: new ObjectType({
+            properties: {
+                clientId: cookieOptionsSchema,
+                userToken: cookieOptionsSchema,
+            },
+        }),
         debug: new BooleanType(),
         test: new BooleanType(),
         logger: loggerSchema,
         urlSanitizer: new FunctionType(),
         eventMetadata: eventMetadataSchema,
+        eventProcessor: new FunctionType(),
     },
 });

package/src/sdk.ts

@@ -1,10 +1,10 @@
-import {Container} from './container';
+import {Container, DependencyResolver} from './container';
 import {Context, TokenScope} from './context';
 import {Logger} from './logging';
 import {BASE_ENDPOINT_URL, VERSION} from './constants';
 import {sdkConfigurationSchema} from './schema';
 import {formatCause} from './error';
-import {Tracker} from './tracker';
+import {Tracker, TrackingEventProcessor} from './tracker';
 import {Evaluator} from './evaluator';
 import {SdkEventMap} from './sdkEvents';
 import {EventManager} from './eventManager';
@@ -12,6 +12,7 @@ import {CidAssigner} from './cid';
 import {UrlSanitizer} from './tab';
 import {ContentFetcher} from './contentFetcher';
 import {TokenStore} from './token';
+import {CookieCacheConfiguration} from './cache/cookieCache';
 
 export type Configuration = {
     appId: string,
@@ -26,6 +27,11 @@ export type Configuration = {
     urlSanitizer?: UrlSanitizer,
     logger?: Logger,
     eventMetadata?: {[key: string]: string},
+    cookie?: {
+        clientId?: CookieCacheConfiguration,
+        userToken?: CookieCacheConfiguration,
+    },
+    eventProcessor?: DependencyResolver<TrackingEventProcessor>,
 };
 
 function validateConfiguration(configuration: unknown): asserts configuration is Configuration {
@@ -53,7 +59,6 @@ export class Sdk {
         validateConfiguration(configuration);
 
         const {
-            disableCidMirroring,
             eventMetadata: customMetadata = {},
             baseEndpointUrl = BASE_ENDPOINT_URL,
             cidAssignerEndpointUrl,
@@ -73,7 +78,6 @@ export class Sdk {
 
         const container = new Container({
             ...containerConfiguration,
-            disableCidMirroring: disableCidMirroring,
             evaluationBaseEndpointUrl: baseHttpEndpoint,
             contentBaseEndpointUrl: baseHttpEndpoint,
             trackerEndpointUrl: `${baseWsEndpoint}/client/web/connect`,