@croct/sdk 0.17.9 → 0.17.11

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(),
-    },
-});

package/src/schema/contentSchemas.ts

@@ -1,44 +0,0 @@
-import {ArrayType, StringType, ObjectType, NumberType} from '../validation';
-
-export const postDetails = new ObjectType({
-    required: ['postId', 'title', 'publishTime'],
-    properties: {
-        postId: new StringType({
-            minLength: 1,
-            maxLength: 200,
-        }),
-        url: new StringType({
-            format: 'url',
-        }),
-        title: new StringType({
-            minLength: 1,
-            maxLength: 200,
-        }),
-        tags: new ArrayType({
-            items: new StringType({
-                minLength: 1,
-                maxLength: 50,
-            }),
-            minItems: 1,
-            maxItems: 10,
-        }),
-        categories: new ArrayType({
-            items: new StringType({
-                minLength: 1,
-                maxLength: 50,
-            }),
-            minItems: 1,
-            maxItems: 10,
-        }),
-        authors: new ArrayType({
-            items: new StringType({
-                minLength: 1,
-                maxLength: 50,
-            }),
-            minItems: 1,
-            maxItems: 10,
-        }),
-        publishTime: new NumberType(),
-        updateTime: new NumberType(),
-    },
-});

package/src/schema/contextSchemas.ts

@@ -1,5 +0,0 @@
-import {StringType} from '../validation';
-
-export const tokenScopeSchema = new StringType({
-    enumeration: ['global', 'contextual', 'isolated'],
-});

package/src/schema/ecommerceSchemas.ts

@@ -1,179 +0,0 @@
-import {ObjectType, StringType, NumberType, ArrayType} from '../validation';
-
-export const productDetails = new ObjectType({
-    required: ['productId', 'name', 'displayPrice'],
-    properties: {
-        productId: new StringType({
-            minLength: 1,
-            maxLength: 50,
-        }),
-        sku: new StringType({
-            minLength: 1,
-            maxLength: 50,
-        }),
-        name: new StringType({
-            minLength: 1,
-            maxLength: 200,
-        }),
-        category: new StringType({
-            minLength: 1,
-            maxLength: 100,
-        }),
-        brand: new StringType({
-            minLength: 1,
-            maxLength: 100,
-        }),
-        variant: new StringType({
-            minLength: 1,
-            maxLength: 50,
-        }),
-        displayPrice: new NumberType({
-            minimum: 0,
-        }),
-        originalPrice: new NumberType({
-            minimum: 0,
-        }),
-        url: new StringType({
-            format: 'url',
-        }),
-        imageUrl: new StringType({
-            format: 'url',
-        }),
-    },
-});
-
-export const cartItem = new ObjectType({
-    required: ['index', 'product', 'quantity', 'total'],
-    properties: {
-        index: new NumberType({
-            minimum: 0,
-        }),
-        product: productDetails,
-        quantity: new NumberType({
-            minimum: 1,
-        }),
-        total: new NumberType({
-            minimum: 0,
-        }),
-        discount: new NumberType({
-            minimum: 0,
-        }),
-        coupon: new StringType({
-            minLength: 1,
-            maxLength: 50,
-        }),
-    },
-});
-
-export const cart = new ObjectType({
-    required: ['currency', 'items', 'total'],
-    properties: {
-        currency: new StringType({
-            maxLength: 10,
-            minLength: 1,
-        }),
-        items: new ArrayType({
-            items: cartItem,
-        }),
-        subtotal: new NumberType({
-            minimum: 0,
-        }),
-        shippingPrice: new NumberType({
-            minimum: 0,
-        }),
-        taxes: new ObjectType({
-            additionalProperties: new NumberType(),
-            minProperties: 1,
-        }),
-        costs: new ObjectType({
-            additionalProperties: new NumberType(),
-            minProperties: 1,
-        }),
-        discount: new NumberType({
-            minimum: 0,
-        }),
-        total: new NumberType({
-            minimum: 0,
-        }),
-        coupon: new StringType({
-            minLength: 1,
-            maxLength: 50,
-        }),
-        lastUpdateTime: new NumberType(),
-    },
-});
-
-export const orderItem = new ObjectType({
-    required: ['index', 'product', 'quantity', 'total'],
-    properties: {
-        index: new NumberType({
-            minimum: 0,
-        }),
-        product: productDetails,
-        quantity: new NumberType({
-            minimum: 1,
-        }),
-        total: new NumberType({
-            minimum: 0,
-        }),
-        discount: new NumberType({
-            minimum: 0,
-        }),
-        coupon: new StringType({
-            minLength: 1,
-            maxLength: 50,
-        }),
-    },
-});
-
-export const order = new ObjectType({
-    required: ['orderId', 'currency', 'items', 'total'],
-    properties: {
-        orderId: new StringType({
-            minLength: 1,
-            maxLength: 50,
-        }),
-        currency: new StringType({
-            maxLength: 10,
-            minLength: 1,
-        }),
-        items: new ArrayType({
-            items: orderItem,
-            minItems: 1,
-        }),
-        subtotal: new NumberType({
-            minimum: 0,
-        }),
-        shippingPrice: new NumberType({
-            minimum: 0,
-        }),
-        taxes: new ObjectType({
-            additionalProperties: new NumberType(),
-            minProperties: 1,
-        }),
-        costs: new ObjectType({
-            additionalProperties: new NumberType(),
-            minProperties: 1,
-        }),
-        discount: new NumberType({
-            minimum: 0,
-        }),
-        total: new NumberType({
-            minimum: 0,
-        }),
-        coupon: new StringType({
-            minLength: 1,
-            maxLength: 50,
-        }),
-        paymentMethod: new StringType({
-            minLength: 1,
-            maxLength: 50,
-        }),
-        installments: new NumberType({
-            minimum: 1,
-        }),
-        status: new StringType({
-            enumeration: ['placed', 'paid', 'complete'],
-        }),
-    },
-});

package/src/schema/evaluatorSchemas.ts

@@ -1,52 +0,0 @@
-import {
-    ObjectType,
-    NumberType,
-    JsonObjectType,
-    UnionType,
-    StringType,
-    NullType,
-    BooleanType,
-    TypeSchema,
-    ArrayType,
-} from '../validation';
-
-function createJsonSchema(maximumDepth: number): TypeSchema {
-    return new UnionType(
-        new NullType(),
-        new NumberType(),
-        new BooleanType(),
-        new StringType({maxLength: 255}),
-        ...(maximumDepth > 1
-            ? [
-                new JsonObjectType({
-                    propertyNames: new UnionType(
-                        new NumberType(),
-                        new StringType({
-                            minLength: 1,
-                            maxLength: 50,
-                        }),
-                    ),
-                    properties: createJsonSchema(maximumDepth - 1),
-                }),
-                new ArrayType({items: createJsonSchema(maximumDepth - 1)}),
-            ]
-            : []
-        ),
-    );
-}
-
-export const evaluationOptionsSchema = new ObjectType({
-    properties: {
-        timeout: new NumberType({
-            integer: true,
-            minimum: 0,
-        }),
-        attributes: new JsonObjectType({
-            propertyNames: new StringType({
-                minLength: 1,
-                maxLength: 50,
-            }),
-            properties: createJsonSchema(5),
-        }),
-    },
-});

package/src/schema/eventSchemas.ts

@@ -1,134 +0,0 @@
-import {
-    ObjectType,
-    StringType,
-    NumberType,
-    UnionType,
-    NullType,
-    BooleanType,
-    ArrayType,
-} from '../validation';
-import {cart, order, productDetails} from './ecommerceSchemas';
-import {userProfileSchema} from './userSchema';
-import {postDetails} from './contentSchemas';
-
-export const cartModified = new ObjectType({
-    required: ['cart'],
-    properties: {
-        cart: cart,
-    },
-});
-
-export const cartViewed = new ObjectType({
-    required: ['cart'],
-    properties: {
-        cart: cart,
-    },
-});
-
-export const checkoutStarted = new ObjectType({
-    required: ['cart'],
-    properties: {
-        cart: cart,
-        orderId: new StringType({
-            minLength: 1,
-            maxLength: 50,
-        }),
-    },
-});
-
-export const orderPlaced = new ObjectType({
-    required: ['order'],
-    properties: {
-        order: order,
-    },
-});
-
-export const productViewed = new ObjectType({
-    required: ['product'],
-    properties: {
-        product: productDetails,
-    },
-});
-
-export const userSignedUp = new ObjectType({
-    required: ['userId'],
-    properties: {
-        userId: new StringType({
-            minLength: 1,
-            maxLength: 254,
-        }),
-        profile: userProfileSchema,
-    },
-});
-
-export const goalCompleted = new ObjectType({
-    required: ['goalId'],
-    properties: {
-        goalId: new StringType({
-            minLength: 3,
-            maxLength: 100,
-            pattern: /^[a-z0-9][a-z0-9:_-]+[a-z0-9]$/i,
-        }),
-        value: new NumberType({
-            minimum: 0,
-        }),
-        currency: new StringType({
-            minLength: 1,
-            maxLength: 10,
-        }),
-    },
-});
-
-export const interestShown = new ObjectType({
-    required: ['interests'],
-    properties: {
-        interests: new ArrayType({
-            items: new StringType({
-                minLength: 1,
-                maxLength: 50,
-            }),
-            minItems: 1,
-            maxItems: 10,
-        }),
-    },
-});
-
-export const postViewed = new ObjectType({
-    required: ['post'],
-    properties: {
-        post: postDetails,
-    },
-});
-
-export const linkOpened = new ObjectType({
-    required: ['link'],
-    properties: {
-        link: new StringType(),
-    },
-});
-
-export const eventOccurred = new ObjectType({
-    required: ['name'],
-    properties: {
-        name: new StringType({
-            minLength: 1,
-            maxLength: 50,
-        }),
-        details: new ObjectType({
-            additionalProperties: new UnionType(
-                new NullType(),
-                new BooleanType(),
-                new NumberType(),
-                new StringType({
-                    maxLength: 300,
-                }),
-            ),
-            propertyNames: new StringType({
-                minLength: 1,
-                maxLength: 20,
-                format: 'identifier',
-            }),
-            maxProperties: 10,
-        }),
-    },
-});

package/src/schema/index.ts

@@ -1,11 +0,0 @@
-export * from './contextSchemas';
-export * from './ecommerceSchemas';
-export * from './evaluatorSchemas';
-export * from './contentFetcherSchemas';
-export * from './eventSchemas';
-export * from './loggerSchema';
-export * from './operationSchemas';
-export * from './sdkFacadeSchemas';
-export * from './sdkSchemas';
-export * from './tokenSchema';
-export * from './userSchema';

package/src/schema/loggerSchema.ts

@@ -1,12 +0,0 @@
-import {ObjectType, FunctionType} from '../validation';
-
-export const loggerSchema = new ObjectType({
-    required: ['debug', 'info', 'warn', 'error'],
-    additionalProperties: true,
-    properties: {
-        debug: new FunctionType(),
-        info: new FunctionType(),
-        warn: new FunctionType(),
-        error: new FunctionType(),
-    },
-});