@croct/sdk 0.11.0-alpha → 0.11.0-alpha.1

package/.src/facade/sdkFacade.ts

@@ -0,0 +1,291 @@
+import {EvaluatorFacade, TabContextFactory} from './evaluatorFacade';
+import {TrackerFacade} from './trackerFacade';
+import {Context, TokenScope} from '../context';
+import {UserFacade} from './userFacade';
+import {Token, TokenStore} from '../token';
+import {formatCause} from '../error';
+import {sdkFacadeConfigurationSchema} from '../schema';
+import {Sdk} from '../sdk';
+import {SessionFacade} from './sessionFacade';
+import {Logger} from '../logging';
+import {SdkEventMap} from '../sdkEvents';
+import {EventManager} from '../eventManager';
+import {CidAssigner} from '../cid';
+import {PartialTrackingEvent} from '../trackingEvents';
+import {UrlSanitizer} from '../tab';
+import {ContentFetcherFacade} from './contentFetcherFacade';
+
+export type Configuration = {
+    appId: string,
+    tokenScope?: TokenScope,
+    debug?: boolean,
+    test?: boolean,
+    track?: boolean,
+    token?: string | null,
+    userId?: string,
+    clientId?: string,
+    eventMetadata?: {[key: string]: string},
+    logger?: Logger,
+    urlSanitizer?: UrlSanitizer,
+    trackerEndpointUrl?: string,
+    evaluationEndpointUrl?: string,
+    contentEndpointUrl?: string,
+    cidAssignerEndpointUrl?: string,
+};
+
+function validateConfiguration(configuration: unknown): asserts configuration is Configuration {
+    try {
+        sdkFacadeConfigurationSchema.validate(configuration);
+    } catch (violation) {
+        throw new Error(`Invalid configuration: ${formatCause(violation)}`);
+    }
+}
+
+export class SdkFacade {
+    private readonly sdk: Sdk;
+
+    private trackerFacade?: TrackerFacade;
+
+    private userFacade?: UserFacade;
+
+    private sessionFacade?: SessionFacade;
+
+    private evaluatorFacade?: EvaluatorFacade;
+
+    private contentFetcherFacade?: ContentFetcherFacade;
+
+    private constructor(sdk: Sdk) {
+        this.sdk = sdk;
+    }
+
+    public static init(configuration: Configuration): SdkFacade {
+        validateConfiguration(configuration);
+
+        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.');
+        }
+
+        const sdk = new SdkFacade(
+            Sdk.init({
+                ...containerConfiguration,
+                tokenScope: containerConfiguration.tokenScope ?? 'global',
+                debug: containerConfiguration.debug ?? false,
+                test: containerConfiguration.test ?? false,
+            }),
+        );
+
+        if (userId !== undefined) {
+            sdk.identify(userId);
+        } else if (token !== undefined) {
+            if (token === null) {
+                sdk.unsetToken();
+            } else {
+                sdk.setToken(Token.parse(token));
+            }
+        }
+
+        if (track) {
+            sdk.tracker.enable();
+        }
+
+        return sdk;
+    }
+
+    public get context(): Context {
+        return this.sdk.context;
+    }
+
+    public get cidAssigner(): CidAssigner {
+        return this.sdk.cidAssigner;
+    }
+
+    public get previewTokenStore(): TokenStore {
+        return this.sdk.previewTokenStore;
+    }
+
+    public get userTokenStore(): TokenStore {
+        return this.sdk.userTokenStore;
+    }
+
+    public get tracker(): TrackerFacade {
+        if (this.trackerFacade === undefined) {
+            this.trackerFacade = new TrackerFacade(this.sdk.tracker);
+        }
+
+        return this.trackerFacade;
+    }
+
+    public get user(): UserFacade {
+        if (this.userFacade === undefined) {
+            this.userFacade = new UserFacade(this.context, this.sdk.tracker);
+        }
+
+        return this.userFacade;
+    }
+
+    public get session(): SessionFacade {
+        if (this.sessionFacade === undefined) {
+            this.sessionFacade = new SessionFacade(this.sdk.tracker);
+        }
+
+        return this.sessionFacade;
+    }
+
+    public get evaluator(): EvaluatorFacade {
+        if (this.evaluatorFacade === undefined) {
+            this.evaluatorFacade = new EvaluatorFacade({
+                evaluator: this.sdk.evaluator,
+                contextFactory: new TabContextFactory(this.sdk
+                    .context
+                    .getTab()),
+                cidAssigner: this.sdk.cidAssigner,
+                userTokenProvider: this.sdk.userTokenStore,
+            });
+        }
+
+        return this.evaluatorFacade;
+    }
+
+    public get contentFetcher(): ContentFetcherFacade {
+        if (this.contentFetcherFacade === undefined) {
+            this.contentFetcherFacade = new ContentFetcherFacade({
+                contentFetcher: this.sdk.contentFetcher,
+                contextFactory: new TabContextFactory(this.sdk
+                    .context
+                    .getTab()),
+                cidAssigner: this.sdk.cidAssigner,
+                previewTokenProvider: this.sdk.previewTokenStore,
+                userTokenProvider: this.sdk.userTokenStore,
+            });
+        }
+
+        return this.contentFetcherFacade;
+    }
+
+    public get eventManager(): EventManager<Record<string, Record<string, unknown>>, SdkEventMap> {
+        const {eventManager} = this.sdk;
+
+        return {
+            addListener: eventManager.addListener.bind(eventManager),
+            removeListener: eventManager.removeListener.bind(eventManager),
+            dispatch: (eventName: string, event: Record<string, unknown>): void => {
+                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);
+            },
+        };
+    }
+
+    public identify(userId: string): void {
+        this.setToken(Token.issue(this.sdk.appId, userId));
+    }
+
+    public anonymize(): void {
+        if (!this.context.isAnonymous()) {
+            this.unsetToken();
+        }
+    }
+
+    public getToken(): Token|null {
+        return this.context.getToken();
+    }
+
+    public setToken(token: Token): void {
+        const currentToken = this.getToken();
+
+        if (currentToken !== null && currentToken.toString() === token.toString()) {
+            return;
+        }
+
+        const currentSubject = currentToken?.getSubject() ?? null;
+        const subject = token.getSubject();
+        const logger = this.getLogger();
+
+        if (subject === currentSubject) {
+            this.context.setToken(token);
+
+            logger.debug('Token refreshed');
+
+            return;
+        }
+
+        if (currentSubject !== null) {
+            this.trackInternalEvent({
+                type: 'userSignedOut',
+                userId: currentSubject,
+            });
+
+            logger.info('User signed out');
+        }
+
+        this.context.setToken(token);
+
+        if (subject !== null) {
+            this.trackInternalEvent({
+                type: 'userSignedIn',
+                userId: subject,
+            });
+
+            logger.info(`User signed in as ${subject}`);
+        }
+
+        logger.debug('New token saved, ');
+    }
+
+    public unsetToken(): void {
+        const token = this.getToken();
+
+        if (token === null) {
+            return;
+        }
+
+        const logger = this.getLogger();
+        const subject = token.getSubject();
+
+        if (subject !== null) {
+            this.trackInternalEvent({
+                type: 'userSignedOut',
+                userId: subject,
+            });
+
+            logger.info('User signed out');
+        }
+
+        this.context.setToken(null);
+
+        logger.debug('Token removed');
+    }
+
+    private trackInternalEvent(event: PartialTrackingEvent): void {
+        this.sdk
+            .tracker
+            .track(event)
+            .catch(() => {
+                // suppress error as it is already logged by the tracker
+            });
+    }
+
+    public getLogger(...namespace: string[]): Logger {
+        return this.sdk.getLogger(...namespace);
+    }
+
+    public getTabStorage(namespace: string, ...subnamespace: string[]): Storage {
+        return this.sdk.getTabStorage(namespace, ...subnamespace);
+    }
+
+    public getBrowserStorage(namespace: string, ...subnamespace: string[]): Storage {
+        return this.sdk.getBrowserStorage(namespace, ...subnamespace);
+    }
+
+    public close(): Promise<void> {
+        return this.sdk.close();
+    }
+}

package/.src/facade/sessionFacade.ts

@@ -0,0 +1,14 @@
+import {Tracker} from '../tracker';
+import {SessionPatch} from './sessionPatch';
+
+export class SessionFacade {
+    private readonly tracker: Tracker;
+
+    public constructor(tracker: Tracker) {
+        this.tracker = tracker;
+    }
+
+    public edit(): SessionPatch {
+        return new SessionPatch(this.tracker);
+    }
+}

package/.src/facade/sessionPatch.ts

@@ -0,0 +1,32 @@
+import {ActiveRecord} from '../activeRecord';
+import {Tracker} from '../tracker';
+import {SessionAttributesChanged} from '../trackingEvents';
+
+export class SessionPatch extends ActiveRecord<SessionAttributesChanged> {
+    private readonly tracker: Tracker;
+
+    public constructor(tracker: Tracker) {
+        super();
+
+        this.tracker = tracker;
+    }
+
+    public save(): Promise<SessionAttributesChanged> {
+        if (!this.isDirty()) {
+            // Empty patch
+            return Promise.resolve({
+                type: 'sessionAttributesChanged',
+                patch: {operations: []},
+            });
+        }
+
+        const promise = this.tracker.track({
+            type: 'sessionAttributesChanged',
+            patch: this.buildPatch(),
+        });
+
+        this.reset();
+
+        return promise;
+    }
+}

package/.src/facade/trackerFacade.ts

@@ -0,0 +1,98 @@
+import {
+    ExternalTrackingEvent as ExternalEvent,
+    ExternalTrackingEventPayload as ExternalEventPayload,
+    ExternalTrackingEventType as ExternalEventType,
+} from '../trackingEvents';
+import {formatCause} from '../error';
+import {Tracker, EventListener} from '../tracker';
+import {
+    cartModified,
+    cartViewed,
+    checkoutStarted,
+    eventOccurred,
+    goalCompleted,
+    interestShown,
+    postViewed,
+    orderPlaced,
+    productViewed,
+    userSignedUp,
+    linkOpened,
+} from '../schema';
+
+const eventSchemas = {
+    cartViewed: cartViewed,
+    cartModified: cartModified,
+    checkoutStarted: checkoutStarted,
+    orderPlaced: orderPlaced,
+    productViewed: productViewed,
+    userSignedUp: userSignedUp,
+    eventOccurred: eventOccurred,
+    interestShown: interestShown,
+    postViewed: postViewed,
+    goalCompleted: goalCompleted,
+    linkOpened: linkOpened,
+};
+
+type UnknownEvent<T extends ExternalEventType> = Pick<ExternalEvent<T>, 'type'>;
+
+function validateEvent<T extends ExternalEventType>(event: UnknownEvent<T>): asserts event is ExternalEvent<T> {
+    const {type, ...payload} = event;
+
+    if (!(type in eventSchemas)) {
+        throw new Error(`Unknown event type '${type}'.`);
+    }
+
+    try {
+        eventSchemas[type].validate(payload);
+    } catch (violation) {
+        throw new Error(`Invalid event payload: ${formatCause(violation)}`);
+    }
+}
+
+function createEvent<T extends ExternalEventType>(type: T, payload: unknown): ExternalEvent<T> {
+    if (typeof type !== 'string') {
+        throw new Error('The event type must of type string.');
+    }
+
+    if (typeof payload !== 'object' || payload == null) {
+        throw new Error('The event payload must of type object.');
+    }
+
+    const event: UnknownEvent<T> = {type: type, ...payload};
+
+    validateEvent(event);
+
+    return event;
+}
+
+export class TrackerFacade {
+    private readonly tracker: Tracker;
+
+    public constructor(tracker: Tracker) {
+        this.tracker = tracker;
+    }
+
+    public get flushed(): Promise<void> {
+        return this.tracker.flushed;
+    }
+
+    public enable(): void {
+        this.tracker.enable();
+    }
+
+    public disable(): void {
+        this.tracker.disable();
+    }
+
+    public addListener(listener: EventListener): void {
+        this.tracker.addListener(listener);
+    }
+
+    public removeListener(listener: EventListener): void {
+        this.tracker.removeListener(listener);
+    }
+
+    public track<T extends ExternalEventType>(type: T, payload: ExternalEventPayload<T>): Promise<ExternalEvent<T>> {
+        return this.tracker.track(createEvent(type, payload));
+    }
+}

package/.src/facade/userFacade.ts

@@ -0,0 +1,26 @@
+import {Tracker} from '../tracker';
+import {UserPatch} from './userPatch';
+import {Context} from '../context';
+
+export class UserFacade {
+    private readonly context: Context;
+
+    private readonly tracker: Tracker;
+
+    public constructor(context: Context, tracker: Tracker) {
+        this.context = context;
+        this.tracker = tracker;
+    }
+
+    public isIdentified(): boolean {
+        return !this.isAnonymous();
+    }
+
+    public isAnonymous(): boolean {
+        return this.context.isAnonymous();
+    }
+
+    public edit(): UserPatch {
+        return new UserPatch(this.tracker);
+    }
+}

package/.src/facade/userPatch.ts

@@ -0,0 +1,32 @@
+import {ActiveRecord} from '../activeRecord';
+import {Tracker} from '../tracker';
+import {UserProfileChanged} from '../trackingEvents';
+
+export class UserPatch extends ActiveRecord<UserProfileChanged> {
+    private readonly tracker: Tracker;
+
+    public constructor(tracker: Tracker) {
+        super();
+
+        this.tracker = tracker;
+    }
+
+    public save(): Promise<UserProfileChanged> {
+        if (!this.isDirty()) {
+            // Empty patch
+            return Promise.resolve({
+                type: 'userProfileChanged',
+                patch: {operations: []},
+            });
+        }
+
+        const promise = this.tracker.track({
+            type: 'userProfileChanged',
+            patch: this.buildPatch(),
+        });
+
+        this.reset();
+
+        return promise;
+    }
+}

package/.src/index.ts

@@ -0,0 +1,4 @@
+import {VERSION} from './constants';
+import {Sdk, Configuration} from './sdk';
+
+export {Sdk, Configuration, VERSION};

package/.src/logging/consoleLogger.ts

@@ -0,0 +1,37 @@
+import {Logger} from './logger';
+
+type ConsoleMethod = {
+    (message?: any, ...optionalParams: any[]): void,
+};
+
+export class ConsoleLogger implements Logger {
+    private readonly namespace?: string;
+
+    public constructor(namespace?: string) {
+        this.namespace = namespace;
+    }
+
+    public get debug(): (message: string) => void {
+        return this.bind(window.console.debug);
+    }
+
+    public get info(): (message: string) => void {
+        return this.bind(window.console.info);
+    }
+
+    public get warn(): (message: string) => void {
+        return this.bind(window.console.warn);
+    }
+
+    public get error(): (message: string) => void {
+        return this.bind(window.console.error);
+    }
+
+    private bind(method: ConsoleMethod): ConsoleMethod {
+        if (this.namespace !== undefined) {
+            return method.bind(window.console, `[${this.namespace}]`);
+        }
+
+        return method.bind(window.console);
+    }
+}

package/.src/logging/index.ts

@@ -0,0 +1,4 @@
+export * from './logger';
+export {ConsoleLogger} from './consoleLogger';
+export {NamespacedLogger} from './namespacedLogger';
+export {NullLogger} from './nullLogger';

package/.src/logging/logger.ts

@@ -0,0 +1,13 @@
+export interface Logger {
+    debug(message: string): void;
+
+    info(message: string): void;
+
+    warn(message: string): void;
+
+    error(message: string): void;
+}
+
+export interface LoggerFactory {
+    (namespace?: string): Logger;
+}

package/.src/logging/namespacedLogger.ts

@@ -0,0 +1,32 @@
+import {Logger} from './logger';
+
+export class NamespacedLogger implements Logger {
+    private readonly logger: Logger;
+
+    private readonly namespace: string;
+
+    public constructor(logger: Logger, namespace: string) {
+        this.logger = logger;
+        this.namespace = namespace;
+    }
+
+    public debug(message: string): void {
+        this.logger.debug(this.format(message));
+    }
+
+    public info(message: string): void {
+        this.logger.info(this.format(message));
+    }
+
+    public warn(message: string): void {
+        this.logger.warn(this.format(message));
+    }
+
+    public error(message: string): void {
+        this.logger.error(this.format(message));
+    }
+
+    private format(message: string): string {
+        return `[${this.namespace}] ${message}`;
+    }
+}

package/.src/logging/nullLogger.ts

@@ -0,0 +1,19 @@
+import {Logger} from './logger';
+
+export class NullLogger implements Logger {
+    public debug(): void {
+        // suppress debug logs
+    }
+
+    public info(): void {
+        // suppress info logs
+    }
+
+    public warn(): void {
+        // suppress warning logs
+    }
+
+    public error(): void {
+        // suppress error logs
+    }
+}

package/.src/namespacedStorage.ts

@@ -0,0 +1,69 @@
+export class NamespacedStorage implements Storage {
+    private readonly storage: Storage;
+
+    private readonly namespace: string;
+
+    public constructor(storage: Storage, namespace: string) {
+        if (namespace === '') {
+            throw new Error('The namespace cannot be empty.');
+        }
+
+        this.storage = storage;
+        this.namespace = namespace;
+    }
+
+    public get length(): number {
+        return this.getKeys().length;
+    }
+
+    public clear(): void {
+        for (const key of this.getKeys()) {
+            this.storage.removeItem(key);
+        }
+    }
+
+    public getItem(key: string): string | null {
+        return this.storage.getItem(this.getPrefixedKey(key));
+    }
+
+    public key(index: number): string | null {
+        const keys = this.getKeys();
+
+        if (index >= keys.length) {
+            return null;
+        }
+
+        return keys[index].substring(this.namespace.length + 1);
+    }
+
+    public removeItem(key: string): void {
+        this.storage.removeItem(this.getPrefixedKey(key));
+    }
+
+    public setItem(key: string, value: string): void {
+        this.storage.setItem(this.getPrefixedKey(key), value);
+    }
+
+    private getKeys(): string[] {
+        const keys = [];
+        const prefix = this.getPrefix();
+
+        for (let index = 0; index < this.storage.length; index++) {
+            const key = this.storage.key(index);
+
+            if (key !== null && key.indexOf(prefix) === 0) {
+                keys.push(key);
+            }
+        }
+
+        return keys;
+    }
+
+    private getPrefixedKey(key: string): string {
+        return this.getPrefix() + key;
+    }
+
+    private getPrefix(): string {
+        return `${this.namespace}.`;
+    }
+}