@croct/sdk 0.17.10 → 0.17.12

package/src/channel/channel.ts

@@ -1,52 +0,0 @@
-import {formatMessage} from '../error';
-
-export class MessageDeliveryError extends Error {
-    public readonly retryable: boolean;
-
-    public constructor(message: string, retryable: boolean) {
-        super(message);
-
-        this.retryable = retryable;
-
-        Object.setPrototypeOf(this, MessageDeliveryError.prototype);
-    }
-
-    public static retryable(cause: unknown): MessageDeliveryError {
-        return MessageDeliveryError.fromCause(cause, true);
-    }
-
-    public static nonRetryable(cause: unknown): MessageDeliveryError {
-        return MessageDeliveryError.fromCause(cause, false);
-    }
-
-    private static fromCause(cause: unknown, retryable: boolean): MessageDeliveryError {
-        const error = new MessageDeliveryError(formatMessage(cause), retryable);
-
-        if (cause instanceof Error) {
-            error.stack = cause.stack;
-        }
-
-        return error;
-    }
-}
-
-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

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

@@ -1,131 +0,0 @@
-import {Logger, NullLogger} from '../logging';
-import {DuplexChannel, MessageDeliveryError, 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(MessageDeliveryError.nonRetryable('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(MessageDeliveryError.retryable('Connection deliberately closed.'));
-                        }
-                    },
-                    0,
-                );
-
-                this.logger.debug(`Waiting confirmation #${id}...`);
-
-                timeoutTimer = window.setTimeout(
-                    () => {
-                        abort(MessageDeliveryError.retryable('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/httpBeaconChannel.ts

@@ -1,128 +0,0 @@
-import {ChannelListener, DuplexChannel, MessageDeliveryError} from './channel';
-import {Envelope} from './guaranteedChannel';
-import {Logger, NullLogger} from '../logging';
-import {CidAssigner} from '../cid';
-import {formatMessage} from '../error';
-import {CLIENT_LIBRARY} from '../constants';
-import {Help} from '../help';
-
-export type Configuration = {
-    appId: string,
-    endpointUrl: string,
-    cidAssigner: CidAssigner,
-    logger?: Logger,
-};
-
-type ApiProblem = {
-    type: string,
-    title: string,
-    status: number,
-    detail: string,
-};
-
-export class HttpBeaconChannel implements DuplexChannel<string, Envelope<string, string>> {
-    private readonly configuration: Omit<Configuration, 'logger'>;
-
-    private readonly logger: Logger;
-
-    private readonly listeners: Array<ChannelListener<string>> = [];
-
-    private closed = false;
-
-    public constructor({logger = new NullLogger(), ...configuration}: Configuration) {
-        this.configuration = configuration;
-        this.logger = logger;
-    }
-
-    public async publish({id: receiptId, message}: Envelope<string, string>): Promise<void> {
-        if (this.closed) {
-            return Promise.reject(MessageDeliveryError.nonRetryable('Channel is closed'));
-        }
-
-        const {token, timestamp, context, payload} = JSON.parse(message);
-        const {endpointUrl, appId, cidAssigner} = this.configuration;
-
-        return fetch(endpointUrl, {
-            method: 'POST',
-            headers: {
-                'X-App-Id': appId,
-                'X-Client-Id': await cidAssigner.assignCid(),
-                'X-Client-Library': CLIENT_LIBRARY,
-                'Content-Type': 'application/json',
-                ...(token !== undefined ? {'X-Token': token} : {}),
-            },
-            body: JSON.stringify({
-                context: context,
-                payload: payload,
-                originalTime: timestamp,
-                departureTime: Date.now(),
-            }),
-        }).then(async response => {
-            if (response.ok) {
-                this.notify(receiptId);
-
-                return;
-            }
-
-            const problem: ApiProblem = await response.json().catch(
-                () => ({
-                    type: 'https://croct.help/api/event-tracker#unexpected-error',
-                    title: response.statusText,
-                    status: response.status,
-                }),
-            );
-
-            const isRetryable = HttpBeaconChannel.isRetryable(problem.status);
-            const help = Help.forStatusCode(problem.status);
-
-            if (help !== undefined) {
-                this.logger.error(help);
-            } else if (!isRetryable) {
-                this.logger.error(`Beacon rejected with non-retryable status: ${problem.title}`);
-            }
-
-            return Promise.reject(
-                isRetryable
-                    ? MessageDeliveryError.retryable(problem.title)
-                    : MessageDeliveryError.nonRetryable(problem.title),
-            );
-        }).catch(error => {
-            this.logger.error(`Failed to publish beacon: ${formatMessage(error)}`);
-
-            return Promise.reject(
-                error instanceof MessageDeliveryError
-                    ? error
-                    : MessageDeliveryError.retryable(error),
-            );
-        });
-    }
-
-    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(receiptId: string): void {
-        this.listeners.forEach(dispatch => dispatch(receiptId));
-    }
-
-    public close(): Promise<void> {
-        this.closed = true;
-
-        return Promise.resolve();
-    }
-
-    private static isRetryable(status: number): boolean {
-        // Retry on any server error and client errors 429 (rate limit) and 408 (request timeout)
-        return status >= 500 || status === 429 || status === 408;
-    }
-}

package/src/channel/index.ts

@@ -1,7 +0,0 @@
-export * from './channel';
-export {EncodedChannel} from './encodedChannel';
-export {GuaranteedChannel} from './guaranteedChannel';
-export {QueuedChannel} from './queuedChannel';
-export {RetryChannel} from './retryChannel';
-export {SandboxChannel} from './sandboxChannel';
-export {HttpBeaconChannel} from './httpBeaconChannel';

package/src/channel/queuedChannel.ts

@@ -1,143 +0,0 @@
-import {MessageDeliveryError, 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(MessageDeliveryError.nonRetryable('Channel is closed.'));
-        }
-
-        if (this.queue.length() >= this.queue.getCapacity()) {
-            this.logger.warn('The queue is full, message rejected.');
-
-            return Promise.reject(MessageDeliveryError.retryable('The queue is full.'));
-        }
-
-        if (this.pending === undefined) {
-            this.pending = this.requeue();
-        }
-
-        this.pending = this.chainNext(this.pending, message, true);
-
-        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(MessageDeliveryError.nonRetryable('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.chainNext(this.pending, message);
-        }
-
-        return this.pending;
-    }
-
-    private async chainNext(previous: Promise<void>, message: T, enqueue = false): Promise<void> {
-        if (enqueue) {
-            this.enqueue(message);
-        }
-
-        try {
-            await previous;
-        } catch (error) {
-            if (error instanceof MessageDeliveryError && error.retryable) {
-                // If the previous message failed to deliver, requeue all messages
-                // including the current one that was just enqueued
-                return this.requeue();
-            }
-
-            throw error;
-        }
-
-        if (this.closed) {
-            throw MessageDeliveryError.retryable('Connection deliberately closed.');
-        }
-
-        try {
-            const result = await this.channel.publish(message);
-
-            this.dequeue();
-
-            return result;
-        } catch (error) {
-            if (!(error instanceof MessageDeliveryError) || !error.retryable) {
-                // Discard the message if it's non-retryable
-                this.dequeue();
-
-                if (!enqueue) {
-                    // If the message was not enqueued, suppress the error
-                    // so that the next message in the queue can be immediately
-                    return;
-                }
-            }
-
-            throw error;
-        }
-    }
-
-    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

@@ -1,94 +0,0 @@
-import {MessageDeliveryError, 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(MessageDeliveryError.nonRetryable('The channel is closed.'));
-        }
-
-        return this.channel
-            .publish(message)
-            .catch(error => this.retry(message, error));
-    }
-
-    public async retry(message: T, error: unknown): Promise<void> {
-        if (error instanceof MessageDeliveryError && !error.retryable) {
-            throw error;
-        }
-
-        let attempt = 0;
-
-        while (this.retryPolicy.shouldRetry(attempt, message, error)) {
-            if (this.closed) {
-                throw MessageDeliveryError.retryable('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(MessageDeliveryError.retryable('Connection deliberately closed.'));
-                            }
-                        },
-                        0,
-                    );
-
-                    window.setTimeout(
-                        (): void => {
-                            window.clearInterval(closeWatcher);
-
-                            resolve();
-                        },
-                        delay,
-                    );
-                });
-            }
-
-            try {
-                return await this.channel.publish(message);
-            } catch {
-                attempt += 1;
-            }
-        }
-
-        throw MessageDeliveryError.nonRetryable('Maximum retry attempts reached.');
-    }
-
-    public close(): Promise<void> {
-        this.closed = true;
-
-        return this.channel.close();
-    }
-}

package/src/channel/sandboxChannel.ts

@@ -1,47 +0,0 @@
-import {ChannelListener, DuplexChannel, MessageDeliveryError} 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> {
-        if (this.closed) {
-            return Promise.reject(MessageDeliveryError.nonRetryable('Channel is closed.'));
-        }
-
-        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/cid/assigner.ts

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

package/src/cid/cachedAssigner.ts

@@ -1,68 +0,0 @@
-import {Logger, NullLogger} from '../logging';
-import {Cache} from '../cache';
-import {CidAssigner} from './assigner';
-
-type CachedAssignerOptions = {
-    logger?: Logger,
-    mirror?: boolean,
-};
-
-export class CachedAssigner implements CidAssigner {
-    private readonly assigner: CidAssigner;
-
-    private readonly cache: Cache;
-
-    private readonly options: Required<CachedAssignerOptions>;
-
-    public constructor(assigner: CidAssigner, cache: Cache, options: CachedAssignerOptions = {}) {
-        this.assigner = assigner;
-        this.cache = cache;
-        this.options = {
-            logger: options.logger ?? new NullLogger(),
-            mirror: options.mirror ?? false,
-        };
-    }
-
-    public async assignCid(currentCid?: string): Promise<string> {
-        const cachedCid = this.cache.get();
-        const previousCid = currentCid ?? cachedCid ?? null;
-        const {logger, mirror} = this.options;
-
-        if (previousCid === null) {
-            const newCid = await this.assigner.assignCid();
-
-            this.cache.put(newCid);
-
-            logger.debug('New CID stored into cache');
-
-            return newCid;
-        }
-
-        logger.debug('Using existing CID');
-
-        if (cachedCid !== previousCid) {
-            logger.debug('The cached CID is stale, updating cache...');
-
-            this.cache.put(previousCid);
-        }
-
-        if (mirror) {
-            logger.debug('Mirroring CID');
-
-            this.assigner
-                .assignCid(previousCid)
-                .then(newCid => {
-                    if (newCid !== previousCid) {
-                        logger.warn('The CID has changed, updating cache...');
-
-                        this.cache.put(newCid);
-                    }
-                })
-                .catch(() => {
-                    logger.error('Failed to mirror CID');
-                });
-        }
-
-        return previousCid;
-    }
-}