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

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