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

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';

package/src/channel/queuedChannel.ts

@@ -0,0 +1,112 @@
+import {OutputChannel} from './channel';
+import {Queue} from '../queue';
+import {Logger, NullLogger} from '../logging';
+
+export class QueuedChannel<T> implements OutputChannel<T> {
+    private readonly channel: OutputChannel<T>;
+
+    private readonly queue: Queue<T>;
+
+    private readonly logger: Logger;
+
+    private pending?: Promise<void>;
+
+    private closed = false;
+
+    public constructor(channel: OutputChannel<T>, queue: Queue<T>, logger?: Logger) {
+        this.channel = channel;
+        this.queue = queue;
+        this.logger = logger ?? new NullLogger();
+    }
+
+    public flush(): Promise<void> {
+        if (this.pending === undefined) {
+            return this.requeue();
+        }
+
+        return this.pending.catch(this.requeue.bind(this));
+    }
+
+    public publish(message: T): Promise<void> {
+        if (this.closed) {
+            return Promise.reject(new Error('Channel is closed.'));
+        }
+
+        if (this.queue.length() >= this.queue.getCapacity()) {
+            this.logger.warn('The queue is full, message rejected.');
+
+            return Promise.reject(new Error('The queue is full.'));
+        }
+
+        if (this.pending === undefined) {
+            this.pending = this.queue.isEmpty()
+                ? Promise.resolve()
+                : Promise.reject(new Error('The queue must be flushed.'));
+        }
+
+        this.enqueue(message);
+
+        this.pending = this.pending.then(
+            () => this.channel
+                .publish(message)
+                .then(this.dequeue.bind(this)),
+        );
+
+        return this.pending;
+    }
+
+    private enqueue(message: T): void {
+        this.logger.debug('Enqueueing message...');
+        this.logger.debug(`Queue length: ${this.queue.length() + 1}`);
+
+        this.queue.push(message);
+    }
+
+    private dequeue(): void {
+        this.logger.debug('Dequeuing message...');
+        this.logger.debug(`Queue length: ${Math.max(0, this.queue.length() - 1)}`);
+
+        this.queue.shift();
+    }
+
+    private requeue(): Promise<void> {
+        if (this.closed) {
+            return Promise.reject(new Error('Channel is closed.'));
+        }
+
+        this.pending = Promise.resolve();
+
+        if (this.queue.isEmpty()) {
+            return this.pending;
+        }
+
+        const length = this.queue.length();
+
+        this.logger.debug('Requeuing messages...');
+        this.logger.debug(`Queue length: ${length}`);
+
+        for (const message of this.queue.all()) {
+            this.pending = this.pending.then(
+                () => this.channel
+                    .publish(message)
+                    .then(this.dequeue.bind(this)),
+            );
+        }
+
+        return this.pending;
+    }
+
+    public async close(): Promise<void> {
+        this.closed = true;
+
+        await this.channel.close();
+
+        if (this.pending !== undefined) {
+            try {
+                await this.pending;
+            } catch {
+                // suppress errors
+            }
+        }
+    }
+}

package/src/channel/retryChannel.ts

@@ -0,0 +1,90 @@
+import {OutputChannel} from './channel';
+import {Logger, NullLogger} from '../logging';
+import {RetryPolicy} from '../retry';
+
+type Configuration<T> = {
+    channel: OutputChannel<T>,
+    retryPolicy: RetryPolicy<T>,
+    logger?: Logger,
+};
+
+export class RetryChannel<T> implements OutputChannel<T> {
+    private readonly channel: OutputChannel<T>;
+
+    private readonly retryPolicy: RetryPolicy<T>;
+
+    private readonly logger: Logger;
+
+    private closed = false;
+
+    public constructor({channel, retryPolicy, logger}: Configuration<T>) {
+        this.channel = channel;
+        this.retryPolicy = retryPolicy;
+        this.logger = logger ?? new NullLogger();
+    }
+
+    public publish(message: T): Promise<void> {
+        if (this.closed) {
+            return Promise.reject(new Error('The channel is closed.'));
+        }
+
+        return this.channel
+            .publish(message)
+            .catch(error => this.retry(message, error));
+    }
+
+    public async retry(message: T, error: unknown): Promise<void> {
+        let attempt = 0;
+
+        while (this.retryPolicy.shouldRetry(attempt, message, error)) {
+            if (this.closed) {
+                throw new Error('Connection deliberately closed.');
+            }
+
+            const delay = this.retryPolicy.getDelay(attempt);
+
+            this.logger.debug(`Retry attempt ${attempt + 1}`);
+
+            if (delay > 0) {
+                this.logger.debug(`Retry attempt delayed in ${delay}ms`);
+
+                await new Promise<void>((resolve, reject): void => {
+                    const closeWatcher = window.setInterval(
+                        () => {
+                            if (this.closed) {
+                                // Cancel delay immediately when the channel is closed
+                                window.clearInterval(closeWatcher);
+
+                                reject(new Error('Connection deliberately closed.'));
+                            }
+                        },
+                        0,
+                    );
+
+                    window.setTimeout(
+                        (): void => {
+                            window.clearInterval(closeWatcher);
+
+                            resolve();
+                        },
+                        delay,
+                    );
+                });
+            }
+
+            try {
+                return await this.channel.publish(message);
+            } catch {
+                attempt += 1;
+            }
+        }
+
+        throw new Error('Maximum retry attempts reached.');
+    }
+
+    public close(): Promise<void> {
+        this.closed = true;
+
+        return this.channel.close();
+    }
+}

package/src/channel/sandboxChannel.ts

@@ -0,0 +1,43 @@
+import {ChannelListener, DuplexChannel} from './channel';
+
+export class SandboxChannel<I, O> implements DuplexChannel<I, O> {
+    private readonly listeners: Array<ChannelListener<I>> = [];
+
+    public readonly messages: O[] = [];
+
+    private closed = false;
+
+    public publish(message: O): Promise<void> {
+        this.messages.push(message);
+
+        return Promise.resolve();
+    }
+
+    public notify(message: I): void {
+        this.listeners.forEach(dispatch => dispatch(message));
+    }
+
+    public subscribe(listener: ChannelListener<I>): void {
+        if (!this.listeners.includes(listener)) {
+            this.listeners.push(listener);
+        }
+    }
+
+    public unsubscribe(listener: ChannelListener<I>): void {
+        const index = this.listeners.indexOf(listener);
+
+        if (index >= 0) {
+            this.listeners.splice(index, 1);
+        }
+    }
+
+    public close(): Promise<void> {
+        this.closed = true;
+
+        return Promise.resolve();
+    }
+
+    public isClosed(): boolean {
+        return this.closed;
+    }
+}