@croct/sdk 0.17.10 → 0.17.11

package/src/facade/sdkFacade.ts

@@ -1,310 +0,0 @@
-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';
-import {CookieCacheConfiguration} from '../cache/cookieCache';
-import {EventSubjectProcessor} from '../eventSubjectProcessor';
-
-export type Configuration = {
-    appId: string,
-    tokenScope?: TokenScope,
-    debug?: boolean,
-    test?: boolean,
-    track?: boolean,
-    token?: string | null,
-    userId?: string | null,
-    clientId?: string,
-    eventMetadata?: {[key: string]: string},
-    logger?: Logger,
-    urlSanitizer?: UrlSanitizer,
-    baseEndpointUrl?: string,
-    disableCidMirroring?: boolean,
-    cidAssignerEndpointUrl?: string,
-    cookie?: {
-        clientId?: CookieCacheConfiguration,
-        userToken?: CookieCacheConfiguration,
-        previewToken?: CookieCacheConfiguration,
-    },
-    defaultFetchTimeout?: number,
-    defaultPreferredLocale?: 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,
-                disableCidMirroring: containerConfiguration.disableCidMirroring ?? false,
-                eventProcessor: container => new EventSubjectProcessor(container.getLogger('EventSubjectProcessor')),
-            }),
-        );
-
-        if (userId !== undefined) {
-            const currentToken = sdk.context.getToken();
-            const currentSubject = currentToken?.getSubject() ?? null;
-
-            if (currentSubject !== userId) {
-                if (userId === null) {
-                    sdk.unsetToken();
-                } else {
-                    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

@@ -1,14 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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/help.ts

@@ -1,24 +0,0 @@
-export namespace Help {
-  export function forStatusCode(statusCode: number): string|undefined {
-      switch (statusCode) {
-          case 401:
-              return 'The request was not authorized, most likely due to invalid credentials. '
-                  + 'For help, see https://croct.help/sdk/javascript/invalid-credentials';
-
-          case 403:
-              return 'The origin of the request is not allowed in your application settings. '
-                  + 'For help, see https://croct.help/sdk/javascript/unauthorized-origin';
-
-          case 408:
-              return 'The request timed out. '
-                    + 'For help, see https://croct.help/sdk/javascript/request-timeout';
-
-          case 423:
-              return 'The application has exceeded the monthly active users (MAU) quota. '
-                  + 'For help, see https://croct.help/sdk/javascript/mau-exceeded';
-
-          default:
-              return undefined;
-      }
-  }
-}

package/src/index.ts

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

package/src/logging/consoleLogger.ts

@@ -1,38 +0,0 @@
-/* eslint-disable no-console -- This is a logging utility */
-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(console.debug);
-    }
-
-    public get info(): (message: string) => void {
-        return this.bind(console.info);
-    }
-
-    public get warn(): (message: string) => void {
-        return this.bind(console.warn);
-    }
-
-    public get error(): (message: string) => void {
-        return this.bind(console.error);
-    }
-
-    private bind(method: ConsoleMethod): ConsoleMethod {
-        if (this.namespace !== undefined) {
-            return method.bind(console, `[${this.namespace}]`);
-        }
-
-        return method.bind(console);
-    }
-}

package/src/logging/filteredLogger.ts

@@ -1,57 +0,0 @@
-import {Logger} from './logger';
-
-export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-
-export type LogFilter = (level: LogLevel, message: string) => boolean;
-
-export type FilteredLoggerConfiguration = {
-    logger: Logger,
-    allowFilter: LogFilter,
-};
-
-export class FilteredLogger implements Logger {
-    private readonly logger: Logger;
-
-    private readonly allowFilter: LogFilter;
-
-    public constructor(configuration: FilteredLoggerConfiguration) {
-        this.logger = configuration.logger;
-        this.allowFilter = configuration.allowFilter;
-    }
-
-    public static include(logger: Logger, levels: LogLevel[]): Logger {
-        return new FilteredLogger({
-            logger: logger,
-            allowFilter: (level: LogLevel): boolean => levels.includes(level),
-        });
-    }
-
-    public static exclude(logger: Logger, levels: LogLevel[]): FilteredLogger {
-        return new FilteredLogger({
-            logger: logger,
-            allowFilter: (level: LogLevel): boolean => !levels.includes(level),
-        });
-    }
-
-    public debug(message: string): void {
-        this.log('debug', message);
-    }
-
-    public info(message: string): void {
-        this.log('info', message);
-    }
-
-    public warn(message: string): void {
-        this.log('warn', message);
-    }
-
-    public error(message: string): void {
-        this.log('error', message);
-    }
-
-    private log(level: LogLevel, message: string): void {
-        if (this.allowFilter(level, message)) {
-            this.logger[level](message);
-        }
-    }
-}

package/src/logging/index.ts

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

package/src/logging/logger.ts

@@ -1,13 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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}`;
-    }
-}