@croct/sdk 0.17.10 → 0.17.12

package/src/logging/nullLogger.ts

@@ -1,19 +0,0 @@
-import {Logger} from './logger';
-
-export class NullLogger implements Logger {
-    public debug(): void {
-        // suppress debug logs
-    }
-
-    public info(): void {
-        // suppress info logs
-    }
-
-    public warn(): void {
-        // suppress warning logs
-    }
-
-    public error(): void {
-        // suppress error logs
-    }
-}

package/src/namespacedStorage.ts

@@ -1,69 +0,0 @@
-export class NamespacedStorage implements Storage {
-    private readonly storage: Storage;
-
-    private readonly namespace: string;
-
-    public constructor(storage: Storage, namespace: string) {
-        if (namespace === '') {
-            throw new Error('The namespace cannot be empty.');
-        }
-
-        this.storage = storage;
-        this.namespace = namespace;
-    }
-
-    public get length(): number {
-        return this.getKeys().length;
-    }
-
-    public clear(): void {
-        for (const key of this.getKeys()) {
-            this.storage.removeItem(key);
-        }
-    }
-
-    public getItem(key: string): string | null {
-        return this.storage.getItem(this.getPrefixedKey(key));
-    }
-
-    public key(index: number): string | null {
-        const keys = this.getKeys();
-
-        if (index >= keys.length) {
-            return null;
-        }
-
-        return keys[index].substring(this.namespace.length + 1);
-    }
-
-    public removeItem(key: string): void {
-        this.storage.removeItem(this.getPrefixedKey(key));
-    }
-
-    public setItem(key: string, value: string): void {
-        this.storage.setItem(this.getPrefixedKey(key), value);
-    }
-
-    private getKeys(): string[] {
-        const keys = [];
-        const prefix = this.getPrefix();
-
-        for (let index = 0; index < this.storage.length; index++) {
-            const key = this.storage.key(index);
-
-            if (key !== null && key.indexOf(prefix) === 0) {
-                keys.push(key);
-            }
-        }
-
-        return keys;
-    }
-
-    private getPrefixedKey(key: string): string {
-        return this.getPrefix() + key;
-    }
-
-    private getPrefix(): string {
-        return `${this.namespace}.`;
-    }
-}

package/src/patch.ts

@@ -1,64 +0,0 @@
-import {JsonStructure, JsonValue} from '@croct/json';
-
-interface AbstractOperation {
-    type: string;
-    path: string;
-}
-
-interface UnsetOperation extends AbstractOperation {
-    type: 'unset';
-}
-
-interface ClearOperation extends AbstractOperation {
-    type: 'clear';
-}
-
-interface SetOperation extends AbstractOperation {
-    type: 'set';
-    value: JsonValue;
-}
-
-interface AddOperation extends AbstractOperation {
-    type: 'add';
-    value: JsonValue;
-}
-
-interface CombineOperation extends AbstractOperation {
-    type: 'combine';
-    value: JsonValue;
-}
-
-interface MergeOperation extends AbstractOperation {
-    type: 'merge';
-    value: JsonStructure;
-}
-
-interface IncrementOperation extends AbstractOperation {
-    type: 'increment';
-    value: JsonValue;
-}
-
-interface DecrementOperation extends AbstractOperation {
-    type: 'decrement';
-    value: JsonValue;
-}
-
-interface removeOperation extends AbstractOperation {
-    type: 'remove';
-    value: JsonValue;
-}
-
-export type Operation =
-      UnsetOperation
-    | ClearOperation
-    | AddOperation
-    | SetOperation
-    | CombineOperation
-    | MergeOperation
-    | IncrementOperation
-    | DecrementOperation
-    | removeOperation;
-
-export interface Patch {
-    operations: Operation[];
-}

package/src/queue/capacityRestrictedQueue.ts

@@ -1,44 +0,0 @@
-import {Queue} from './queue';
-
-export class CapacityRestrictedQueue<T> implements Queue<T> {
-    private readonly queue: Queue<T>;
-
-    private readonly capacity: number;
-
-    public constructor(queue: Queue<T>, capacity: number) {
-        this.queue = queue;
-        this.capacity = capacity;
-    }
-
-    public all(): T[] {
-        return this.queue.all();
-    }
-
-    public getCapacity(): number {
-        return this.capacity;
-    }
-
-    public isEmpty(): boolean {
-        return this.queue.isEmpty();
-    }
-
-    public length(): number {
-        return Math.min(this.capacity, this.queue.length());
-    }
-
-    public peek(): T | null {
-        return this.queue.peek();
-    }
-
-    public push(value: T): void {
-        if (this.queue.length() >= this.capacity) {
-            throw new Error('Maximum queue capacity reached.');
-        }
-
-        this.queue.push(value);
-    }
-
-    public shift(): T {
-        return this.queue.shift();
-    }
-}

package/src/queue/inMemoryQueue.ts

@@ -1,43 +0,0 @@
-import {Queue} from './queue';
-
-export class InMemoryQueue<T> implements Queue<T> {
-    private queue: T[] = [];
-
-    public constructor(...values: T[]) {
-        this.queue.unshift(...values);
-    }
-
-    public all(): T[] {
-        return this.queue.slice();
-    }
-
-    public getCapacity(): number {
-        return Infinity;
-    }
-
-    public isEmpty(): boolean {
-        return this.queue.length === 0;
-    }
-
-    public push(value: T): void {
-        this.queue.push(value);
-    }
-
-    public peek(): T | null {
-        return this.queue[0] ?? null;
-    }
-
-    public shift(): T {
-        const value = this.queue.shift();
-
-        if (value === undefined) {
-            throw new Error('The queue is empty.');
-        }
-
-        return value;
-    }
-
-    public length(): number {
-        return this.queue.length;
-    }
-}

package/src/queue/index.ts

@@ -1,5 +0,0 @@
-export * from './queue';
-export {CapacityRestrictedQueue} from './capacityRestrictedQueue';
-export {InMemoryQueue} from './inMemoryQueue';
-export {MonitoredQueue} from './monitoredQueue';
-export {PersistentQueue} from './persistentQueue';

package/src/queue/monitoredQueue.ts

@@ -1,168 +0,0 @@
-import {Queue} from './queue';
-import {Logger, NullLogger} from '../logging';
-
-export type QueueStatus = 'halfEmpty' | 'almostEmpty' | 'empty' | 'halfFull' | 'almostFull' | 'full';
-
-export type QueueCallback<T> = {
-    (queue: Queue<T>): void,
-};
-
-export class MonitoredQueue<T> implements Queue<T> {
-    private readonly queue: Queue<T>;
-
-    private readonly logger: Logger;
-
-    private readonly callbacks: Partial<{[key in QueueStatus]: Array<QueueCallback<T>>}> = {};
-
-    private status: QueueStatus;
-
-    public constructor(queue: Queue<T>, logger?: Logger) {
-        this.queue = queue;
-        this.logger = logger ?? new NullLogger();
-
-        this.updateStatus();
-    }
-
-    public all(): T[] {
-        return this.queue.all();
-    }
-
-    public getCapacity(): number {
-        return this.queue.getCapacity();
-    }
-
-    public addCallback(status: QueueStatus, callback: QueueCallback<T>): void {
-        const callbacks = this.callbacks[status] ?? [];
-
-        if (!callbacks.includes(callback)) {
-            callbacks.push(callback);
-        }
-
-        this.callbacks[status] = callbacks;
-
-        switch (this.status) {
-            case status:
-                callback(this);
-
-                break;
-
-            case 'empty':
-            case 'almostEmpty':
-                if (status === 'halfEmpty') {
-                    callback(this);
-                }
-
-                break;
-
-            case 'full':
-            case 'almostFull':
-                if (status === 'halfFull') {
-                    callback(this);
-                }
-
-                break;
-        }
-    }
-
-    public removeCallback(type: QueueStatus, callback: QueueCallback<T>): void {
-        const callbacks = this.callbacks[type];
-
-        if (callbacks == null) {
-            return;
-        }
-
-        const index = callbacks.indexOf(callback);
-
-        if (index >= 0) {
-            callbacks.splice(index, 1);
-        }
-    }
-
-    private setStatus(status: QueueStatus): void {
-        if (this.status === status) {
-            return;
-        }
-
-        this.logger.debug(`Queue status changed to "${status}"`);
-
-        this.report(status);
-
-        this.status = status;
-    }
-
-    private report(status: QueueStatus): void {
-        const callbacks = this.callbacks[status];
-
-        if (callbacks !== undefined) {
-            callbacks.forEach(callback => callback(this));
-        }
-
-        switch (status) {
-            case 'empty':
-            case 'almostEmpty':
-                this.report('halfEmpty');
-
-                break;
-
-            case 'full':
-            case 'almostFull':
-                this.report('halfFull');
-
-                break;
-
-            default:
-                break;
-        }
-    }
-
-    public isEmpty(): boolean {
-        return this.queue.isEmpty();
-    }
-
-    public length(): number {
-        return this.queue.length();
-    }
-
-    public peek(): T | null {
-        return this.queue.peek();
-    }
-
-    public push(value: T): void {
-        this.queue.push(value);
-
-        this.updateStatus();
-    }
-
-    public shift(): T {
-        const value = this.queue.shift();
-
-        this.updateStatus();
-
-        return value;
-    }
-
-    private updateStatus(): void {
-        const length = this.queue.length();
-        const capacity = this.getCapacity();
-
-        if (length <= capacity * 0.5) {
-            if (length === 0) {
-                this.setStatus('empty');
-            } else if (length <= capacity * 0.25) {
-                this.setStatus('almostEmpty');
-            } else {
-                this.setStatus('halfEmpty');
-            }
-
-            return;
-        }
-
-        if (length >= capacity) {
-            this.setStatus('full');
-        } else if (length >= capacity * 0.75) {
-            this.setStatus('almostFull');
-        } else {
-            this.setStatus('halfFull');
-        }
-    }
-}

package/src/queue/persistentQueue.ts

@@ -1,73 +0,0 @@
-import {Queue} from './queue';
-
-export class PersistentQueue<T> implements Queue<T> {
-    private readonly storage: Storage;
-
-    private readonly key: string;
-
-    public constructor(storage: Storage, key = 'queue') {
-        this.storage = storage;
-        this.key = key;
-    }
-
-    public all(): T[] {
-        return this.queue.slice();
-    }
-
-    public getCapacity(): number {
-        return Number.MAX_SAFE_INTEGER;
-    }
-
-    public isEmpty(): boolean {
-        return this.length() === 0;
-    }
-
-    public length(): number {
-        return this.queue.length;
-    }
-
-    public push(value: T): void {
-        this.save([...this.queue, value]);
-    }
-
-    public peek(): T | null {
-        const item = this.queue[0];
-
-        if (item === undefined) {
-            return null;
-        }
-
-        return item;
-    }
-
-    public shift(): T {
-        const queue = [...this.queue];
-        const value = queue.shift();
-
-        if (value === undefined) {
-            throw new Error('The queue is empty.');
-        }
-
-        this.save(queue);
-
-        return value;
-    }
-
-    private get queue(): readonly T[] {
-        const data = this.storage.getItem(this.key);
-
-        if (data === null) {
-            return [];
-        }
-
-        try {
-            return JSON.parse(data);
-        } catch {
-            return [];
-        }
-    }
-
-    private save(data: T[]): void {
-        this.storage.setItem(this.key, JSON.stringify(data));
-    }
-}

package/src/queue/queue.ts

@@ -1,15 +0,0 @@
-export interface Queue<T> {
-    getCapacity(): number;
-
-    all(): T[];
-
-    push(value: T): void;
-
-    shift(): T;
-
-    peek(): T | null;
-
-    isEmpty(): boolean;
-
-    length(): number;
-}

package/src/retry/arbitraryPolicy.ts

@@ -1,21 +0,0 @@
-import {RetryPolicy} from './policy';
-
-export class ArbitraryPolicy<T> implements RetryPolicy<T> {
-    private readonly delays: number[];
-
-    public constructor(delays: number[]) {
-        if (delays.length < 1) {
-            throw new Error('The list of delays cannot be empty.');
-        }
-
-        this.delays = [...delays];
-    }
-
-    public getDelay(attempt: number): number {
-        return this.delays[Math.min(attempt < 0 ? 0 : attempt, this.delays.length - 1)];
-    }
-
-    public shouldRetry(): boolean {
-        return true;
-    }
-}

package/src/retry/backoffPolicy.ts

@@ -1,84 +0,0 @@
-import {RetryPolicy} from './policy';
-
-type Options = {
-    minRetryDelay: number, // min retry delay in ms (used in exp. backoff calcs)
-    maxRetryDelay: number, // max retry delay in ms (used in exp. backoff calcs)
-    backoffFactor: number, // exponential backoff factor (attempts^n)
-    backoffJitter: number, // jitter factor for backoff calcs (0 is usually fine)
-    maxAttempts: number,
-};
-
-export class BackoffPolicy<T> implements RetryPolicy<T> {
-    private readonly minRetryDelay: number = 1000;
-
-    private readonly maxRetryDelay: number = 30000;
-
-    private readonly backoffFactor: number = 2;
-
-    private readonly backoffJitter: number = 1;
-
-    private readonly maxAttempts: number = Infinity;
-
-    public constructor(options: Partial<Options> = {}) {
-        const {
-            minRetryDelay = this.minRetryDelay,
-            maxRetryDelay = this.maxRetryDelay,
-            backoffFactor = this.backoffFactor,
-            backoffJitter = this.backoffJitter,
-            maxAttempts = this.maxAttempts,
-        } = options;
-
-        if (minRetryDelay < 0) {
-            throw new Error('The minimum retry delay must be non-negative.');
-        }
-
-        if (maxRetryDelay < minRetryDelay) {
-            throw new Error('The maximum retry delay must be greater than the minimum.');
-        }
-
-        if (backoffFactor < 1) {
-            throw new Error('The backoff factor must be greater than zero.');
-        }
-
-        if (backoffJitter < 0) {
-            throw new Error('The backoff jitter must be non-negative.');
-        }
-
-        if (maxAttempts < 0) {
-            throw new Error('The maximum attempts must be non-negative.');
-        }
-
-        this.minRetryDelay = minRetryDelay;
-        this.maxRetryDelay = maxRetryDelay;
-        this.backoffFactor = backoffFactor;
-        this.backoffJitter = backoffJitter;
-        this.maxAttempts = maxAttempts;
-    }
-
-    /**
-     * Full Jitter algorithm
-     *
-     * @see https://www.awsarchitectureblog.com/2015/03/backoff.html
-     */
-    public getDelay(attempt: number): number {
-        let delay = Math.min(Math.max(this.backoffFactor ** attempt, this.minRetryDelay), this.maxRetryDelay);
-
-        if (this.backoffJitter > 0) {
-            // Jitter will result in a random value between the minimum and
-            // calculated delay for a given attempt.
-            const min = Math.ceil(this.minRetryDelay);
-            const max = Math.floor(delay);
-
-            delay = Math.floor(Math.random() * (max - min + 1)) + min;
-        }
-
-        // Removing any fractional digits
-        delay -= delay % 1;
-
-        return delay;
-    }
-
-    public shouldRetry(attempt: number): boolean {
-        return attempt < this.maxAttempts;
-    }
-}

package/src/retry/index.ts

@@ -1,5 +0,0 @@
-export * from './policy';
-export {ArbitraryPolicy} from './arbitraryPolicy';
-export {BackoffPolicy} from './backoffPolicy';
-export {MaxAttemptsPolicy} from './maxAttemptsPolicy';
-export {NeverPolicy} from './neverPolicy';

package/src/retry/maxAttemptsPolicy.ts

@@ -1,28 +0,0 @@
-import {RetryPolicy} from './policy';
-
-export class MaxAttemptsPolicy<T> implements RetryPolicy<T> {
-    private readonly maxAttempts: number;
-
-    private readonly delay: number;
-
-    public constructor(delay: number, maxAttempts: number) {
-        if (delay < 0) {
-            throw new Error('Delay must be non-negative.');
-        }
-
-        if (maxAttempts < 0) {
-            throw new Error('Max attempts must be non-negative.');
-        }
-
-        this.maxAttempts = maxAttempts;
-        this.delay = delay;
-    }
-
-    public getDelay(): number {
-        return this.delay;
-    }
-
-    public shouldRetry(attempt: number): boolean {
-        return attempt < this.maxAttempts;
-    }
-}

package/src/retry/neverPolicy.ts

@@ -1,11 +0,0 @@
-import {RetryPolicy} from './policy';
-
-export class NeverPolicy<T> implements RetryPolicy<T> {
-    public getDelay(): number {
-        return Infinity;
-    }
-
-    public shouldRetry(): boolean {
-        return false;
-    }
-}

package/src/retry/policy.ts

@@ -1,5 +0,0 @@
-export interface RetryPolicy<T> {
-    shouldRetry(attempt: number, subject?: T, failure?: any): boolean;
-
-    getDelay(attempt: number): number;
-}

package/src/schema/attributeSchema.ts

@@ -1,6 +0,0 @@
-import {StringType} from '../validation';
-
-export const attributeNameSchema = new StringType({
-    maxLength: 50,
-    format: 'identifier',
-});

package/src/schema/contentFetcherSchemas.ts

@@ -1,23 +0,0 @@
-import {ObjectType, NumberType, JsonObjectType, StringType, UnionType} from '../validation';
-
-export const fetchOptionsSchema = new ObjectType({
-    properties: {
-        timeout: new NumberType({
-            integer: true,
-            minimum: 0,
-        }),
-        version: new UnionType(
-            new StringType({
-                pattern: /^\d+$/,
-            }),
-            new NumberType({
-                integer: true,
-                minimum: 1,
-            }),
-        ),
-        preferredLocale: new StringType({
-            pattern: /^[a-z]{2,3}([-_][a-z]{2,3})?$/i,
-        }),
-        attributes: new JsonObjectType(),
-    },
-});