@eventvisor/sdk 0.0.2

package/lib/attributesManager.d.ts

@@ -0,0 +1,36 @@
+import type { AttributeName, Value } from "@eventvisor/types";
+import type { GetDatafileReader } from "./datafileReader";
+import type { GetConditionsChecker } from "./conditions";
+import type { ModulesManager } from "./modulesManager";
+import type { Emitter } from "./emitter";
+import type { Logger } from "./logger";
+import type { GetTransformer } from "./transformer";
+import type { Validator } from "./validator";
+export type AttributesMap = Record<AttributeName, Value>;
+export interface AttributesManagerOptions {
+    logger: Logger;
+    emitter: Emitter;
+    getDatafileReader: GetDatafileReader;
+    getTransformer: GetTransformer;
+    getConditionsChecker: GetConditionsChecker;
+    validator: Validator;
+    modulesManager: ModulesManager;
+}
+export declare class AttributesManager {
+    private logger;
+    private getDatafileReader;
+    private emitter;
+    private getTransformer;
+    private getConditionsChecker;
+    private validator;
+    private modulesManager;
+    private attributesMap;
+    constructor(options: AttributesManagerOptions);
+    initialize(): Promise<void>;
+    private initializeFromStorage;
+    setAttribute(attributeName: AttributeName, value: Value): Promise<Value | null>;
+    isAttributeSet(attributeName: AttributeName): boolean;
+    getAttributesMap(): AttributesMap;
+    getAttributeValue(attributeName: AttributeName): Value | null;
+    removeAttribute(attributeName: AttributeName): Promise<void>;
+}

package/lib/bucketer.d.ts

@@ -0,0 +1,30 @@
+import type { Sample, SampleBy, Inputs } from "@eventvisor/types";
+import type { Logger } from "./logger";
+import type { SourceResolver } from "./sourceResolver";
+import type { ConditionsChecker } from "./conditions";
+import type { Transformer } from "./transformer";
+export type BucketKey = string;
+export type BucketValue = number;
+export declare const MAX_BUCKETED_NUMBER = 100000;
+export declare function getBucketedNumber(bucketKey: string): BucketValue;
+export declare class BucketerOptions {
+    logger: Logger;
+    sourceResolver: SourceResolver;
+    conditionsChecker: ConditionsChecker;
+    transformer: Transformer;
+}
+export interface SampleResult {
+    isSampled: boolean;
+    matchedSample?: Sample;
+    bucketedNumber?: number;
+    bucketKey?: BucketKey;
+}
+export declare class Bucketer {
+    private logger;
+    private sourceResolver;
+    private conditionsChecker;
+    private transformer;
+    constructor(options: BucketerOptions);
+    getBucketKey(sampleBy: SampleBy, inputs: Inputs): Promise<BucketKey>;
+    isSampled(sample: Sample | Sample[], inputs: Inputs): Promise<SampleResult>;
+}

package/lib/compareVersions.d.ts

@@ -0,0 +1,4 @@
+export declare const semver: RegExp;
+export declare const validateAndParse: (version: string) => RegExpMatchArray;
+export declare const compareSegments: (a: string | string[] | RegExpMatchArray, b: string | string[] | RegExpMatchArray) => 0 | 1 | -1;
+export declare const compareVersions: (v1: string, v2: string) => 0 | 1 | -1;

package/lib/conditions.d.ts

@@ -0,0 +1,20 @@
+import type { PlainCondition, Condition, Inputs } from "@eventvisor/types";
+import type { GetRegex } from "./datafileReader";
+import type { SourceResolver } from "./sourceResolver";
+import { Logger } from "./logger";
+export type GetConditionsChecker = () => ConditionsChecker;
+export interface ConditionsCheckerOptions {
+    getRegex: GetRegex;
+    sourceResolver: SourceResolver;
+    logger: Logger;
+}
+export declare class ConditionsChecker {
+    private getRegex;
+    private sourceResolver;
+    private logger;
+    constructor(options: ConditionsCheckerOptions);
+    isMatched(condition: PlainCondition, inputs: Inputs): Promise<boolean>;
+    private _allAreMatched;
+    allAreMatched(conditions: Condition[] | Condition, inputs: Inputs): Promise<boolean>;
+    parseIfStringified(conditions: Condition | Condition[]): Condition | Condition[];
+}

package/lib/datafileReader.d.ts

@@ -0,0 +1,29 @@
+import { AttributeName, DatafileContent, DestinationName, EffectName, EventName, Persist, ComplexPersist, Attribute, Effect, Event, Destination } from "@eventvisor/types";
+import { Logger } from "./logger";
+export interface DatafileReaderOptions {
+    datafile: DatafileContent;
+    logger: Logger;
+}
+export type GetDatafileReader = () => DatafileReader;
+export type GetRegex = (regexString: string, regexFlags?: string) => RegExp;
+export declare const emptyDatafile: DatafileContent;
+export declare function getComplexPersists(persist: Persist): ComplexPersist[];
+export declare class DatafileReader {
+    private schemaVersion;
+    private revision;
+    private datafile;
+    private logger;
+    private regexCache;
+    constructor(options: DatafileReaderOptions);
+    getSchemaVersion(): string;
+    getRevision(): string;
+    getAttribute(attributeName: AttributeName): Attribute | undefined;
+    getAttributeNames(): AttributeName[];
+    getEvent(eventName: EventName): Event | undefined;
+    getDestination(destinationName: DestinationName): Destination | undefined;
+    getDestinationNames(): DestinationName[];
+    getEffect(effectName: EffectName): Effect | undefined;
+    getEffectNames(): EffectName[];
+    getRegex(regexString: string, regexFlags?: string): RegExp;
+    getPersists(schema: Attribute | Effect): ComplexPersist[] | null;
+}

package/lib/effectsManager.d.ts

@@ -0,0 +1,33 @@
+import type { EventName, AttributeName, EffectName, Value, EffectOnType } from "@eventvisor/types";
+import type { GetDatafileReader } from "./datafileReader";
+import type { Logger } from "./logger";
+import type { GetTransformer } from "./transformer";
+import type { GetConditionsChecker } from "./conditions";
+import type { ModulesManager } from "./modulesManager";
+export type StatesByEffect = Record<EffectName, Value>;
+export interface DispatchOptions {
+    eventType: EffectOnType;
+    name: EventName | AttributeName;
+    value: Value;
+}
+export interface EffectsManagerOptions {
+    logger: Logger;
+    getDatafileReader: GetDatafileReader;
+    getTransformer: GetTransformer;
+    getConditionsChecker: GetConditionsChecker;
+    modulesManager: ModulesManager;
+}
+export declare class EffectsManager {
+    private logger;
+    private getDatafileReader;
+    private getTransformer;
+    private getConditionsChecker;
+    private modulesManager;
+    private statesByEffect;
+    constructor(options: EffectsManagerOptions);
+    initialize(): Promise<void>;
+    dispatch(dispatchOptions: DispatchOptions): Promise<void>;
+    refresh(): void;
+    getAllStates(): StatesByEffect;
+    getStateValue(name: EffectName): Value;
+}

package/lib/emitter.d.ts

@@ -0,0 +1,11 @@
+export type EmitType = "ready" | "datafile_set" | "attribute_set" | "attribute_removed" | "event_tracked";
+export type EventDetails = Record<string, unknown>;
+export type EventCallback = (details: EventDetails) => void;
+export type Listeners = Record<EmitType, EventCallback[]> | {};
+export declare class Emitter {
+    listeners: Listeners;
+    constructor();
+    on(emitType: EmitType, callback: EventCallback): () => void;
+    trigger(emitType: EmitType, details?: EventDetails): void;
+    clearAll(): void;
+}

package/lib/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./instance";
+export * from "./attributesManager";
+export * from "./datafileReader";
+export * from "./emitter";
+export * from "./logger";
+export * from "./transformer";
+export * from "./bucketer";
+export * from "./sourceResolver";
+export * from "./modulesManager";
+export * from "./effectsManager";
+export * from "./murmurhash";
+export * from "./compareVersions";

package/lib/instance.d.ts

@@ -0,0 +1,67 @@
+import { AttributeName, DatafileContent, EventName, EffectName, Value } from "@eventvisor/types";
+import { Logger, LogLevel } from "./logger";
+import { EmitType, EventCallback } from "./emitter";
+import { Module, ModuleName } from "./modulesManager";
+export interface InstanceOptions {
+    datafile?: DatafileContent;
+    logLevel?: LogLevel;
+    logger?: Logger;
+    modules?: Module[];
+}
+export declare class Eventvisor {
+    private datafileReader;
+    private logger;
+    private emitter;
+    private attributesManager;
+    private modulesManager;
+    private effectsManager;
+    private sourceResolver;
+    private conditionsChecker;
+    private transformer;
+    private bucketer;
+    private validator;
+    private ready;
+    private queue;
+    private queueProcessing;
+    constructor(options?: InstanceOptions);
+    isReady(): boolean;
+    onReady(): Promise<void>;
+    getRevision(): string;
+    setLogLevel(level: LogLevel): void;
+    setDatafile(datafile: DatafileContent): void;
+    on(emitType: EmitType, callback: EventCallback): () => void;
+    /**
+     * Queue
+     */
+    private addToQueue;
+    private processQueue;
+    /**
+     * Attribute
+     */
+    setAttributeAsync(attributeName: AttributeName, value: Value): Promise<Value>;
+    setAttribute(attributeName: AttributeName, value: Value): void;
+    getAttributeValue(attributeName: AttributeName): Value;
+    getAttributes(): import("./attributesManager").AttributesMap;
+    isAttributeSet(attributeName: AttributeName): boolean;
+    removeAttributeAsync(attributeName: AttributeName): Promise<void>;
+    removeAttribute(attributeName: AttributeName): void;
+    /**
+     * Modules
+     */
+    registerModule(module: Module): void;
+    removeModule(moduleName: ModuleName): void;
+    /**
+     * Event
+     */
+    trackAsync(eventName: EventName, value: Value): Promise<Value | null>;
+    track(eventName: EventName, value: Value): void;
+    /**
+     * Effect's state
+     */
+    getStateValue(name: EffectName): Value;
+    /**
+     * @TODO: implement
+     */
+    spawn(): void;
+}
+export declare function createInstance(options?: InstanceOptions): Eventvisor;

package/lib/logger.d.ts

@@ -0,0 +1,26 @@
+export type LogLevel = "fatal" | "error" | "warn" | "info" | "debug";
+export type LogMessage = string;
+export interface LogDetails {
+    [key: string]: any;
+}
+export type LogHandler = (level: LogLevel, message: LogMessage, details?: LogDetails) => void;
+export interface CreateLoggerOptions {
+    level?: LogLevel;
+    handler?: LogHandler;
+}
+export declare const loggerPrefix = "[Eventvisor]";
+export declare const defaultLogHandler: LogHandler;
+export declare class Logger {
+    static allLevels: LogLevel[];
+    static defaultLevel: LogLevel;
+    private level;
+    private handle;
+    constructor(options: CreateLoggerOptions);
+    setLevel(level: LogLevel): void;
+    log(level: LogLevel, message: LogMessage, details?: LogDetails): void;
+    debug(message: LogMessage, details?: LogDetails): void;
+    info(message: LogMessage, details?: LogDetails): void;
+    warn(message: LogMessage, details?: LogDetails): void;
+    error(message: LogMessage, details?: LogDetails): void;
+}
+export declare function createLogger(options?: CreateLoggerOptions): Logger;

package/lib/modulesManager.d.ts

@@ -0,0 +1,67 @@
+import type { Value, Effect, Step, EventName, DestinationName, EffectName, EventLevel } from "@eventvisor/types";
+import type { Logger } from "./logger";
+import type { DatafileReader } from "./datafileReader";
+import type { SourceResolver } from "./sourceResolver";
+export type ModuleName = string;
+export interface LookupOptions {
+    key: string;
+}
+export interface HandleOptions {
+    effectName: EffectName;
+    effect: Effect;
+    step: Step;
+    payload: Value;
+}
+export interface TransportOptions {
+    destinationName: DestinationName;
+    eventName: EventName;
+    eventLevel?: EventLevel;
+    payload: Value;
+}
+export interface ReadFromStorageOptions {
+    key: string;
+}
+export interface WriteToStorageOptions {
+    key: string;
+    value: Value;
+}
+export interface RemoveFromStorageOptions {
+    key: string;
+}
+export interface ModuleDependencies {
+    datafileReader: DatafileReader;
+    logger: Logger;
+    sourceResolver: SourceResolver;
+}
+export interface Module {
+    name: ModuleName;
+    lookup?: (options: LookupOptions, deps: ModuleDependencies) => Promise<Value>;
+    handle?: (options: HandleOptions, deps: ModuleDependencies) => Promise<void>;
+    transport?: (options: TransportOptions, deps: ModuleDependencies) => Promise<void>;
+    readFromStorage?: (options: ReadFromStorageOptions, deps: ModuleDependencies) => Promise<Value>;
+    writeToStorage?: (options: WriteToStorageOptions, deps: ModuleDependencies) => Promise<void>;
+    removeFromStorage?: (options: RemoveFromStorageOptions, deps: ModuleDependencies) => Promise<void>;
+}
+export interface ModulesManagerOptions {
+    logger: Logger;
+    getDatafileReader: () => DatafileReader;
+    getSourceResolver: () => SourceResolver;
+}
+export declare class ModulesManager {
+    private logger;
+    private getDatafileReader;
+    private getSourceResolver;
+    private modules;
+    constructor(options: ModulesManagerOptions);
+    registerModule(module: Module): void;
+    getModule(name: string): Module;
+    removeModule(name: string): void;
+    getModuleDependencies(): ModuleDependencies;
+    lookup(fullKey: string): Promise<Value>;
+    handle(fullKey: string, effectName: EffectName, effect: Effect, step: Step, payload: Value): Promise<void>;
+    transportExists(fullKey: string): boolean;
+    transport(fullKey: string, destinationName: DestinationName, eventName: EventName, payload: Value, eventLevel?: EventLevel): Promise<void>;
+    readFromStorage(moduleName: ModuleName, key: string): Promise<Value>;
+    writeToStorage(moduleName: ModuleName, key: string, value: Value): Promise<void>;
+    removeFromStorage(moduleName: ModuleName, key: string): Promise<void>;
+}

package/lib/murmurhash.d.ts

@@ -0,0 +1 @@
+export declare function MurmurHashV3(key: any, seed: any): number;

package/lib/persister.d.ts

@@ -0,0 +1,40 @@
+import type { Attribute, Effect, Value, ComplexPersist } from "@eventvisor/types";
+import type { DatafileReader } from "./datafileReader";
+import type { ConditionsChecker } from "./conditions";
+import type { ModulesManager } from "./modulesManager";
+export type EntityMap = Record<string, Value>;
+export interface InitializeFromStorageOptions {
+    datafileReader: DatafileReader;
+    conditionsChecker: ConditionsChecker;
+    modulesManager: ModulesManager;
+    storageKeyPrefix: string;
+    getEntityNames: () => string[];
+    getEntity: (entityName: string) => Attribute | Effect | undefined;
+}
+export interface FindPersistOptions {
+    persists: ComplexPersist[];
+    entityName: string;
+    conditionsChecker: ConditionsChecker;
+    payload: Value;
+}
+export declare function findPersist(options: FindPersistOptions): Promise<ComplexPersist | undefined>;
+export declare function initializeFromStorage({ datafileReader, conditionsChecker, modulesManager, storageKeyPrefix, getEntityNames, getEntity, }: InitializeFromStorageOptions): Promise<EntityMap>;
+export interface PersistEntityOptions {
+    datafileReader: DatafileReader;
+    conditionsChecker: ConditionsChecker;
+    modulesManager: ModulesManager;
+    storageKeyPrefix: string;
+    entityName: string;
+    entity: Attribute | Effect | undefined;
+    value: Value;
+}
+export declare function persistEntity({ datafileReader, conditionsChecker, modulesManager, storageKeyPrefix, entityName, entity, value, }: PersistEntityOptions): Promise<void>;
+export interface RemoveEntityOptions {
+    datafileReader: DatafileReader;
+    conditionsChecker: ConditionsChecker;
+    modulesManager: ModulesManager;
+    storageKeyPrefix: string;
+    entityName: string;
+    entity: Attribute | Effect | undefined;
+}
+export declare function removeEntity({ datafileReader, conditionsChecker, modulesManager, storageKeyPrefix, entityName, entity, }: RemoveEntityOptions): Promise<void>;

package/lib/sourceResolver.d.ts

@@ -0,0 +1,31 @@
+import type { Source, SourceBase, Value, Inputs } from "@eventvisor/types";
+import type { ModulesManager } from "./modulesManager";
+import type { Logger } from "./logger";
+import type { AttributesManager } from "./attributesManager";
+import type { EffectsManager } from "./effectsManager";
+export type GetSourceResolver = () => SourceResolver;
+export interface SourceResolverOptions {
+    logger: Logger;
+    modulesManager: ModulesManager;
+    attributesManager: AttributesManager;
+    effectsManager: EffectsManager;
+}
+export interface SourcePath {
+    name: string;
+    path: string[];
+    fullKey: string;
+}
+export type SourceOrigin = SourcePath & {
+    originType: "attribute" | "attributes" | "effect" | "payload" | "lookup" | string;
+};
+export declare class SourceResolver {
+    private logger;
+    private modulesManager;
+    private attributesManager;
+    private effectsManager;
+    constructor(options: SourceResolverOptions);
+    getPath(p: string): SourcePath;
+    getOrigin(source: Source | Partial<SourceBase>): SourceOrigin | SourceOrigin[] | null;
+    resolveByOrigin(origin: SourceOrigin | null, inputs?: Inputs): Promise<Value>;
+    resolve(source: Source | Partial<SourceBase>, inputs?: Inputs): Promise<Value>;
+}

package/lib/transformer.d.ts

@@ -0,0 +1,21 @@
+import type { Value, Transform, Inputs } from "@eventvisor/types";
+import type { Logger } from "./logger";
+import type { ConditionsChecker } from "./conditions";
+import type { SourceResolver } from "./sourceResolver";
+export type GetTransformer = () => Transformer;
+export interface TransformerOptions {
+    logger: Logger;
+    conditionsChecker: ConditionsChecker;
+    sourceResolver: SourceResolver;
+}
+export declare class Transformer {
+    private logger;
+    private conditionsChecker;
+    private sourceResolver;
+    constructor(options: TransformerOptions);
+    applyAll(value: Value, transforms: Transform[], inputs?: Inputs): Promise<Value>;
+    static renameValueAt(obj: any, target: Record<string, string>): any;
+    static getValueAtPath(obj: any, path: string): any;
+    static setValueAtPath(obj: any, path: string, value: any): any;
+    static removeValueAt(obj: any, path: string): any;
+}

package/lib/validator.d.ts

@@ -0,0 +1,28 @@
+import { JSONSchema, Value } from "@eventvisor/types";
+import type { GetSourceResolver } from "./sourceResolver";
+import type { Logger } from "./logger";
+export interface ValidatorOptions {
+    logger: Logger;
+    getSourceResolver: GetSourceResolver;
+}
+export declare class Validator {
+    private logger;
+    private getSourceResolver;
+    constructor(options: ValidatorOptions);
+    validate(schema: JSONSchema, value: Value): Promise<ValidationResult>;
+}
+export interface ValidationError {
+    path: string;
+    message: string;
+    schema?: JSONSchema;
+    value?: Value;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors?: ValidationError[];
+    value?: Value;
+}
+export interface ValidationDependencies {
+    [key: string]: any;
+}
+export declare function validate(schema: JSONSchema, value: Value, deps: ValidationDependencies): Promise<ValidationResult>;

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@eventvisor/sdk",
+  "version": "0.0.2",
+  "description": "Eventvisor SDK for Node.js and the browser",
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "transpile": "echo 'Nothing to transpile'",
+    "dist": "webpack --config ./webpack.config.js && tsc --project tsconfig.esm.json --declaration --emitDeclarationOnly --declarationDir dist",
+    "build": "npm run transpile && npm run dist",
+    "test": "jest --config jest.config.js --verbose --coverage",
+    "test:no-coverage": "jest --config jest.config.js --verbose"
+  },
+  "author": {
+    "name": "Fahad Heylaal",
+    "url": "https://fahad19.com"
+  },
+  "homepage": "https://eventvisor.org",
+  "keywords": [],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/eventvisor/eventvisor.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "bugs": {
+    "url": "https://github.com/eventvisor/eventvisor/issues"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@eventvisor/types": "0.0.2"
+  },
+  "gitHead": "373d5c00cb6fa0d6f4baaa05a10e57e505474847"
+}