@croct/sdk 0.10.0 → 0.11.0-alpha.1

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;
+    }
+}

package/.src/channel/socketChannel.ts

@@ -0,0 +1,217 @@
+import {Logger, NullLogger} from '../logging';
+import {ChannelListener, DuplexChannel} from './channel';
+import {formatCause} from '../error';
+
+type Input = string | ArrayBufferLike | Blob | ArrayBufferView;
+type Output = string | ArrayBuffer | Blob;
+
+type Options = {
+    closeTimeout: number,
+    connectionTimeout: number,
+    protocols: string | string[],
+    binaryType?: BinaryType,
+};
+
+export type Configuration = Partial<Options> & {
+    url: string,
+    logger?: Logger,
+};
+
+export class SocketChannel<I extends Input, O extends Output> implements DuplexChannel<I, O> {
+    private readonly url: string;
+
+    private readonly logger: Logger;
+
+    private readonly options: Options;
+
+    private readonly listeners: Array<ChannelListener<I>> = [];
+
+    private connection?: Promise<WebSocket>;
+
+    private closed = false;
+
+    public constructor({url, logger, ...options}: Configuration) {
+        this.url = url;
+        this.logger = logger ?? new NullLogger();
+        this.options = {
+            ...options,
+            closeTimeout: options.closeTimeout ?? 5000,
+            connectionTimeout: options.connectionTimeout ?? 10000,
+            protocols: options.protocols ?? [],
+        };
+    }
+
+    public get connected(): Promise<boolean> {
+        if (this.connection === undefined) {
+            return Promise.resolve(false);
+        }
+
+        return this.connection.then(() => true, () => false);
+    }
+
+    public publish(message: O): Promise<void> {
+        return this.connect().then(socket => {
+            socket.send(message);
+
+            this.logger.debug('Message sent.');
+        });
+    }
+
+    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);
+        }
+    }
+
+    private notify(message: I): void {
+        this.listeners.forEach(dispatch => dispatch(message));
+    }
+
+    private connect(): Promise<WebSocket> {
+        if (this.closed) {
+            return Promise.reject(new Error('Channel has been closed.'));
+        }
+
+        if (this.connection !== undefined) {
+            return this.connection
+                .then(connection => {
+                    const state = connection.readyState;
+
+                    if (state === WebSocket.OPEN) {
+                        return connection;
+                    }
+
+                    throw new Error('Connection lost.');
+                })
+                .catch(() => {
+                    // Reconnect
+                    delete this.connection;
+
+                    return this.connect();
+                });
+        }
+
+        this.connection = new Promise((resolve, reject): void => {
+            this.logger.debug('Connecting...');
+
+            const connection = new window.WebSocket(this.url, this.options.protocols);
+
+            if (this.options.binaryType !== undefined) {
+                connection.binaryType = this.options.binaryType;
+            }
+
+            const abortListener = (): void => {
+                const reason = 'Maximum connection timeout reached.';
+
+                this.logger.error(reason);
+
+                reject(new Error(reason));
+
+                connection.close(1000, reason);
+            };
+
+            const abortTimer: number = window.setTimeout(abortListener, this.options.connectionTimeout);
+
+            const openListener = (): void => {
+                window.clearTimeout(abortTimer);
+
+                this.logger.info('Connection established.');
+
+                connection.removeEventListener('open', openListener);
+
+                resolve(connection);
+            };
+
+            const errorListener = (): void => {
+                if (!this.closed) {
+                    this.logger.error('Connection error.');
+                }
+            };
+
+            const messageListener = (event: MessageEvent): void => {
+                this.logger.debug('Message received.');
+
+                this.notify(event.data);
+            };
+
+            const closeListener = (event: CloseEvent): void => {
+                window.clearTimeout(abortTimer);
+
+                const reason = `${formatCause(event.reason ?? 'unknown')} (code ${event.code})`;
+                const message = `Connection has been closed, reason: ${reason}`;
+
+                if (!this.closed) {
+                    this.logger.info(message);
+                }
+
+                connection.removeEventListener('open', openListener);
+                connection.removeEventListener('error', errorListener);
+                connection.removeEventListener('close', closeListener);
+                connection.removeEventListener('message', messageListener);
+
+                reject(new Error(message));
+            };
+
+            connection.addEventListener('open', openListener, {once: true});
+            connection.addEventListener('close', closeListener, {once: true});
+            connection.addEventListener('error', errorListener);
+            connection.addEventListener('message', messageListener);
+        });
+
+        return this.connection;
+    }
+
+    public close(): Promise<void> {
+        this.logger.debug('Closing connection...');
+
+        return new Promise((resolve, reject): void => {
+            this.closed = true;
+
+            if (this.connection === undefined) {
+                this.logger.debug('Connection is not open.');
+
+                resolve();
+
+                return;
+            }
+
+            this.connection.then(
+                (connection): void => {
+                    let abortTimer: number | undefined;
+
+                    const abort = (): void => {
+                        this.logger.warn('Connection could not be closed within the timeout period.');
+
+                        reject(new Error('Maximum close timeout reached.'));
+                    };
+
+                    const close = (): void => {
+                        window.clearTimeout(abortTimer);
+
+                        this.logger.info('Connection gracefully closed.');
+
+                        resolve();
+                    };
+
+                    connection.addEventListener('close', close, {once: true});
+                    connection.close(1000, 'Deliberate disconnection.');
+
+                    abortTimer = window.setTimeout(abort, this.options.closeTimeout);
+                },
+                () => {
+                    this.logger.info('Connection closed.');
+
+                    resolve();
+                },
+            );
+        });
+    }
+}

package/.src/cid/assigner.ts

@@ -0,0 +1,3 @@
+export interface CidAssigner {
+    assignCid(): Promise<string>;
+}

package/.src/cid/cachedAssigner.ts

@@ -0,0 +1,35 @@
+import {Logger, NullLogger} from '../logging';
+import {Cache} from '../cache';
+import {CidAssigner} from './assigner';
+
+export class CachedAssigner implements CidAssigner {
+    private readonly assigner: CidAssigner;
+
+    private readonly cache: Cache;
+
+    private readonly logger: Logger;
+
+    public constructor(assigner: CidAssigner, cache: Cache, logger?: Logger) {
+        this.assigner = assigner;
+        this.cache = cache;
+        this.logger = logger ?? new NullLogger();
+    }
+
+    public async assignCid(): Promise<string> {
+        const cid = this.cache.get();
+
+        if (cid !== null) {
+            this.logger.debug('Previous CID loaded from cache');
+
+            return cid;
+        }
+
+        const newCid = await this.assigner.assignCid();
+
+        this.cache.put(newCid);
+
+        this.logger.debug('New CID stored into cache');
+
+        return newCid;
+    }
+}

package/.src/cid/fixedAssigner.ts

@@ -0,0 +1,13 @@
+import {CidAssigner} from './assigner';
+
+export class FixedAssigner implements CidAssigner {
+    private readonly cid: string;
+
+    public constructor(cid: string) {
+        this.cid = cid;
+    }
+
+    public assignCid(): Promise<string> {
+        return Promise.resolve(this.cid);
+    }
+}

package/.src/cid/index.ts

@@ -0,0 +1,4 @@
+export * from './assigner';
+export {CachedAssigner} from './cachedAssigner';
+export {FixedAssigner} from './fixedAssigner';
+export {RemoteAssigner} from './remoteAssigner';

package/.src/cid/remoteAssigner.ts

@@ -0,0 +1,47 @@
+import {Logger, NullLogger} from '../logging';
+import {formatCause} from '../error';
+import {CidAssigner} from './assigner';
+
+export class RemoteAssigner implements CidAssigner {
+    private readonly logger: Logger;
+
+    private readonly endpoint: string;
+
+    private pending?: Promise<string>;
+
+    public constructor(endpoint: string, logger?: Logger) {
+        this.endpoint = endpoint;
+        this.logger = logger ?? new NullLogger();
+    }
+
+    public assignCid(): Promise<string> {
+        if (this.pending === undefined) {
+            this.pending = this.fetchCid().finally(() => {
+                this.pending = undefined;
+            });
+        }
+
+        return this.pending;
+    }
+
+    private async fetchCid(): Promise<string> {
+        const options: RequestInit = {
+            method: 'GET',
+            credentials: 'include',
+        };
+
+        const response = await window.fetch(this.endpoint, options);
+
+        if (!response.ok) {
+            const error = new Error(`Failed to assign CID: ${formatCause(response.statusText)}`);
+
+            this.logger.error(error.message);
+
+            throw error;
+        }
+
+        this.logger.debug('New CID successfully assigned');
+
+        return response.text();
+    }
+}

package/.src/constants.ts

@@ -0,0 +1,6 @@
+export const CID_ASSIGNER_ENDPOINT_URL = '<@cidAssignerEndpointUrl@>';
+export const TRACKER_ENDPOINT_URL = '<@trackerEndpointUrl@>';
+export const EVALUATION_ENDPOINT_URL = '<@evaluationEndpointUrl@>';
+export const CONTENT_ENDPOINT_URL = '<@contentEndpointUrl@>';
+export const MAX_QUERY_LENGTH = parseInt('<@maxQueryLength@>', 10);
+export const VERSION = '<@version@>';