@croct/sdk 0.9.1 → 0.11.0-alpha

package/facade/evaluatorFacade.d.ts

@@ -1,18 +1,28 @@
 import { JsonObject, JsonValue } from '@croct/json';
 import { Evaluator, EvaluationContext } from '../evaluator';
 import { Tab } from '../tab';
-export declare type EvaluationOptions = {
+import { TokenProvider } from '../token';
+import { CidAssigner } from '../cid';
+export type EvaluationOptions = {
     timeout?: number;
     attributes?: JsonObject;
 };
 export interface ContextFactory {
     createContext(attributes?: JsonObject): EvaluationContext;
 }
+export type Configuration = {
+    evaluator: Evaluator;
+    contextFactory: ContextFactory;
+    userTokenProvider: TokenProvider;
+    cidAssigner: CidAssigner;
+};
 export declare class EvaluatorFacade {
     private readonly evaluator;
     private readonly contextFactory;
-    constructor(evaluator: Evaluator, contextFactory: ContextFactory);
-    evaluate(expression: string, options?: EvaluationOptions): Promise<JsonValue>;
+    private readonly tokenProvider;
+    private readonly cidAssigner;
+    constructor(configuration: Configuration);
+    evaluate(query: string, options?: EvaluationOptions): Promise<JsonValue>;
 }
 export declare class MinimalContextFactory implements ContextFactory {
     createContext(attributes?: JsonObject): EvaluationContext;

package/facade/evaluatorFacade.js

@@ -1,72 +1,69 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TabContextFactory = exports.MinimalContextFactory = exports.EvaluatorFacade = void 0;
-var tslib_1 = require("tslib");
-var schema_1 = require("../schema");
-var error_1 = require("../error");
+const schema_1 = require("../schema");
+const error_1 = require("../error");
 function validate(options) {
-    if (typeof options !== 'object' || options === null) {
-        throw new Error('The options must be an object.');
-    }
     try {
-        schema_1.optionsSchema.validate(options);
+        schema_1.evaluationOptionsSchema.validate(options);
     }
     catch (violation) {
-        throw new Error("Invalid options: ".concat((0, error_1.formatCause)(violation)));
+        throw new Error(`Invalid options: ${(0, error_1.formatCause)(violation)}`);
     }
 }
-var EvaluatorFacade = /** @class */ (function () {
-    function EvaluatorFacade(evaluator, contextFactory) {
-        this.evaluator = evaluator;
-        this.contextFactory = contextFactory;
+class EvaluatorFacade {
+    constructor(configuration) {
+        this.evaluator = configuration.evaluator;
+        this.contextFactory = configuration.contextFactory;
+        this.tokenProvider = configuration.userTokenProvider;
+        this.cidAssigner = configuration.cidAssigner;
     }
-    EvaluatorFacade.prototype.evaluate = function (expression, options) {
-        if (options === void 0) { options = {}; }
-        if (typeof expression !== 'string' || expression.length === 0) {
-            throw new Error('The expression must be a non-empty string.');
+    async evaluate(query, options = {}) {
+        var _a;
+        if (typeof query !== 'string' || query.length === 0) {
+            throw new Error('The query must be a non-empty string.');
         }
         validate(options);
-        return this.evaluator.evaluate(expression, {
+        return this.evaluator.evaluate(query, {
+            clientId: await this.cidAssigner.assignCid(),
+            userToken: (_a = this.tokenProvider.getToken()) !== null && _a !== void 0 ? _a : undefined,
             timeout: options.timeout,
             context: this.contextFactory.createContext(options.attributes),
         });
-    };
-    return EvaluatorFacade;
-}());
-exports.EvaluatorFacade = EvaluatorFacade;
-var MinimalContextFactory = /** @class */ (function () {
-    function MinimalContextFactory() {
     }
-    MinimalContextFactory.prototype.createContext = function (attributes) {
+}
+exports.EvaluatorFacade = EvaluatorFacade;
+class MinimalContextFactory {
+    createContext(attributes) {
         if (attributes === undefined) {
             return {};
         }
         return { attributes: attributes };
-    };
-    return MinimalContextFactory;
-}());
+    }
+}
 exports.MinimalContextFactory = MinimalContextFactory;
-var TabContextFactory = /** @class */ (function () {
-    function TabContextFactory(tab) {
+class TabContextFactory {
+    constructor(tab) {
         this.tab = tab;
     }
-    TabContextFactory.prototype.createContext = function (attributes) {
-        var url = new URL(this.tab.url);
-        var context = {};
-        var page = {
+    createContext(attributes) {
+        var _a;
+        const url = new URL(this.tab.url);
+        const context = {};
+        const page = {
             title: this.tab.title,
             url: url.toString(),
         };
-        var referrer = this.tab.referrer;
+        const { referrer } = this.tab;
         if (referrer.length > 0) {
             page.referrer = referrer;
         }
         context.page = page;
-        var timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || null;
-        if (timezone !== null) {
-            context.timezone = timezone;
+        const timeZone = (_a = Intl.DateTimeFormat().resolvedOptions().timeZone) !== null && _a !== void 0 ? _a : null;
+        if (timeZone !== null) {
+            context.timeZone = timeZone;
         }
-        var campaign = TabContextFactory.createCampaign(url);
+        const campaign = TabContextFactory.createCampaign(url);
         if (Object.keys(campaign).length > 0) {
             context.campaign = campaign;
         }
@@ -74,41 +71,29 @@ var TabContextFactory = /** @class */ (function () {
             context.attributes = attributes;
         }
         return context;
-    };
-    TabContextFactory.createCampaign = function (url) {
-        var e_1, _a;
-        var campaign = {};
-        try {
-            for (var _b = tslib_1.__values(url.searchParams.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var _d = tslib_1.__read(_c.value, 2), parameter = _d[0], value = _d[1];
-                switch (parameter.toLowerCase()) {
-                    case 'utm_campaign':
-                        campaign.name = value;
-                        break;
-                    case 'utm_source':
-                        campaign.source = value;
-                        break;
-                    case 'utm_term':
-                        campaign.term = value;
-                        break;
-                    case 'utm_medium':
-                        campaign.medium = value;
-                        break;
-                    case 'utm_content':
-                        campaign.content = value;
-                        break;
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+    }
+    static createCampaign(url) {
+        const campaign = {};
+        for (const [parameter, value] of url.searchParams.entries()) {
+            switch (parameter.toLowerCase()) {
+                case 'utm_campaign':
+                    campaign.name = value;
+                    break;
+                case 'utm_source':
+                    campaign.source = value;
+                    break;
+                case 'utm_term':
+                    campaign.term = value;
+                    break;
+                case 'utm_medium':
+                    campaign.medium = value;
+                    break;
+                case 'utm_content':
+                    campaign.content = value;
+                    break;
             }
-            finally { if (e_1) throw e_1.error; }
         }
         return campaign;
-    };
-    return TabContextFactory;
-}());
+    }
+}
 exports.TabContextFactory = TabContextFactory;

package/facade/sdkFacade.d.ts

@@ -2,14 +2,15 @@ import { EvaluatorFacade } from './evaluatorFacade';
 import { TrackerFacade } from './trackerFacade';
 import { Context, TokenScope } from '../context';
 import { UserFacade } from './userFacade';
-import { Token } from '../token';
+import { Token, TokenStore } from '../token';
 import { SessionFacade } from './sessionFacade';
 import { Logger } from '../logging';
 import { SdkEventMap } from '../sdkEvents';
 import { EventManager } from '../eventManager';
 import { CidAssigner } from '../cid';
 import { UrlSanitizer } from '../tab';
-export declare type Configuration = {
+import { ContentFetcherFacade } from './contentFetcherFacade';
+export type Configuration = {
     appId: string;
     tokenScope?: TokenScope;
     debug?: boolean;
@@ -17,6 +18,7 @@ export declare type Configuration = {
     track?: boolean;
     token?: string | null;
     userId?: string;
+    clientId?: string;
     eventMetadata?: {
         [key: string]: string;
     };
@@ -24,7 +26,8 @@ export declare type Configuration = {
     urlSanitizer?: UrlSanitizer;
     trackerEndpointUrl?: string;
     evaluationEndpointUrl?: string;
-    bootstrapEndpointUrl?: string;
+    contentEndpointUrl?: string;
+    cidAssignerEndpointUrl?: string;
 };
 export declare class SdkFacade {
     private readonly sdk;
@@ -32,14 +35,18 @@ export declare class SdkFacade {
     private userFacade?;
     private sessionFacade?;
     private evaluatorFacade?;
+    private contentFetcherFacade?;
     private constructor();
     static init(configuration: Configuration): SdkFacade;
     get context(): Context;
     get cidAssigner(): CidAssigner;
+    get previewTokenStore(): TokenStore;
+    get userTokenStore(): TokenStore;
     get tracker(): TrackerFacade;
     get user(): UserFacade;
     get session(): SessionFacade;
     get evaluator(): EvaluatorFacade;
+    get contentFetcher(): ContentFetcherFacade;
     get eventManager(): EventManager<Record<string, Record<string, unknown>>, SdkEventMap>;
     identify(userId: string): void;
     anonymize(): void;

package/facade/sdkFacade.js

@@ -1,38 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SdkFacade = void 0;
-var tslib_1 = require("tslib");
-var evaluatorFacade_1 = require("./evaluatorFacade");
-var trackerFacade_1 = require("./trackerFacade");
-var userFacade_1 = require("./userFacade");
-var token_1 = require("../token");
-var error_1 = require("../error");
-var schema_1 = require("../schema");
-var sdk_1 = require("../sdk");
-var sessionFacade_1 = require("./sessionFacade");
+const evaluatorFacade_1 = require("./evaluatorFacade");
+const trackerFacade_1 = require("./trackerFacade");
+const userFacade_1 = require("./userFacade");
+const token_1 = require("../token");
+const error_1 = require("../error");
+const schema_1 = require("../schema");
+const sdk_1 = require("../sdk");
+const sessionFacade_1 = require("./sessionFacade");
+const contentFetcherFacade_1 = require("./contentFetcherFacade");
 function validateConfiguration(configuration) {
-    if (typeof configuration !== 'object' || configuration === null) {
-        throw new Error('The configuration must be a key-value map.');
-    }
     try {
         schema_1.sdkFacadeConfigurationSchema.validate(configuration);
     }
     catch (violation) {
-        throw new Error("Invalid configuration: ".concat((0, error_1.formatCause)(violation)));
+        throw new Error(`Invalid configuration: ${(0, error_1.formatCause)(violation)}`);
     }
 }
-var SdkFacade = /** @class */ (function () {
-    function SdkFacade(sdk) {
+class SdkFacade {
+    constructor(sdk) {
         this.sdk = sdk;
     }
-    SdkFacade.init = function (configuration) {
+    static init(configuration) {
         var _a, _b, _c;
         validateConfiguration(configuration);
-        var _d = configuration.track, track = _d === void 0 ? true : _d, userId = configuration.userId, token = configuration.token, containerConfiguration = tslib_1.__rest(configuration, ["track", "userId", "token"]);
+        const { track = true, userId, token, ...containerConfiguration } = configuration;
         if (userId !== undefined && token !== undefined) {
             throw new Error('Either the user ID or token can be specified, but not both.');
         }
-        var sdk = new SdkFacade(sdk_1.Sdk.init(tslib_1.__assign(tslib_1.__assign({}, containerConfiguration), { tokenScope: (_a = containerConfiguration.tokenScope) !== null && _a !== void 0 ? _a : 'global', debug: (_b = containerConfiguration.debug) !== null && _b !== void 0 ? _b : false, test: (_c = containerConfiguration.test) !== null && _c !== void 0 ? _c : false })));
+        const sdk = new SdkFacade(sdk_1.Sdk.init({
+            ...containerConfiguration,
+            tokenScope: (_a = containerConfiguration.tokenScope) !== null && _a !== void 0 ? _a : 'global',
+            debug: (_b = containerConfiguration.debug) !== null && _b !== void 0 ? _b : false,
+            test: (_c = containerConfiguration.test) !== null && _c !== void 0 ? _c : false,
+        }));
         if (userId !== undefined) {
             sdk.identify(userId);
         }
@@ -48,100 +50,99 @@ var SdkFacade = /** @class */ (function () {
             sdk.tracker.enable();
         }
         return sdk;
-    };
-    Object.defineProperty(SdkFacade.prototype, "context", {
-        get: function () {
-            return this.sdk.context;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SdkFacade.prototype, "cidAssigner", {
-        get: function () {
-            return this.sdk.cidAssigner;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SdkFacade.prototype, "tracker", {
-        get: function () {
-            if (this.trackerFacade === undefined) {
-                this.trackerFacade = new trackerFacade_1.TrackerFacade(this.sdk.tracker);
-            }
-            return this.trackerFacade;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SdkFacade.prototype, "user", {
-        get: function () {
-            if (this.userFacade === undefined) {
-                this.userFacade = new userFacade_1.UserFacade(this.context, this.sdk.tracker);
-            }
-            return this.userFacade;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SdkFacade.prototype, "session", {
-        get: function () {
-            if (this.sessionFacade === undefined) {
-                this.sessionFacade = new sessionFacade_1.SessionFacade(this.sdk.tracker);
-            }
-            return this.sessionFacade;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SdkFacade.prototype, "evaluator", {
-        get: function () {
-            if (this.evaluatorFacade === undefined) {
-                this.evaluatorFacade = new evaluatorFacade_1.EvaluatorFacade(this.sdk.evaluator, new evaluatorFacade_1.TabContextFactory(this.sdk.context.getTab()));
-            }
-            return this.evaluatorFacade;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SdkFacade.prototype, "eventManager", {
-        get: function () {
-            var eventManager = this.sdk.eventManager;
-            return {
-                addListener: eventManager.addListener.bind(eventManager),
-                removeListener: eventManager.removeListener.bind(eventManager),
-                dispatch: function (eventName, event) {
-                    if (!/[a-z][a-z_]+\.[a-z][a-z_]+/i.test(eventName)) {
-                        throw new Error('The event name must be in the form of "namespaced.eventName", where '
-                            + 'both the namespace and event name must start with a letter, followed by '
-                            + 'any series of letters and underscores.');
-                    }
-                    eventManager.dispatch(eventName, event);
-                },
-            };
-        },
-        enumerable: false,
-        configurable: true
-    });
-    SdkFacade.prototype.identify = function (userId) {
+    }
+    get context() {
+        return this.sdk.context;
+    }
+    get cidAssigner() {
+        return this.sdk.cidAssigner;
+    }
+    get previewTokenStore() {
+        return this.sdk.previewTokenStore;
+    }
+    get userTokenStore() {
+        return this.sdk.userTokenStore;
+    }
+    get tracker() {
+        if (this.trackerFacade === undefined) {
+            this.trackerFacade = new trackerFacade_1.TrackerFacade(this.sdk.tracker);
+        }
+        return this.trackerFacade;
+    }
+    get user() {
+        if (this.userFacade === undefined) {
+            this.userFacade = new userFacade_1.UserFacade(this.context, this.sdk.tracker);
+        }
+        return this.userFacade;
+    }
+    get session() {
+        if (this.sessionFacade === undefined) {
+            this.sessionFacade = new sessionFacade_1.SessionFacade(this.sdk.tracker);
+        }
+        return this.sessionFacade;
+    }
+    get evaluator() {
+        if (this.evaluatorFacade === undefined) {
+            this.evaluatorFacade = new evaluatorFacade_1.EvaluatorFacade({
+                evaluator: this.sdk.evaluator,
+                contextFactory: new evaluatorFacade_1.TabContextFactory(this.sdk
+                    .context
+                    .getTab()),
+                cidAssigner: this.sdk.cidAssigner,
+                userTokenProvider: this.sdk.userTokenStore,
+            });
+        }
+        return this.evaluatorFacade;
+    }
+    get contentFetcher() {
+        if (this.contentFetcherFacade === undefined) {
+            this.contentFetcherFacade = new contentFetcherFacade_1.ContentFetcherFacade({
+                contentFetcher: this.sdk.contentFetcher,
+                contextFactory: new evaluatorFacade_1.TabContextFactory(this.sdk
+                    .context
+                    .getTab()),
+                cidAssigner: this.sdk.cidAssigner,
+                previewTokenProvider: this.sdk.previewTokenStore,
+                userTokenProvider: this.sdk.userTokenStore,
+            });
+        }
+        return this.contentFetcherFacade;
+    }
+    get eventManager() {
+        const { eventManager } = this.sdk;
+        return {
+            addListener: eventManager.addListener.bind(eventManager),
+            removeListener: eventManager.removeListener.bind(eventManager),
+            dispatch: (eventName, event) => {
+                if (!/[a-z][a-z_]+\.[a-z][a-z_]+/i.test(eventName)) {
+                    throw new Error('The event name must be in the form of "namespaced.eventName", where '
+                        + 'both the namespace and event name must start with a letter, followed by '
+                        + 'any series of letters and underscores.');
+                }
+                eventManager.dispatch(eventName, event);
+            },
+        };
+    }
+    identify(userId) {
         this.setToken(token_1.Token.issue(this.sdk.appId, userId));
-    };
-    SdkFacade.prototype.anonymize = function () {
+    }
+    anonymize() {
         if (!this.context.isAnonymous()) {
             this.unsetToken();
         }
-    };
-    SdkFacade.prototype.getToken = function () {
+    }
+    getToken() {
         return this.context.getToken();
-    };
-    SdkFacade.prototype.setToken = function (token) {
+    }
+    setToken(token) {
         var _a;
-        var currentToken = this.getToken();
+        const currentToken = this.getToken();
         if (currentToken !== null && currentToken.toString() === token.toString()) {
             return;
         }
-        var currentSubject = (_a = currentToken === null || currentToken === void 0 ? void 0 : currentToken.getSubject()) !== null && _a !== void 0 ? _a : null;
-        var subject = token.getSubject();
-        var logger = this.getLogger();
+        const currentSubject = (_a = currentToken === null || currentToken === void 0 ? void 0 : currentToken.getSubject()) !== null && _a !== void 0 ? _a : null;
+        const subject = token.getSubject();
+        const logger = this.getLogger();
         if (subject === currentSubject) {
             this.context.setToken(token);
             logger.debug('Token refreshed');
@@ -160,17 +161,17 @@ var SdkFacade = /** @class */ (function () {
                 type: 'userSignedIn',
                 userId: subject,
             });
-            logger.info("User signed in as ".concat(subject));
+            logger.info(`User signed in as ${subject}`);
         }
         logger.debug('New token saved, ');
-    };
-    SdkFacade.prototype.unsetToken = function () {
-        var token = this.getToken();
+    }
+    unsetToken() {
+        const token = this.getToken();
         if (token === null) {
             return;
         }
-        var logger = this.getLogger();
-        var subject = token.getSubject();
+        const logger = this.getLogger();
+        const subject = token.getSubject();
         if (subject !== null) {
             this.trackInternalEvent({
                 type: 'userSignedOut',
@@ -180,39 +181,26 @@ var SdkFacade = /** @class */ (function () {
         }
         this.context.setToken(null);
         logger.debug('Token removed');
-    };
-    SdkFacade.prototype.trackInternalEvent = function (event) {
-        this.sdk.tracker.track(event).catch(function () {
+    }
+    trackInternalEvent(event) {
+        this.sdk
+            .tracker
+            .track(event)
+            .catch(() => {
             // suppress error as it is already logged by the tracker
         });
-    };
-    SdkFacade.prototype.getLogger = function () {
-        var _a;
-        var namespace = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            namespace[_i] = arguments[_i];
-        }
-        return (_a = this.sdk).getLogger.apply(_a, tslib_1.__spreadArray([], tslib_1.__read(namespace), false));
-    };
-    SdkFacade.prototype.getTabStorage = function (namespace) {
-        var _a;
-        var subnamespace = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            subnamespace[_i - 1] = arguments[_i];
-        }
-        return (_a = this.sdk).getTabStorage.apply(_a, tslib_1.__spreadArray([namespace], tslib_1.__read(subnamespace), false));
-    };
-    SdkFacade.prototype.getBrowserStorage = function (namespace) {
-        var _a;
-        var subnamespace = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            subnamespace[_i - 1] = arguments[_i];
-        }
-        return (_a = this.sdk).getBrowserStorage.apply(_a, tslib_1.__spreadArray([namespace], tslib_1.__read(subnamespace), false));
-    };
-    SdkFacade.prototype.close = function () {
+    }
+    getLogger(...namespace) {
+        return this.sdk.getLogger(...namespace);
+    }
+    getTabStorage(namespace, ...subnamespace) {
+        return this.sdk.getTabStorage(namespace, ...subnamespace);
+    }
+    getBrowserStorage(namespace, ...subnamespace) {
+        return this.sdk.getBrowserStorage(namespace, ...subnamespace);
+    }
+    close() {
         return this.sdk.close();
-    };
-    return SdkFacade;
-}());
+    }
+}
 exports.SdkFacade = SdkFacade;

package/facade/sessionFacade.js

@@ -1,14 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SessionFacade = void 0;
-var sessionPatch_1 = require("./sessionPatch");
-var SessionFacade = /** @class */ (function () {
-    function SessionFacade(tracker) {
+const sessionPatch_1 = require("./sessionPatch");
+class SessionFacade {
+    constructor(tracker) {
         this.tracker = tracker;
     }
-    SessionFacade.prototype.edit = function () {
+    edit() {
         return new sessionPatch_1.SessionPatch(this.tracker);
-    };
-    return SessionFacade;
-}());
+    }
+}
 exports.SessionFacade = SessionFacade;

package/facade/sessionPatch.js

@@ -1,16 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SessionPatch = void 0;
-var tslib_1 = require("tslib");
-var activeRecord_1 = require("../activeRecord");
-var SessionPatch = /** @class */ (function (_super) {
-    tslib_1.__extends(SessionPatch, _super);
-    function SessionPatch(tracker) {
-        var _this = _super.call(this) || this;
-        _this.tracker = tracker;
-        return _this;
+const activeRecord_1 = require("../activeRecord");
+class SessionPatch extends activeRecord_1.ActiveRecord {
+    constructor(tracker) {
+        super();
+        this.tracker = tracker;
     }
-    SessionPatch.prototype.save = function () {
+    save() {
         if (!this.isDirty()) {
             // Empty patch
             return Promise.resolve({
@@ -18,13 +15,12 @@ var SessionPatch = /** @class */ (function (_super) {
                 patch: { operations: [] },
             });
         }
-        var promise = this.tracker.track({
+        const promise = this.tracker.track({
             type: 'sessionAttributesChanged',
             patch: this.buildPatch(),
         });
         this.reset();
         return promise;
-    };
-    return SessionPatch;
-}(activeRecord_1.ActiveRecord));
+    }
+}
 exports.SessionPatch = SessionPatch;