@croct/sdk 0.10.0 → 0.11.0-alpha.1

package/.src/activeRecord.ts

@@ -0,0 +1,150 @@
+import {JsonStructure, JsonValue} from '@croct/json';
+import {Operation, Patch} from './patch';
+import {TrackingEvent} from './trackingEvents';
+import {
+    addOperation,
+    clearOperation,
+    combineOperation,
+    decrementOperation,
+    incrementOperation,
+    mergeOperation,
+    setOperation,
+    unsetOperation,
+    removeOperation,
+} from './schema';
+
+const operationSchema = {
+    add: addOperation,
+    set: setOperation,
+    merge: mergeOperation,
+    combine: combineOperation,
+    increment: incrementOperation,
+    decrement: decrementOperation,
+    clear: clearOperation,
+    unset: unsetOperation,
+    remove: removeOperation,
+};
+
+export abstract class ActiveRecord<T extends TrackingEvent> {
+    private readonly operations: Operation[] = [];
+
+    public set(value: JsonValue): this;
+
+    public set(property: string, value: JsonValue): this;
+
+    public set(propertyOrValue: string | JsonValue, value?: JsonValue): this {
+        if (typeof propertyOrValue === 'string') {
+            return this.pushOperation({
+                type: 'set',
+                path: propertyOrValue,
+                value: value as JsonValue,
+            });
+        }
+
+        return this.pushOperation({
+            type: 'set',
+            path: '.',
+            value: propertyOrValue,
+        });
+    }
+
+    public add(property: string, value: JsonValue): this {
+        return this.pushOperation({
+            type: 'add',
+            path: property,
+            value: value,
+        });
+    }
+
+    public combine(property: string, value: JsonValue): this {
+        return this.pushOperation({
+            type: 'combine',
+            path: property,
+            value: value,
+        });
+    }
+
+    public merge(value: JsonStructure): this;
+
+    public merge(property: string, value: JsonStructure): this;
+
+    public merge(propertyOrValue: string | JsonStructure, value?: JsonStructure): this {
+        if (typeof propertyOrValue === 'string') {
+            return this.pushOperation({
+                type: 'merge',
+                path: propertyOrValue,
+                value: value as JsonStructure,
+            });
+        }
+
+        return this.pushOperation({
+            type: 'merge',
+            path: '.',
+            value: propertyOrValue,
+        });
+    }
+
+    public increment(property: string, amount = 1): this {
+        return this.pushOperation({
+            type: 'increment',
+            path: property,
+            value: amount,
+        });
+    }
+
+    public decrement(property: string, amount = 1): this {
+        return this.pushOperation({
+            type: 'decrement',
+            path: property,
+            value: amount,
+        });
+    }
+
+    public clear(property: string): this {
+        return this.pushOperation({
+            type: 'clear',
+            path: property,
+        });
+    }
+
+    public unset(property: string): this {
+        return this.pushOperation({
+            type: 'unset',
+            path: property,
+        });
+    }
+
+    public remove(property: string, value: JsonValue): this {
+        return this.pushOperation({
+            type: 'remove',
+            path: property,
+            value: value,
+        });
+    }
+
+    private pushOperation(operation: Operation): this {
+        const {type, ...data} = operation;
+
+        operationSchema[type].validate(data);
+
+        this.operations.push(operation);
+
+        return this;
+    }
+
+    protected reset(): this {
+        this.operations.splice(0);
+
+        return this;
+    }
+
+    public abstract save(): Promise<T>;
+
+    protected isDirty(): boolean {
+        return this.operations.length > 0;
+    }
+
+    protected buildPatch(): Patch {
+        return {operations: this.operations.slice()};
+    }
+}

package/.src/base64Url.ts

@@ -0,0 +1,18 @@
+function base64Unescape(value: string): string {
+    return (value + '==='.slice((value.length + 3) % 4)).replace(/-/g, '+').replace(/_/g, '/');
+}
+
+function base64Escape(value: string): string {
+    return value
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=/g, '');
+}
+
+export function base64UrlEncode(value: string): string {
+    return base64Escape(window.btoa(value));
+}
+
+export function base64UrlDecode(value: string): string {
+    return window.atob(base64Unescape(value));
+}

package/.src/cache/cache.ts

@@ -0,0 +1,15 @@
+export interface Cache {
+    get(): string|null;
+    put(value: string): void;
+    clear(): void;
+}
+
+export interface CacheListener {
+    (value: string|null): void;
+}
+
+export interface ObservableCache extends Cache {
+    addListener(listener: CacheListener): void;
+
+    removeListener(listener: CacheListener): void;
+}

package/.src/cache/fallbackCache.ts

@@ -0,0 +1,29 @@
+import {Cache} from './cache';
+
+export class FallbackCache implements Cache {
+    private readonly caches: Cache[];
+
+    public constructor(...caches: Cache[]) {
+        this.caches = caches;
+    }
+
+    public get(): string|null {
+        for (const cache of this.caches) {
+            const value = cache.get();
+
+            if (value !== null) {
+                return value;
+            }
+        }
+
+        return null;
+    }
+
+    public put(value: string): void {
+        this.caches.forEach(cache => cache.put(value));
+    }
+
+    public clear(): void {
+        this.caches.forEach(cache => cache.clear());
+    }
+}

package/.src/cache/inMemoryCache.ts

@@ -0,0 +1,21 @@
+import {Cache} from './cache';
+
+export class InMemoryCache implements Cache {
+    private cache?: string;
+
+    public constructor(cache?: string) {
+        this.cache = cache;
+    }
+
+    public get(): string | null {
+        return this.cache ?? null;
+    }
+
+    public put(value: string): void {
+        this.cache = value;
+    }
+
+    public clear(): void {
+        delete this.cache;
+    }
+}

package/.src/cache/index.ts

@@ -0,0 +1,4 @@
+export * from './cache';
+export {FallbackCache} from './fallbackCache';
+export {InMemoryCache} from './inMemoryCache';
+export {LocalStorageCache} from './localStorageCache';

package/.src/cache/localStorageCache.ts

@@ -0,0 +1,85 @@
+import {CacheListener, ObservableCache} from './cache';
+
+export class LocalStorageCache implements ObservableCache {
+    private readonly storage: Storage;
+
+    private readonly key: string;
+
+    private value: string|null;
+
+    private readonly listeners: CacheListener[] = [];
+
+    public constructor(storage: Storage, key: string) {
+        this.storage = storage;
+        this.key = key;
+        this.value = storage.getItem(key);
+    }
+
+    public static autoSync(cache: LocalStorageCache): (() => void) {
+        const listener = cache.sync.bind(cache);
+
+        window.addEventListener('storage', listener);
+
+        return (): void => window.removeEventListener('storage', listener);
+    }
+
+    public get(): string|null {
+        return this.value;
+    }
+
+    public put(value: string): void {
+        this.storage.setItem(this.key, value);
+
+        if (this.value !== value) {
+            this.value = value;
+            this.notifyChange(value);
+        }
+    }
+
+    public clear(): void {
+        this.storage.removeItem(this.key);
+
+        if (this.value !== null) {
+            this.value = null;
+            this.notifyChange(null);
+        }
+    }
+
+    public addListener(listener: CacheListener): void {
+        if (!this.listeners.includes(listener)) {
+            this.listeners.push(listener);
+        }
+    }
+
+    public removeListener(listener: CacheListener): void {
+        const index = this.listeners.indexOf(listener);
+
+        if (index > -1) {
+            this.listeners.splice(index, 1);
+        }
+    }
+
+    private notifyChange(value: string|null): void {
+        this.listeners.forEach(listener => listener(value));
+    }
+
+    private sync(event: StorageEvent): void {
+        if (event.storageArea !== this.storage || (event.key !== null && event.key !== this.key)) {
+            // Ignore unrelated changes
+            return;
+        }
+
+        /*
+         * Retrieving the value from the store rather than the event ensures
+         * the cache will be in sync with the latest value set.
+         * In case of cascading changes, it prevents notifying listeners
+         * about intermediate states already outdated at this point.
+         */
+        const value = this.storage.getItem(this.key);
+
+        if (this.value !== value) {
+            this.value = value;
+            this.notifyChange(value);
+        }
+    }
+}

package/.src/channel/beaconSocketChannel.ts

@@ -0,0 +1,153 @@
+import {ChannelListener, DuplexChannel} from './channel';
+import {Envelope} from './guaranteedChannel';
+import {Logger, LoggerFactory, NullLogger} from '../logging';
+import {CidAssigner} from '../cid';
+
+export interface DuplexChannelFactory {
+    (url: string, logger: Logger): DuplexChannel<string, string>;
+}
+
+type Configuration = {
+    logger?: Logger,
+    loggerFactory?: LoggerFactory,
+    tokenParameter: string,
+    trackerEndpointUrl: string,
+    channelFactory: DuplexChannelFactory,
+    cidAssigner: CidAssigner,
+    cidParameter: string,
+};
+
+type Violation = {
+    message: string,
+    path: string,
+};
+
+type Confirmation = {
+    receiptId: string | null,
+    violations?: Violation[],
+};
+
+export class BeaconSocketChannel implements DuplexChannel<string, Envelope<string, string>> {
+    private readonly socketFactory: DuplexChannelFactory;
+
+    private readonly logger: Logger;
+
+    private readonly loggerFactory: LoggerFactory;
+
+    private readonly cidAssigner: CidAssigner;
+
+    private readonly cidParameter: string;
+
+    private readonly tokenParameter: string;
+
+    private readonly trackerEndpointUrl: string;
+
+    private readonly listeners: Array<ChannelListener<string>> = [];
+
+    private socketChannel?: DuplexChannel<string, string>;
+
+    private token?: string;
+
+    private connectionIndex = 0;
+
+    public constructor(configuration: Configuration) {
+        this.socketFactory = configuration.channelFactory;
+        this.logger = configuration.logger ?? new NullLogger();
+        this.loggerFactory = configuration.loggerFactory ?? ((): Logger => new NullLogger());
+        this.cidAssigner = configuration.cidAssigner;
+        this.cidParameter = configuration.cidParameter;
+        this.trackerEndpointUrl = configuration.trackerEndpointUrl;
+        this.tokenParameter = configuration.tokenParameter;
+        this.notify = this.notify.bind(this);
+    }
+
+    public async publish({id: receiptId, message}: Envelope<string, string>): Promise<void> {
+        const {token, timestamp, context, payload} = JSON.parse(message);
+
+        if (this.token !== token || this.socketChannel === undefined) {
+            if (this.socketChannel !== undefined) {
+                this.logger.info('Connection no longer valid for current message.');
+
+                this.socketChannel.unsubscribe(this.notify);
+
+                await this.socketChannel.close();
+            }
+
+            this.token = token;
+            this.socketChannel = await this.createSocketChannel(token);
+        }
+
+        return this.socketChannel.publish(
+            JSON.stringify({
+                receiptId: receiptId,
+                originalTime: timestamp,
+                departureTime: Date.now(),
+                context: context,
+                payload: payload,
+            }),
+        );
+    }
+
+    private async createSocketChannel(token?: string): Promise<DuplexChannel<string, string>> {
+        const endpoint = new URL(this.trackerEndpointUrl);
+
+        endpoint.searchParams.append(this.cidParameter, await this.cidAssigner.assignCid());
+
+        if (token !== undefined) {
+            endpoint.searchParams.append(this.tokenParameter, token);
+        }
+
+        const channel: DuplexChannel<string, string> = this.socketFactory(
+            endpoint.toString(),
+            this.loggerFactory(`WebSocket#${this.connectionIndex}`),
+        );
+
+        this.connectionIndex += 1;
+
+        channel.subscribe(this.notify);
+
+        return channel;
+    }
+
+    public subscribe(listener: ChannelListener<string>): void {
+        if (!this.listeners.includes(listener)) {
+            this.listeners.push(listener);
+        }
+    }
+
+    public unsubscribe(listener: ChannelListener<string>): void {
+        const index = this.listeners.indexOf(listener);
+
+        if (index >= 0) {
+            this.listeners.splice(index, 1);
+        }
+    }
+
+    private notify(message: string): void {
+        let confirmation: Confirmation;
+
+        try {
+            confirmation = JSON.parse(message);
+        } catch {
+            this.logger.error('Invalid JSON message received.');
+
+            return;
+        }
+
+        const {violations = [], receiptId} = confirmation;
+
+        violations.forEach(violation => this.logger.error(violation.message));
+
+        if (receiptId !== null) {
+            this.listeners.forEach(dispatch => dispatch(receiptId));
+        }
+    }
+
+    public close(): Promise<void> {
+        if (this.socketChannel === undefined) {
+            return Promise.resolve();
+        }
+
+        return this.socketChannel.close();
+    }
+}

package/.src/channel/channel.ts

@@ -0,0 +1,20 @@
+export interface Closeable {
+    close(): Promise<void>;
+}
+
+export interface OutputChannel<O> extends Closeable {
+    publish(message: O): Promise<void>;
+}
+
+export type ChannelListener<T> = {
+    (message: T): void,
+};
+
+export interface InputChannel<I> extends Closeable {
+    subscribe(listener: ChannelListener<I>): void;
+
+    unsubscribe(listener: ChannelListener<I>): void;
+}
+
+export interface DuplexChannel<I, O> extends InputChannel<I>, OutputChannel<O> {
+}

package/.src/channel/encodedChannel.ts

@@ -0,0 +1,21 @@
+import {OutputChannel} from './channel';
+import {Transformer} from '../transformer';
+
+export class EncodedChannel<D, E> implements OutputChannel<D> {
+    private readonly encode: Transformer<D, E>;
+
+    private readonly channel: OutputChannel<E>;
+
+    public constructor(channel: OutputChannel<E>, encoder: Transformer<D, E>) {
+        this.channel = channel;
+        this.encode = encoder;
+    }
+
+    public publish(message: D): Promise<void> {
+        return this.encode(message).then((result => this.channel.publish(result)));
+    }
+
+    public close(): Promise<void> {
+        return this.channel.close();
+    }
+}

package/.src/channel/guaranteedChannel.ts

@@ -0,0 +1,131 @@
+import {Logger, NullLogger} from '../logging';
+import {DuplexChannel, OutputChannel} from './channel';
+
+export type MessageStamper<M, S> = {
+    generate(message: M): S,
+};
+
+export class TimeStamper implements MessageStamper<any, string> {
+    public generate(): string {
+        return String(Date.now());
+    }
+}
+
+export type Envelope<M, S> = {
+    id: S,
+    message: M,
+};
+
+type Options = {
+    ackTimeout: number,
+};
+
+type Configuration<M, S> = Partial<Options> & {
+    channel: DuplexChannel<S, Envelope<M, S>>,
+    stamper: MessageStamper<M, S>,
+    logger?: Logger,
+};
+
+export class GuaranteedChannel<M, S> implements OutputChannel<M> {
+    private readonly channel: DuplexChannel<S, Envelope<M, S>>;
+
+    private readonly stamper: MessageStamper<M, S>;
+
+    private readonly logger: Logger;
+
+    private readonly options: Options;
+
+    private closed = false;
+
+    public constructor({channel, logger, stamper, ...options}: Configuration<M, S>) {
+        this.channel = channel;
+        this.logger = logger ?? new NullLogger();
+        this.stamper = stamper;
+        this.options = {
+            ...options,
+            ackTimeout: options.ackTimeout ?? 5000,
+        };
+    }
+
+    public publish(message: M): Promise<void> {
+        if (this.closed) {
+            return Promise.reject(new Error('Channel is closed.'));
+        }
+
+        return new Promise((resolve, reject): void => {
+            const id = this.stamper.generate(message);
+
+            let timeoutTimer: number;
+            let closeWatcher: number;
+            let confirmed = false;
+            const start = Date.now();
+
+            const acknowledge = (response: any): void => {
+                if (response === id) {
+                    confirmed = true;
+
+                    const elapsed = Date.now() - start;
+
+                    window.clearTimeout(timeoutTimer);
+                    window.clearInterval(closeWatcher);
+
+                    this.logger.debug(`Delivery confirmed #${id}, elapsed ${elapsed}ms.`);
+
+                    this.channel.unsubscribe(acknowledge);
+
+                    resolve();
+                }
+            };
+
+            this.channel.subscribe(acknowledge);
+
+            const abort = (error: any): void => {
+                window.clearTimeout(timeoutTimer);
+                window.clearInterval(closeWatcher);
+
+                this.logger.error(`Failed to send message #${id}`);
+
+                this.channel.unsubscribe(acknowledge);
+
+                reject(error);
+            };
+
+            const wait = (): void => {
+                if (confirmed) {
+                    return;
+                }
+
+                closeWatcher = window.setInterval(
+                    () => {
+                        if (this.closed) {
+                            // Cancel delay immediately when the channel is closed
+                            abort(new Error('Connection deliberately closed.'));
+                        }
+                    },
+                    0,
+                );
+
+                this.logger.debug(`Waiting confirmation #${id}...`);
+
+                timeoutTimer = window.setTimeout(
+                    () => {
+                        abort(new Error('Maximum confirmation time reached.'));
+                    },
+                    this.options.ackTimeout,
+                );
+            };
+
+            this.logger.debug(`Sending message #${id}...`);
+
+            this.channel
+                .publish({id: id, message: message})
+                .then(wait, abort);
+        });
+    }
+
+    public close(): Promise<void> {
+        this.closed = true;
+
+        return this.channel.close();
+    }
+}

package/.src/channel/index.ts

@@ -0,0 +1,8 @@
+export * from './channel';
+export {BeaconSocketChannel, DuplexChannelFactory} from './beaconSocketChannel';
+export {EncodedChannel} from './encodedChannel';
+export {GuaranteedChannel} from './guaranteedChannel';
+export {QueuedChannel} from './queuedChannel';
+export {RetryChannel} from './retryChannel';
+export {SandboxChannel} from './sandboxChannel';
+export {SocketChannel} from './socketChannel';