@croct/sdk 0.9.1 → 0.11.0-alpha

package/container.js

@@ -1,82 +1,102 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Container = void 0;
-var tslib_1 = require("tslib");
-var logging_1 = require("./logging");
-var context_1 = require("./context");
-var namespacedStorage_1 = require("./namespacedStorage");
-var retry_1 = require("./retry");
-var queue_1 = require("./queue");
-var tracker_1 = require("./tracker");
-var evaluator_1 = require("./evaluator");
-var transformer_1 = require("./transformer");
-var cid_1 = require("./cid");
-var eventManager_1 = require("./eventManager");
-var cache_1 = require("./cache");
-var guaranteedChannel_1 = require("./channel/guaranteedChannel");
-var channel_1 = require("./channel");
-var Container = /** @class */ (function () {
-    function Container(configuration) {
+const logging_1 = require("./logging");
+const context_1 = require("./context");
+const namespacedStorage_1 = require("./namespacedStorage");
+const retry_1 = require("./retry");
+const queue_1 = require("./queue");
+const token_1 = require("./token");
+const tracker_1 = require("./tracker");
+const evaluator_1 = require("./evaluator");
+const transformer_1 = require("./transformer");
+const cid_1 = require("./cid");
+const eventManager_1 = require("./eventManager");
+const cache_1 = require("./cache");
+const guaranteedChannel_1 = require("./channel/guaranteedChannel");
+const channel_1 = require("./channel");
+const contentFetcher_1 = require("./contentFetcher");
+class Container {
+    constructor(configuration) {
         this.eventManager = new eventManager_1.SynchronousEventManager();
         this.configuration = configuration;
     }
-    Container.prototype.getConfiguration = function () {
+    getConfiguration() {
         return this.configuration;
-    };
-    Container.prototype.getEvaluator = function () {
+    }
+    getEvaluator() {
         if (this.evaluator === undefined) {
             this.evaluator = this.createEvaluator();
         }
         return this.evaluator;
-    };
-    Container.prototype.createEvaluator = function () {
+    }
+    createEvaluator() {
         return new evaluator_1.Evaluator({
             appId: this.configuration.appId,
             endpointUrl: this.configuration.evaluationEndpointUrl,
-            tokenProvider: this.getTokenProvider(),
-            cidAssigner: this.getCidAssigner(),
         });
-    };
-    Container.prototype.getTracker = function () {
+    }
+    getContentFetcher() {
+        if (this.contentFetcher === undefined) {
+            this.contentFetcher = this.createContentFetcher();
+        }
+        return this.contentFetcher;
+    }
+    createContentFetcher() {
+        return new contentFetcher_1.ContentFetcher({
+            appId: this.configuration.appId,
+            endpointUrl: this.configuration.contentEndpointUrl,
+        });
+    }
+    getPreviewTokenStore() {
+        if (this.previewTokenStore === undefined) {
+            this.previewTokenStore = new token_1.CachedTokenStore(new cache_1.LocalStorageCache(this.getGlobalBrowserStorage('preview'), 'token'));
+        }
+        return this.previewTokenStore;
+    }
+    getTracker() {
         if (this.tracker === undefined) {
             this.tracker = this.createTracker();
         }
         return this.tracker;
-    };
-    Container.prototype.createTracker = function () {
-        var context = this.getContext();
-        var tracker = new tracker_1.Tracker({
+    }
+    createTracker() {
+        const context = this.getContext();
+        const tracker = new tracker_1.Tracker({
             tab: context.getTab(),
-            tokenProvider: this.getTokenProvider(),
+            tokenProvider: this.getUserTokenStore(),
             inactivityRetryPolicy: new retry_1.ArbitraryPolicy([30000, 30000, 120000, 120000, 300000, 300000, 900000]),
             logger: this.getLogger('Tracker'),
             channel: this.getBeaconChannel(),
-            eventMetadata: this.configuration.eventMetadata || {},
+            eventMetadata: this.configuration.eventMetadata,
         });
-        var queue = this.getBeaconQueue();
+        const queue = this.getBeaconQueue();
         queue.addCallback('halfEmpty', tracker.unsuspend);
         queue.addCallback('full', tracker.suspend);
         return tracker;
-    };
-    Container.prototype.getTokenProvider = function () {
-        if (this.tokenProvider === undefined) {
-            var context = this.getContext();
-            this.tokenProvider = { getToken: context.getToken.bind(context) };
-        }
-        return this.tokenProvider;
-    };
-    Container.prototype.getContext = function () {
+    }
+    getUserTokenStore() {
+        if (this.userTokenProvider === undefined) {
+            const context = this.getContext();
+            this.userTokenProvider = {
+                getToken: context.getToken.bind(context),
+                setToken: context.setToken.bind(context),
+            };
+        }
+        return this.userTokenProvider;
+    }
+    getContext() {
         if (this.context === undefined) {
             this.context = this.createContext();
         }
         return this.context;
-    };
-    Container.prototype.createContext = function () {
-        var tokenKey = this.resolveStorageNamespace('token');
-        var tabKey = this.resolveStorageNamespace('tab');
-        var browserStorage = this.getLocalStorage();
-        var browserCache = new cache_1.LocalStorageCache(browserStorage, tokenKey);
-        var tabStorage = this.getSessionStorage();
+    }
+    createContext() {
+        const tokenKey = this.resolveStorageNamespace('token');
+        const tabKey = this.resolveStorageNamespace('tab');
+        const browserStorage = this.getLocalStorage();
+        const browserCache = new cache_1.LocalStorageCache(browserStorage, tokenKey);
+        const tabStorage = this.getSessionStorage();
         this.removeTokenSyncListener = cache_1.LocalStorageCache.autoSync(browserCache);
         return context_1.Context.load({
             tokenScope: this.configuration.tokenScope,
@@ -88,27 +108,27 @@ var Container = /** @class */ (function () {
                 browserToken: browserCache,
             },
         });
-    };
-    Container.prototype.getBeaconChannel = function () {
+    }
+    getBeaconChannel() {
         if (this.beaconChannel === undefined) {
             this.beaconChannel = this.createBeaconChannel();
         }
         return this.beaconChannel;
-    };
-    Container.prototype.createBeaconChannel = function () {
+    }
+    createBeaconChannel() {
         if (this.configuration.test) {
             return new channel_1.SandboxChannel();
         }
-        var channelLogger = this.getLogger('BeaconChannel');
-        var _a = this.configuration, appId = _a.appId, trackerEndpointUrl = _a.trackerEndpointUrl;
-        var queuedChannel = new channel_1.QueuedChannel(new channel_1.RetryChannel({
+        const channelLogger = this.getLogger('BeaconChannel');
+        const { appId, trackerEndpointUrl } = this.configuration;
+        const queuedChannel = new channel_1.QueuedChannel(new channel_1.RetryChannel({
             channel: new channel_1.GuaranteedChannel({
                 channel: new channel_1.BeaconSocketChannel({
-                    trackerEndpointUrl: "".concat(trackerEndpointUrl, "/").concat(appId),
+                    trackerEndpointUrl: `${trackerEndpointUrl}/${appId}`,
                     tokenParameter: 'token',
                     loggerFactory: this.getLogger.bind(this),
                     logger: channelLogger,
-                    channelFactory: function (url, logger) { return new channel_1.SocketChannel({ url: url, logger: logger }); },
+                    channelFactory: (url, logger) => (new channel_1.SocketChannel({ url: url, logger: logger })),
                     cidAssigner: this.getCidAssigner(),
                     cidParameter: 'clientId',
                 }),
@@ -124,44 +144,40 @@ var Container = /** @class */ (function () {
             }),
             logger: channelLogger,
         }), this.getBeaconQueue(), channelLogger);
-        queuedChannel.flush().catch(function () {
+        queuedChannel.flush().catch(() => {
             // Suppress errors as they are already reported by the channel
         });
         return new channel_1.EncodedChannel(queuedChannel, transformer_1.encodeJson);
-    };
-    Container.prototype.getCidAssigner = function () {
+    }
+    getCidAssigner() {
         if (this.cidAssigner === undefined) {
             this.cidAssigner = this.createCidAssigner();
         }
         return this.cidAssigner;
-    };
-    Container.prototype.createCidAssigner = function () {
-        if (this.configuration.cid !== undefined) {
-            return new cid_1.FixedAssigner(this.configuration.cid);
+    }
+    createCidAssigner() {
+        if (this.configuration.clientId !== undefined) {
+            return new cid_1.FixedAssigner(this.configuration.clientId);
         }
         if (this.configuration.test) {
             return new cid_1.FixedAssigner('00000000-0000-0000-0000-000000000000');
         }
-        var logger = this.getLogger('CidAssigner');
-        return new cid_1.CachedAssigner(new cid_1.RemoteAssigner(this.configuration.bootstrapEndpointUrl, logger), new cache_1.LocalStorageCache(this.getLocalStorage(), 'croct.cid'), logger);
-    };
-    Container.prototype.getBeaconQueue = function () {
+        const logger = this.getLogger('CidAssigner');
+        return new cid_1.CachedAssigner(new cid_1.RemoteAssigner(this.configuration.cidAssignerEndpointUrl, logger), new cache_1.LocalStorageCache(this.getLocalStorage(), 'croct.cid'), logger);
+    }
+    getBeaconQueue() {
         if (this.beaconQueue === undefined) {
             this.beaconQueue = this.createBeaconQueue();
         }
         return this.beaconQueue;
-    };
-    Container.prototype.createBeaconQueue = function () {
-        var context = this.getContext();
-        var tab = context.getTab();
+    }
+    createBeaconQueue() {
+        const context = this.getContext();
+        const tab = context.getTab();
         return new queue_1.MonitoredQueue(new queue_1.CapacityRestrictedQueue(new queue_1.PersistentQueue(this.getGlobalTabStorage('queue'), tab.id), this.configuration.beaconQueueSize), this.getLogger('BeaconQueue'));
-    };
-    Container.prototype.getLogger = function () {
-        var namespace = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            namespace[_i] = arguments[_i];
-        }
-        var prefix = "Croct".concat(namespace.length === 0 ? '' : ":".concat(namespace.join(':')));
+    }
+    getLogger(...namespace) {
+        const prefix = `Croct${namespace.length === 0 ? '' : `:${namespace.join(':')}`}`;
         if (this.configuration.logger !== undefined) {
             return new logging_1.NamespacedLogger(this.configuration.logger, prefix);
         }
@@ -169,96 +185,64 @@ var Container = /** @class */ (function () {
             return new logging_1.ConsoleLogger(prefix);
         }
         return new logging_1.NullLogger();
-    };
-    Container.prototype.getTabStorage = function (namespace) {
-        var subnamespace = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            subnamespace[_i - 1] = arguments[_i];
-        }
-        return this.getGlobalTabStorage.apply(this, tslib_1.__spreadArray(['external', namespace], tslib_1.__read(subnamespace), false));
-    };
-    Container.prototype.getBrowserStorage = function (namespace) {
-        var subnamespace = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            subnamespace[_i - 1] = arguments[_i];
-        }
-        return this.getGlobalBrowserStorage.apply(this, tslib_1.__spreadArray(['external', namespace], tslib_1.__read(subnamespace), false));
-    };
-    Container.prototype.getGlobalTabStorage = function (namespace) {
-        var subnamespace = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            subnamespace[_i - 1] = arguments[_i];
-        }
-        return new namespacedStorage_1.NamespacedStorage(this.getSessionStorage(), this.resolveStorageNamespace.apply(this, tslib_1.__spreadArray([namespace], tslib_1.__read(subnamespace), false)));
-    };
-    Container.prototype.getGlobalBrowserStorage = function (namespace) {
-        var subnamespace = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            subnamespace[_i - 1] = arguments[_i];
-        }
-        return new namespacedStorage_1.NamespacedStorage(this.getLocalStorage(), this.resolveStorageNamespace.apply(this, tslib_1.__spreadArray([namespace], tslib_1.__read(subnamespace), false)));
-    };
-    Container.prototype.resolveStorageNamespace = function (namespace) {
-        var subnamespace = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            subnamespace[_i - 1] = arguments[_i];
-        }
-        return "croct[".concat(this.configuration.appId.toLowerCase(), "].").concat([namespace].concat(subnamespace).join('.'));
-    };
-    Container.prototype.getLocalStorage = function () {
+    }
+    getTabStorage(namespace, ...subnamespace) {
+        return this.getGlobalTabStorage('external', namespace, ...subnamespace);
+    }
+    getBrowserStorage(namespace, ...subnamespace) {
+        return this.getGlobalBrowserStorage('external', namespace, ...subnamespace);
+    }
+    getGlobalTabStorage(namespace, ...subnamespace) {
+        return new namespacedStorage_1.NamespacedStorage(this.getSessionStorage(), this.resolveStorageNamespace(namespace, ...subnamespace));
+    }
+    getGlobalBrowserStorage(namespace, ...subnamespace) {
+        return new namespacedStorage_1.NamespacedStorage(this.getLocalStorage(), this.resolveStorageNamespace(namespace, ...subnamespace));
+    }
+    resolveStorageNamespace(namespace, ...subnamespace) {
+        return `croct[${this.configuration
+            .appId
+            .toLowerCase()}].${[namespace].concat(subnamespace).join('.')}`;
+    }
+    getLocalStorage() {
         return localStorage;
-    };
-    Container.prototype.getSessionStorage = function () {
+    }
+    getSessionStorage() {
         return sessionStorage;
-    };
-    Container.prototype.getEventManager = function () {
+    }
+    getEventManager() {
         return this.eventManager;
-    };
-    Container.prototype.dispose = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var logger;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        logger = this.getLogger();
-                        if (!this.beaconChannel) return [3 /*break*/, 2];
-                        logger.debug('Closing beacon channel...');
-                        return [4 /*yield*/, this.beaconChannel.close()];
-                    case 1:
-                        _a.sent();
-                        _a.label = 2;
-                    case 2:
-                        if (this.removeTokenSyncListener) {
-                            logger.debug('Removing token sync listener...');
-                            this.removeTokenSyncListener();
-                        }
-                        if (!this.tracker) return [3 /*break*/, 4];
-                        if (this.beaconQueue) {
-                            logger.debug('Removing queue listeners...');
-                            this.beaconQueue.removeCallback('halfEmpty', this.tracker.unsuspend);
-                            this.beaconQueue.removeCallback('full', this.tracker.suspend);
-                        }
-                        logger.debug('Suspending tracker...');
-                        this.tracker.suspend();
-                        return [4 /*yield*/, this.tracker.flushed];
-                    case 3:
-                        _a.sent();
-                        _a.label = 4;
-                    case 4:
-                        delete this.context;
-                        delete this.tokenProvider;
-                        delete this.cidAssigner;
-                        delete this.tracker;
-                        delete this.evaluator;
-                        delete this.beaconChannel;
-                        delete this.beaconQueue;
-                        delete this.removeTokenSyncListener;
-                        logger.debug('Container resources released.');
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    return Container;
-}());
+    }
+    async dispose() {
+        const logger = this.getLogger();
+        if (this.beaconChannel !== undefined) {
+            logger.debug('Closing beacon channel...');
+            await this.beaconChannel.close();
+        }
+        if (this.removeTokenSyncListener !== undefined) {
+            logger.debug('Removing token sync listener...');
+            this.removeTokenSyncListener();
+        }
+        if (this.tracker !== undefined) {
+            if (this.beaconQueue !== undefined) {
+                logger.debug('Removing queue listeners...');
+                this.beaconQueue.removeCallback('halfEmpty', this.tracker.unsuspend);
+                this.beaconQueue.removeCallback('full', this.tracker.suspend);
+            }
+            logger.debug('Suspending tracker...');
+            this.tracker.suspend();
+            await this.tracker.flushed;
+        }
+        delete this.context;
+        delete this.userTokenProvider;
+        delete this.previewTokenStore;
+        delete this.cidAssigner;
+        delete this.tracker;
+        delete this.evaluator;
+        delete this.contentFetcher;
+        delete this.beaconChannel;
+        delete this.beaconQueue;
+        delete this.removeTokenSyncListener;
+        logger.debug('Container resources released.');
+    }
+}
 exports.Container = Container;

package/contentFetcher.d.ts

@@ -0,0 +1,59 @@
+import { JsonObject } from '@croct/json';
+import { EvaluationContext } from './evaluator';
+import { Token } from './token';
+export type ErrorResponse = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+};
+export declare enum ContentErrorType {
+    TIMEOUT = "https://croct.help/api/content#timeout",
+    UNEXPECTED_ERROR = "https://croct.help/api/content#unexpected-error"
+}
+export declare class ContentError<T extends ErrorResponse = ErrorResponse> extends Error {
+    readonly response: T;
+    constructor(response: T);
+}
+type BasicOptions = {
+    version?: `${number}` | number;
+    preferredLocale?: string;
+    timeout?: number;
+    extra?: ExtraFetchOptions;
+};
+export type StaticContentOptions = BasicOptions & {
+    static: true;
+};
+export type DynamicContentOptions = BasicOptions & {
+    static?: false;
+    clientId?: string;
+    clientIp?: string;
+    userAgent?: string;
+    userToken?: Token | string;
+    previewToken?: Token | string;
+    context?: EvaluationContext;
+};
+type AllowedFetchOptions = Exclude<keyof RequestInit, 'method' | 'body' | 'headers' | 'signal'>;
+type ExtraFetchOptions<T extends keyof RequestInit = AllowedFetchOptions> = Pick<RequestInit, T> & {
+    [key in Exclude<keyof RequestInit, T>]?: never;
+} & Record<string, any>;
+export type FetchOptions = StaticContentOptions | DynamicContentOptions;
+export type FetchResponse<P extends JsonObject = JsonObject> = {
+    content: P;
+};
+export type Configuration = {
+    appId?: string;
+    apiKey?: string;
+    endpointUrl?: string;
+};
+export declare class ContentFetcher {
+    private readonly configuration;
+    private readonly dynamicEndpoint;
+    private readonly staticEndpoint;
+    constructor(configuration: Configuration);
+    fetch<P extends JsonObject>(slotId: string, options?: FetchOptions): Promise<FetchResponse<P>>;
+    private load;
+    private static isDynamicContent;
+    toJSON(): never;
+}
+export {};

package/contentFetcher.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentFetcher = exports.ContentError = exports.ContentErrorType = void 0;
+const constants_1 = require("./constants");
+const error_1 = require("./error");
+var ContentErrorType;
+(function (ContentErrorType) {
+    ContentErrorType["TIMEOUT"] = "https://croct.help/api/content#timeout";
+    ContentErrorType["UNEXPECTED_ERROR"] = "https://croct.help/api/content#unexpected-error";
+})(ContentErrorType = exports.ContentErrorType || (exports.ContentErrorType = {}));
+class ContentError extends Error {
+    constructor(response) {
+        super(response.title);
+        this.response = response;
+        Object.setPrototypeOf(this, ContentError.prototype);
+    }
+}
+exports.ContentError = ContentError;
+class ContentFetcher {
+    constructor(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, endpointUrl } = this.configuration;
+        // eslint-disable-next-line prefer-template -- Better readability
+        const baseEndpoint = (endpointUrl !== null && endpointUrl !== void 0 ? endpointUrl : constants_1.CONTENT_ENDPOINT_URL).replace(/\/+$/, '')
+            + (apiKey === undefined ? '/client' : '/external')
+            + '/web';
+        this.dynamicEndpoint = `${baseEndpoint}/content`;
+        this.staticEndpoint = `${baseEndpoint}/static-content`;
+    }
+    fetch(slotId, options = {}) {
+        if (options.static === true && this.configuration.apiKey === undefined) {
+            throw new Error('The API key must be provided to fetch static content.');
+        }
+        return new Promise((resolve, reject) => {
+            const abortController = new AbortController();
+            if (options.timeout !== undefined) {
+                setTimeout(() => {
+                    const response = {
+                        title: 'Maximum timeout reached before content could be loaded.',
+                        type: ContentErrorType.TIMEOUT,
+                        detail: `The content took more than ${options.timeout}ms to load.`,
+                        status: 408, // Request Timeout
+                    };
+                    abortController.abort();
+                    reject(new ContentError(response));
+                }, options.timeout);
+            }
+            this.load(slotId, abortController.signal, options)
+                .then(response => response.json()
+                .then(body => {
+                if (response.ok) {
+                    resolve(body);
+                }
+                else {
+                    reject(new ContentError(body));
+                }
+            }))
+                .catch(error => {
+                if (!abortController.signal.aborted) {
+                    reject(new ContentError({
+                        title: (0, error_1.formatMessage)(error),
+                        type: ContentErrorType.UNEXPECTED_ERROR,
+                        detail: 'Please try again or contact Croct support if the error persists.',
+                        status: 500, // Internal Server Error
+                    }));
+                }
+            });
+        });
+    }
+    load(slotId, signal, options) {
+        const payload = {
+            slotId: slotId,
+        };
+        const { apiKey, appId } = this.configuration;
+        const headers = new Headers();
+        if (appId !== undefined) {
+            headers.set('X-App-Id', appId);
+        }
+        if (apiKey !== undefined) {
+            headers.set('X-Api-Key', apiKey);
+        }
+        const dynamic = ContentFetcher.isDynamicContent(options);
+        if (dynamic) {
+            if (options.clientId !== undefined) {
+                headers.set('X-Client-Id', options.clientId);
+            }
+            if (options.clientIp !== undefined) {
+                headers.set('X-Client-Ip', options.clientIp);
+            }
+            if (options.userToken !== undefined) {
+                headers.set('X-Token', options.userToken.toString());
+            }
+            if (options.userAgent !== undefined) {
+                headers.set('User-Agent', options.userAgent);
+            }
+            if (options.version !== undefined) {
+                payload.version = `${options.version}`;
+            }
+            if (options.preferredLocale !== undefined) {
+                payload.preferredLocale = options.preferredLocale;
+            }
+            if (options.context !== undefined) {
+                payload.context = options.context;
+            }
+            if (options.previewToken !== undefined) {
+                payload.previewToken = `${options.previewToken}`;
+            }
+        }
+        return fetch(dynamic ? this.dynamicEndpoint : this.staticEndpoint, {
+            credentials: 'omit',
+            ...options.extra,
+            method: 'POST',
+            headers: headers,
+            signal: signal,
+            body: JSON.stringify(payload),
+        });
+    }
+    static isDynamicContent(options) {
+        return options.static !== true;
+    }
+    toJSON() {
+        // Prevent sensitive configuration from being serialized
+        throw new Error('Unserializable value.');
+    }
+}
+exports.ContentFetcher = ContentFetcher;

package/context.d.ts

@@ -3,8 +3,8 @@ import { Tab, UrlSanitizer } from './tab';
 import { EventDispatcher } from './eventManager';
 import { SdkEventMap } from './sdkEvents';
 import { LocalStorageCache } from './cache';
-export declare type TokenScope = 'isolated' | 'global' | 'contextual';
-export declare type Configuration = {
+export type TokenScope = 'isolated' | 'global' | 'contextual';
+export type Configuration = {
     tokenScope: TokenScope;
     urlSanitizer?: UrlSanitizer;
     eventDispatcher: ContextEventDispatcher;
@@ -14,7 +14,7 @@ export declare type Configuration = {
         browserToken: LocalStorageCache;
     };
 };
-declare type ContextEventDispatcher = EventDispatcher<Pick<SdkEventMap, 'tokenChanged'>>;
+type ContextEventDispatcher = EventDispatcher<Pick<SdkEventMap, 'tokenChanged'>>;
 export declare class Context {
     private readonly tab;
     private readonly tokenStore;