@convertcom/js-sdk-rules 0.0.1 → 1.0.0

package/lib/legacy/types/src/Variation.d.ts

@@ -0,0 +1,49 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+import { VariationChangeType } from '@convertcom/js-sdk-enums';
+import { Id } from './Id';
+export type RichStructureChange = {
+    js?: string;
+    selector: string;
+    page_id: string;
+};
+export type CustomCodeChange = {
+    css?: string;
+    js?: string;
+    page_id: string;
+};
+export type DefaultCodeChange = {
+    css?: string;
+    js?: string;
+    custom_js?: string;
+};
+export type DefaultCodeMultipageChange = {
+    css?: string;
+    js?: string;
+    custom_js?: string;
+    page_id: string;
+};
+export type DefaultRedirectChange = {
+    original_pattern: string;
+    variation_pattern: string;
+};
+export type FullStackFeatureChange = {
+    feature_id: Id;
+    variables_data: Record<string, any>;
+};
+export type VariationChange = {
+    id: Id;
+    type: VariationChangeType;
+    data: RichStructureChange | CustomCodeChange | DefaultCodeChange | DefaultCodeMultipageChange | DefaultRedirectChange | FullStackFeatureChange;
+};
+export type Variation = {
+    id: Id;
+    key: string;
+    name: string;
+    changes: Array<VariationChange>;
+    traffic_allocation?: number;
+};

package/lib/legacy/types/src/VisitorsQueue.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+import { Id } from './Id';
+import { SegmentsData } from './SegmentsData';
+import { Visitor } from './tracking/Visitor';
+import { VisitorEvent } from './tracking/VisitorEvent';
+export type VisitorsQueue = {
+    length: number;
+    items: Array<Visitor>;
+    push: (visitorId: Id, eventRequest: VisitorEvent, segments?: SegmentsData) => void;
+    reset: () => void;
+};

package/lib/legacy/types/src/tracking/BucketingEvent.d.ts

@@ -0,0 +1,11 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+import { Id } from '../Id';
+export type BucketingEvent = {
+    experienceId: Id;
+    variationId: Id;
+};

package/lib/legacy/types/src/tracking/ConversionEvent.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+import { GoalDataKey } from '@convertcom/js-sdk-enums';
+import { Id } from '../Id';
+export type GoalData = {
+    [key in GoalDataKey]?: Id;
+};
+export type ConversionEvent = {
+    goalId: Id;
+    goalData?: Array<GoalData>;
+    bucketingData?: Record<string, Id>;
+};

package/lib/legacy/types/src/tracking/Visitor.d.ts

@@ -0,0 +1,14 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+import { Id } from '../Id';
+import { SegmentsData } from '../SegmentsData';
+import { VisitorEvent } from './VisitorEvent';
+export type Visitor = {
+    visitorId: Id;
+    segments?: SegmentsData;
+    events: Array<VisitorEvent>;
+};

package/lib/legacy/types/src/tracking/VisitorEvent.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+import { EventType } from '@convertcom/js-sdk-enums';
+import { BucketingEvent } from './BucketingEvent';
+import { ConversionEvent } from './ConversionEvent';
+export type VisitorEvent = {
+    eventType: EventType;
+    data?: BucketingEvent | ConversionEvent;
+};

package/lib/legacy/utils/index.d.ts

@@ -0,0 +1,14 @@
+/*!
+ * Convert JS SDK test
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+export * from './src/array-utils';
+export * from './src/comparisons';
+export * from './src/data-store';
+export * from './src/file-logger';
+export * from './src/http-client';
+export * from './src/object-utils';
+export * from './src/string-utils';
+export * from './src/types-utils';

package/lib/legacy/utils/src/array-utils.d.ts

@@ -0,0 +1,11 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+/**
+ * Validates variable is array and not empty
+ * @param array
+ */
+export declare function arrayNotEmpty(array: Array<unknown>): boolean;

package/lib/legacy/utils/src/comparisons.d.ts

@@ -0,0 +1,22 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+/**
+ * Comparison Processor. Provides comparison methods for rules validation
+ */
+export declare class Comparisons {
+    static equals(value: string | number | boolean | Array<string | number | boolean> | Record<string, string | number | boolean>, testAgainst: string | number | boolean, negation?: boolean): boolean;
+    static equalsNumber: typeof Comparisons.equals;
+    static matches: typeof Comparisons.equals;
+    static less(value: string | number, testAgainst: string | number, negation?: boolean): boolean;
+    static lessEqual(value: string | number, testAgainst: string | number, negation?: boolean): boolean;
+    static contains(value: string | number, testAgainst: string | number, negation?: boolean): boolean;
+    static isIn(values: string | number, testAgainst: Array<string | number> | string, negation?: boolean, splitter?: string): boolean;
+    static startsWith(value: string | number, testAgainst: string | number, negation?: boolean): boolean;
+    static endsWith(value: string | number, testAgainst: string | number, negation?: boolean): boolean;
+    static regexMatches(value: string | number, testAgainst: string | number, negation?: boolean): boolean;
+    private static _returnNegationCheck;
+}

package/lib/legacy/utils/src/data-store.d.ts

@@ -0,0 +1,39 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+/**
+ * Example of Data Store implementation with simple database Based JSON file.
+ * It's not recommended to use it in production as it can be memory and CPU intensive.
+ * @param {string} file
+ * @param {module} fs
+ */
+declare class DataStore {
+    private _file;
+    private _fs;
+    /**
+     * @param {string} file
+     * @param {module} fs
+     */
+    constructor(file: string, fs: any);
+    /**
+     * Get value by key
+     * @param {string} key
+     * @return {any}
+     */
+    get(key: string): any;
+    /**
+     * Store value by key
+     * @param {string} key
+     * @param {any} value
+     */
+    set(key: string, value: any): void;
+    /**
+     * Delete value by key
+     * @param {string} key
+     */
+    delete(key: string): void;
+}
+export { DataStore };

package/lib/legacy/utils/src/file-logger.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @param {string} file
+ * @param {module} fs
+ * @param {string=} appendMethod Defaults to 'appendFileSync'
+ * @example new FileLogger('./convert.log', require('fs'), 'appendFileSync')
+ * @constructor
+ */
+declare class FileLogger {
+    private _file;
+    private _fs;
+    private _appendMethod;
+    /**
+     * @param {string} file
+     * @param {module} fs
+     * @param {string=} appendMethod
+     */
+    constructor(file: string, fs: any, appendMethod?: string);
+    private _write;
+    /**
+     * @param {Array<any>} args
+     */
+    log(...args: any): Promise<void>;
+    /**
+     * @param {Array<any>} args
+     */
+    info(...args: any): Promise<void>;
+    /**
+     * @param {Array<any>} args
+     */
+    debug(...args: any): Promise<void>;
+    /**
+     * @param {Array<any>} args
+     */
+    warn(...args: any): Promise<void>;
+    /**
+     * @param {Array<any>} args
+     */
+    error(...args: any): Promise<void>;
+}
+export { FileLogger };

package/lib/legacy/utils/src/http-client.d.ts

@@ -0,0 +1,102 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+export type HttpMethod = 'GET' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'POST' | 'PUT' | 'PATCH';
+export type HttpResponseType = 'json' | 'arraybuffer' | 'text';
+export type HttpRequest = {
+    baseURL: string;
+    path?: string;
+    method?: HttpMethod;
+    headers?: {
+        [x: string]: any;
+    };
+    responseType?: HttpResponseType;
+    data?: Record<string, any>;
+};
+declare enum HttpStatusCode {
+    Continue = 100,
+    SwitchingProtocols = 101,
+    Processing = 102,
+    EarlyHints = 103,
+    Ok = 200,
+    Created = 201,
+    Accepted = 202,
+    NonAuthoritativeInformation = 203,
+    NoContent = 204,
+    ResetContent = 205,
+    PartialContent = 206,
+    MultiStatus = 207,
+    AlreadyReported = 208,
+    ImUsed = 226,
+    MultipleChoices = 300,
+    MovedPermanently = 301,
+    Found = 302,
+    SeeOther = 303,
+    NotModified = 304,
+    UseProxy = 305,
+    Unused = 306,
+    TemporaryRedirect = 307,
+    PermanentRedirect = 308,
+    BadRequest = 400,
+    Unauthorized = 401,
+    PaymentRequired = 402,
+    Forbidden = 403,
+    NotFound = 404,
+    MethodNotAllowed = 405,
+    NotAcceptable = 406,
+    ProxyAuthenticationRequired = 407,
+    RequestTimeout = 408,
+    Conflict = 409,
+    Gone = 410,
+    LengthRequired = 411,
+    PreconditionFailed = 412,
+    PayloadTooLarge = 413,
+    UriTooLong = 414,
+    UnsupportedMediaType = 415,
+    RangeNotSatisfiable = 416,
+    ExpectationFailed = 417,
+    ImATeapot = 418,
+    MisdirectedRequest = 421,
+    UnprocessableEntity = 422,
+    Locked = 423,
+    FailedDependency = 424,
+    TooEarly = 425,
+    UpgradeRequired = 426,
+    PreconditionRequired = 428,
+    TooManyRequests = 429,
+    RequestHeaderFieldsTooLarge = 431,
+    UnavailableForLegalReasons = 451,
+    InternalServerError = 500,
+    NotImplemented = 501,
+    BadGateway = 502,
+    ServiceUnavailable = 503,
+    GatewayTimeout = 504,
+    HttpVersionNotSupported = 505,
+    VariantAlsoNegotiates = 506,
+    InsufficientStorage = 507,
+    LoopDetected = 508,
+    NotExtended = 510,
+    NetworkAuthenticationRequired = 511
+}
+export type HttpResponse = {
+    data: any;
+    status: HttpStatusCode;
+    statusText: string;
+    headers?: {
+        [x: string]: any;
+    };
+};
+interface HttpClientInterface {
+    request(config: HttpRequest): Promise<HttpResponse>;
+}
+export declare const serialize: (params: Record<string, any>, method: string) => string;
+/**
+ * Provide http client for newtork requests
+ * @param {HttpRequest}
+ * @returns {HttpClient}
+ */
+export declare const HttpClient: HttpClientInterface;
+export {};

package/lib/legacy/utils/src/object-utils.d.ts

@@ -0,0 +1,28 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+/**
+ * Returns the value at path of object
+ * @param {Record<string, any>} object
+ * @param {string} path
+ * @param {any=} defaultValue
+ * @param {boolean=} truthy Should Number 0 number and Boolean false be considered as normal value
+ * @return {any}
+ */
+export declare function objectDeepValue(object: Record<string, any>, path: string, defaultValue?: any, truthy?: boolean): any;
+/**
+ * Deep merge objects and their keys and nested objects
+ * Accepts arrays
+ *
+ * @param {...Record<any, any>} objects Objects to merge
+ * @return {Record<any, any>}
+ */
+export declare function objectDeepMerge(...objects: any[]): any;
+/**
+ * Validates variable is object and not empty
+ * @param object
+ */
+export declare function objectNotEmpty(object: any): boolean;

package/lib/legacy/utils/src/string-utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * String formatter tool. Use %s for string %d for digit and %j for JSON formatting
+ * @param {string} template
+ * @param {Array<string>} args
+ * @return {string}
+ */
+export declare function stringFormat(template: string, ...args: any[]): string;
+/**
+ * String formatter tool. Transforms a space-separated string into camelCase
+ * @param {string} input
+ * @return {string}
+ */
+export declare function camelCase(input: string): string;
+/**
+ * Generate numeric hash based on seed
+ * @param {string} value
+ * @param {number=} seed
+ * @return {number}
+ */
+export declare function generateHash(value: string, seed?: number): number;

package/lib/legacy/utils/src/types-utils.d.ts

@@ -0,0 +1,12 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+/**
+ * Transform value type. Does not do any JSON validation
+ * @param value
+ * @param type
+ */
+export declare function castType(value: any, type: string): any;

package/lib/logger/index.d.ts

@@ -0,0 +1,8 @@
+/*!
+ * Convert JS SDK test
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+export { LogManager } from './src/log-manager';
+export { LogManagerInterface } from './src/interfaces/log-manager';

package/lib/logger/src/interfaces/log-client.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+import { LogLevel } from '@convertcom/js-sdk-enums';
+import { LogMethodMapInterface } from './log-method-map';
+export interface LogClientInterface {
+    sdk: any;
+    level: LogLevel;
+    mapper: LogMethodMapInterface;
+}

package/lib/logger/src/interfaces/log-manager.d.ts

@@ -0,0 +1,18 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+import { LogLevel } from '@convertcom/js-sdk-enums';
+import { LogMethodMapInterface } from './log-method-map';
+export interface LogManagerInterface {
+    log(level: LogLevel, ...args: any[]): void;
+    trace(...args: any[]): void;
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    addClient(client?: any, level?: LogLevel, methodMap?: LogMethodMapInterface): void;
+    setClientLevel(level: LogLevel, client?: any): void;
+}

package/lib/logger/src/interfaces/log-method-map.d.ts

@@ -0,0 +1,15 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+import { LogMethod } from '@convertcom/js-sdk-enums';
+export interface LogMethodMapInterface {
+    [LogMethod.LOG]?: string;
+    [LogMethod.DEBUG]?: string;
+    [LogMethod.INFO]?: string;
+    [LogMethod.WARN]?: string;
+    [LogMethod.ERROR]?: string;
+    [LogMethod.TRACE]?: string;
+}

package/lib/logger/src/log-manager.d.ts

@@ -0,0 +1,64 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+import { LogLevel } from '@convertcom/js-sdk-enums';
+import { LogMethodMapInterface } from './interfaces/log-method-map';
+import { LogManagerInterface } from './interfaces/log-manager';
+/**
+ * Provides logging logic
+ * @category Modules
+ * @constructor
+ * @implements {LogManagerInterface}
+ */
+export declare class LogManager implements LogManagerInterface {
+    private _clients;
+    private _defaultMapper;
+    /**
+     * @param {any} client
+     * @param {LogLevel=} level
+     * @param {LogMethodMapInterface=} mapper
+     */
+    constructor(client?: any, level?: LogLevel, mapper?: LogMethodMapInterface);
+    private _isValidLevel;
+    private _isValidMethod;
+    private _log;
+    /**
+     * @param {LogLevel} level
+     * @param {Array<any>} args
+     */
+    log(level: LogLevel, ...args: any[]): void;
+    /**
+     * @param {Array<any>} args
+     */
+    trace(...args: any[]): void;
+    /**
+     * @param {Array<any>} args
+     */
+    debug(...args: any[]): void;
+    /**
+     * @param {Array<any>} args
+     */
+    info(...args: any[]): void;
+    /**
+     * @param {Array<any>} args
+     */
+    warn(...args: any[]): void;
+    /**
+     * @param {Array<any>} args
+     */
+    error(...args: any[]): void;
+    /**
+     * @param {any=} client
+     * @param {LogLevel=} level
+     * @param {LogMethodMapInterface=} methodMap
+     */
+    addClient(client?: any, level?: LogLevel, methodMap?: LogMethodMapInterface): void;
+    /**
+     * @param {LogLevel=} level
+     * @param {any=} client
+     */
+    setClientLevel(level: LogLevel, client?: any): void;
+}

package/lib/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@convertcom/js-sdk-rules",
+  "main": "index.min.js",
+  "module": "index.min.mjs",
+  "browser": "index.umd.min.js",
+  "types": "index.d.ts",
+  "files": [
+    "**/**/*"
+  ],
+  "author": "Convert Insights, Inc",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/convertcom/javascript-sdk.git",
+    "directory": "packages/rules"
+  },
+  "license": "Apache-2.0",
+  "version": "1.0.0"
+}

package/lib/rules/index.d.ts

@@ -0,0 +1,8 @@
+/*!
+ * Convert JS SDK test
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+export { RuleManager } from './src/rule-manager';
+export { RuleManagerInterface } from './src/interfaces/rule-manager';

package/lib/rules/src/interfaces/rule-manager.d.ts

@@ -0,0 +1,14 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+import { Rule, RuleSet } from '@convertcom/js-sdk-types';
+import { RuleError } from '@convertcom/js-sdk-enums';
+export interface RuleManagerInterface {
+    comparisonProcessor: Record<string, any>;
+    getComparisonProcessorMethods(): Array<string>;
+    isRuleMatched(data: Record<string, any>, ruleSet: RuleSet, logEntry?: string): boolean | RuleError;
+    isValidRule(rule: Rule): boolean;
+}

package/lib/rules/src/rule-manager.d.ts

@@ -0,0 +1,75 @@
+import { RuleManagerInterface } from './interfaces/rule-manager';
+import { Config, Rule, RuleSet } from '@convertcom/js-sdk-types';
+import { LogManagerInterface } from '@convertcom/js-sdk-logger';
+import { RuleError } from '@convertcom/js-sdk-enums';
+/**
+ * Provides rule processing calculations with corresponding comparisons methods
+ * @category Modules
+ * @constructor
+ * @implements {RuleManagerInterface}
+ */
+export declare class RuleManager implements RuleManagerInterface {
+    private _comparisonProcessor;
+    private readonly _negation;
+    private readonly _keys_case_sensitive;
+    private _loggerManager;
+    /**
+     * @param {Config=} config
+     * @param {Object=} dependencies
+     * @param {LogManagerInterface=} dependencies.loggerManager
+     */
+    constructor(config?: Config, { loggerManager }?: {
+        loggerManager?: LogManagerInterface;
+    });
+    /**
+     * Setter for comparison processor
+     * @param {Record<string, any>} comparisonProcessor
+     */
+    set comparisonProcessor(comparisonProcessor: Record<string, any>);
+    /**
+     * Getter for comparison processor
+     */
+    get comparisonProcessor(): Record<string, any>;
+    /**
+     * Retrieve comparison methods from comparison processor
+     * @return {Array<string>} List of methods of comparison processor
+     */
+    getComparisonProcessorMethods(): Array<string>;
+    /**
+     * Check input data matching to rule set
+     * @param {Record<string, any>} data Single value or key-value data set to compare
+     * @param {RuleSet} ruleSet
+     * @return {boolean | RuleError}
+     */
+    isRuleMatched(data: Record<string, any>, ruleSet: RuleSet, logEntry?: string): boolean | RuleError;
+    /**
+     * Check is rule object valid
+     * @param {Rule} rule
+     * @return {boolean}
+     */
+    isValidRule(rule: Rule): boolean;
+    /**
+     * Process AND block of rule set. Return first false if found
+     * @param {Record<string, any>} data Single value or key-value data set to compare
+     * @param {RuleAnd} rulesSubset
+     * @return {boolean | RuleError}
+     * @private
+     */
+    private _processAND;
+    /**
+     * Process OR block of rule set. Return first true if found
+     * @param {Record<string, any>} data Single value or key-value data set to compare
+     * @param {RuleOrWhen} rulesSubset
+     * @return {boolean | RuleError}
+     * @private
+     */
+    private _processORWHEN;
+    /**
+     * Process single rule item
+     * @param {Record<string, any>} data Single value or key-value data set to compare
+     * @param {Rule} rule A single rule to compare
+     * @return {boolean | RuleError} Comparison result
+     * @private
+     */
+    private _processRuleItem;
+}