@eventvisor/sdk 0.0.2

package/src/conditions.ts

@@ -0,0 +1,224 @@
+import type { PlainCondition, Condition, Inputs } from "@eventvisor/types";
+
+import type { GetRegex } from "./datafileReader";
+import type { SourceResolver } from "./sourceResolver";
+
+import { compareVersions } from "./compareVersions";
+import { Logger } from "./logger";
+
+export type GetConditionsChecker = () => ConditionsChecker;
+
+export interface ConditionsCheckerOptions {
+  getRegex: GetRegex;
+  sourceResolver: SourceResolver;
+  logger: Logger;
+}
+
+export class ConditionsChecker {
+  private getRegex: GetRegex;
+  private sourceResolver: SourceResolver;
+  private logger: Logger;
+
+  constructor(options: ConditionsCheckerOptions) {
+    this.getRegex = options.getRegex;
+    this.sourceResolver = options.sourceResolver;
+    this.logger = options.logger;
+  }
+
+  async isMatched(condition: PlainCondition, inputs: Inputs): Promise<boolean> {
+    const { operator, value, regexFlags } = condition;
+
+    const sourceValue = await this.sourceResolver.resolve(condition, inputs);
+
+    if (operator === "equals") {
+      return sourceValue === value;
+    } else if (operator === "notEquals") {
+      return sourceValue !== value;
+    } else if (operator === "before" || operator === "after") {
+      // date comparisons
+      const valueInContext = sourceValue as string | Date;
+
+      const dateInContext =
+        valueInContext instanceof Date ? valueInContext : new Date(valueInContext);
+      const dateInCondition = value instanceof Date ? value : new Date(value as string);
+
+      return operator === "before"
+        ? dateInContext < dateInCondition
+        : dateInContext > dateInCondition;
+    } else if (
+      Array.isArray(value) &&
+      (["string", "number"].indexOf(typeof sourceValue) !== -1 || sourceValue === null)
+    ) {
+      // in / notIn (where condition value is an array)
+      const valueInContext = sourceValue as string;
+
+      if (operator === "in") {
+        return value.indexOf(valueInContext) !== -1;
+      } else if (operator === "notIn") {
+        return value.indexOf(valueInContext) === -1;
+      }
+    } else if (typeof sourceValue === "string" && typeof value === "string") {
+      // string
+      const valueInContext = sourceValue as string;
+
+      if (operator === "contains") {
+        return valueInContext.indexOf(value) !== -1;
+      } else if (operator === "notContains") {
+        return valueInContext.indexOf(value) === -1;
+      } else if (operator === "startsWith") {
+        return valueInContext.startsWith(value);
+      } else if (operator === "endsWith") {
+        return valueInContext.endsWith(value);
+      } else if (operator === "semverEquals") {
+        return compareVersions(valueInContext, value) === 0;
+      } else if (operator === "semverNotEquals") {
+        return compareVersions(valueInContext, value) !== 0;
+      } else if (operator === "semverGreaterThan") {
+        return compareVersions(valueInContext, value) === 1;
+      } else if (operator === "semverGreaterThanOrEquals") {
+        return compareVersions(valueInContext, value) >= 0;
+      } else if (operator === "semverLessThan") {
+        return compareVersions(valueInContext, value) === -1;
+      } else if (operator === "semverLessThanOrEquals") {
+        return compareVersions(valueInContext, value) <= 0;
+      } else if (operator === "matches") {
+        const regex = this.getRegex(value, regexFlags || "");
+        return regex.test(valueInContext);
+      } else if (operator === "notMatches") {
+        const regex = this.getRegex(value, regexFlags || "");
+        return !regex.test(valueInContext);
+      }
+    } else if (typeof sourceValue === "number" && typeof value === "number") {
+      // numeric
+      const valueInContext = sourceValue as number;
+
+      if (operator === "greaterThan") {
+        return valueInContext > value;
+      } else if (operator === "greaterThanOrEquals") {
+        return valueInContext >= value;
+      } else if (operator === "lessThan") {
+        return valueInContext < value;
+      } else if (operator === "lessThanOrEquals") {
+        return valueInContext <= value;
+      }
+    } else if (operator === "exists") {
+      // @TODO: may require extra care for null values
+      return typeof sourceValue !== "undefined";
+    } else if (operator === "notExists") {
+      return typeof sourceValue === "undefined";
+    } else if (Array.isArray(sourceValue) && typeof value === "string") {
+      // includes / notIncludes (where context value is an array)
+      const valueInContext = sourceValue as string[];
+
+      if (operator === "includes") {
+        return valueInContext.indexOf(value) > -1;
+      } else if (operator === "notIncludes") {
+        return valueInContext.indexOf(value) === -1;
+      }
+    }
+
+    return false;
+  }
+
+  private async _allAreMatched(
+    conditions: Condition[] | Condition,
+    inputs: Inputs,
+  ): Promise<boolean> {
+    if (typeof conditions === "string") {
+      if (conditions === "*") {
+        return true;
+      }
+
+      return false;
+    }
+
+    if ("operator" in conditions) {
+      try {
+        return this.isMatched(conditions, inputs);
+      } catch (e) {
+        this.logger.warn(e.message, {
+          error: e,
+          details: {
+            condition: conditions,
+          },
+        });
+
+        return false;
+      }
+    }
+
+    if ("and" in conditions && Array.isArray(conditions.and)) {
+      for (const c of conditions.and) {
+        if (!(await this._allAreMatched(c, inputs))) {
+          return false; // If any condition fails, return false
+        }
+      }
+      return true; // All conditions passed
+    }
+
+    if ("or" in conditions && Array.isArray(conditions.or)) {
+      for (const c of conditions.or) {
+        if (await this._allAreMatched(c, inputs)) {
+          return true; // If any condition passes, return true
+        }
+      }
+      return false; // No conditions passed
+    }
+
+    if ("not" in conditions && Array.isArray(conditions.not)) {
+      for (const c of conditions.not) {
+        if (await this._allAreMatched(c, inputs)) {
+          return false; // If any condition passes, return false (since this is NOT)
+        }
+      }
+      return true; // No conditions passed, which is what we want for NOT
+    }
+
+    if (Array.isArray(conditions)) {
+      let result = true;
+      for (const c of conditions) {
+        if (!(await this._allAreMatched(c, inputs))) {
+          result = false;
+          break;
+        }
+      }
+
+      return result;
+    }
+
+    return false;
+  }
+
+  async allAreMatched(conditions: Condition[] | Condition, inputs: Inputs): Promise<boolean> {
+    const parsedConditions = this.parseIfStringified(conditions);
+
+    const result = this._allAreMatched(parsedConditions, inputs);
+
+    return result;
+  }
+
+  parseIfStringified(conditions: Condition | Condition[]): Condition | Condition[] {
+    if (typeof conditions !== "string") {
+      // already parsed
+      return conditions;
+    }
+
+    if (conditions === "*") {
+      // everyone
+      return conditions;
+    }
+
+    try {
+      return JSON.parse(conditions);
+    } catch (e) {
+      this.logger.error("Error parsing conditions", {
+        error: e,
+        details: {
+          conditions,
+        },
+      });
+
+      return conditions;
+    }
+  }
+}

package/src/datafileReader.ts

@@ -0,0 +1,133 @@
+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 const emptyDatafile: DatafileContent = {
+  schemaVersion: "1",
+  revision: "0",
+
+  attributes: {},
+  events: {},
+  destinations: {},
+  effects: {},
+};
+
+export function getComplexPersists(persist: Persist): ComplexPersist[] {
+  let result: ComplexPersist[] = [];
+
+  if (typeof persist === "string") {
+    result.push({ storage: persist });
+  } else if (Array.isArray(persist)) {
+    for (const p of persist) {
+      const r = getComplexPersists(p);
+
+      if (r) {
+        result = result.concat(r);
+      }
+    }
+  } else if (typeof persist === "object") {
+    result.push(persist);
+  }
+
+  return result;
+}
+
+export class DatafileReader {
+  private schemaVersion: string;
+  private revision: string;
+
+  private datafile: DatafileContent;
+  private logger: Logger;
+  private regexCache: Record<string, RegExp>;
+
+  constructor(options: DatafileReaderOptions) {
+    const { datafile, logger } = options;
+
+    this.datafile = datafile;
+    this.schemaVersion = datafile.schemaVersion;
+    this.revision = datafile.revision;
+
+    this.regexCache = {};
+
+    this.logger = logger;
+  }
+
+  getSchemaVersion(): string {
+    return this.schemaVersion;
+  }
+
+  getRevision(): string {
+    return this.revision;
+  }
+
+  getAttribute(attributeName: AttributeName): Attribute | undefined {
+    return this.datafile.attributes[attributeName];
+  }
+
+  getAttributeNames(): AttributeName[] {
+    return Object.keys(this.datafile.attributes);
+  }
+
+  getEvent(eventName: EventName): Event | undefined {
+    return this.datafile.events[eventName];
+  }
+
+  getDestination(destinationName: DestinationName): Destination | undefined {
+    return this.datafile.destinations[destinationName];
+  }
+
+  getDestinationNames(): DestinationName[] {
+    return Object.keys(this.datafile.destinations);
+  }
+
+  getEffect(effectName: EffectName): Effect | undefined {
+    return this.datafile.effects[effectName];
+  }
+
+  getEffectNames(): EffectName[] {
+    return Object.keys(this.datafile.effects);
+  }
+
+  getRegex(regexString: string, regexFlags?: string): RegExp {
+    const flags = regexFlags || "";
+    const cacheKey = `${regexString}-${flags}`;
+
+    if (this.regexCache[cacheKey]) {
+      return this.regexCache[cacheKey];
+    }
+
+    const regex = new RegExp(regexString, flags);
+    this.regexCache[cacheKey] = regex;
+
+    return regex;
+  }
+
+  getPersists(schema: Attribute | Effect): ComplexPersist[] | null {
+    if (!schema || !schema.persist) {
+      return null;
+    }
+
+    return getComplexPersists(schema.persist);
+  }
+}

package/src/effectsManager.ts

@@ -0,0 +1,214 @@
+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";
+import { initializeFromStorage, persistEntity } from "./persister";
+
+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 class EffectsManager {
+  private logger: Logger;
+  private getDatafileReader: GetDatafileReader;
+  private getTransformer: GetTransformer;
+  private getConditionsChecker: GetConditionsChecker;
+  private modulesManager: ModulesManager;
+
+  private statesByEffect: StatesByEffect = {};
+
+  constructor(options: EffectsManagerOptions) {
+    this.logger = options.logger;
+    this.getDatafileReader = options.getDatafileReader;
+    this.getTransformer = options.getTransformer;
+    this.getConditionsChecker = options.getConditionsChecker;
+    this.modulesManager = options.modulesManager;
+  }
+
+  async initialize(): Promise<void> {
+    const datafileReader = this.getDatafileReader();
+    const effects = datafileReader.getEffectNames();
+
+    const persistedResult = await initializeFromStorage({
+      datafileReader,
+      conditionsChecker: this.getConditionsChecker(),
+      modulesManager: this.modulesManager,
+      storageKeyPrefix: "effects_",
+      getEntityNames: () => datafileReader.getEffectNames(),
+      getEntity: (entityName: string) => datafileReader.getEffect(entityName),
+    });
+
+    for (const effectName of effects) {
+      const effect = datafileReader.getEffect(effectName);
+
+      if (!effect) {
+        continue;
+      }
+
+      if (typeof this.statesByEffect[effectName] !== "undefined") {
+        // possibly called via refresh() method after initialization
+        continue;
+      }
+
+      if (typeof persistedResult[effectName] !== "undefined") {
+        // from storage
+        this.statesByEffect[effectName] = persistedResult[effectName];
+      } else {
+        // from initial state of effect
+        if (typeof effect.state !== "undefined") {
+          if (typeof this.statesByEffect[effectName] === "undefined") {
+            this.statesByEffect[effectName] = effect.state;
+          }
+        }
+      }
+    }
+  }
+
+  async dispatch(dispatchOptions: DispatchOptions) {
+    // @TODO: rename to actionType
+    const { eventType, name, value } = dispatchOptions;
+
+    const datafileReader = this.getDatafileReader();
+    const conditionsChecker = this.getConditionsChecker();
+    const transformer = this.getTransformer();
+
+    const allEffects = datafileReader.getEffectNames();
+
+    for (const effectName of allEffects) {
+      const effect = datafileReader.getEffect(effectName);
+
+      if (!effect) {
+        continue;
+      }
+
+      if (eventType === "event_tracked") {
+        if (Array.isArray(effect.on) && !effect.on.includes("event_tracked")) {
+          continue;
+        }
+
+        if (typeof effect.on === "object" && !effect.on["event_tracked"]?.includes(name)) {
+          continue;
+        }
+      }
+
+      if (eventType === "attribute_set") {
+        if (Array.isArray(effect.on) && !effect.on.includes("attribute_set")) {
+          continue;
+        }
+
+        if (typeof effect.on === "object" && !effect.on["attribute_set"]?.includes(name)) {
+          continue;
+        }
+      }
+
+      // conditions
+      if (effect.conditions) {
+        const isMatched = await conditionsChecker.allAreMatched(effect.conditions, {
+          payload: value,
+          eventName: eventType === "event_tracked" ? name : undefined,
+          attributeName: eventType === "attribute_set" ? name : undefined,
+          state: this.statesByEffect[effectName],
+        });
+
+        if (!isMatched) {
+          continue;
+        }
+      }
+
+      // steps
+      if (effect.steps) {
+        for (const step of effect.steps) {
+          let stepPassed = true;
+
+          // conditions
+          if (step.conditions) {
+            const conditionsChecker = this.getConditionsChecker();
+            const isMatched = await conditionsChecker.allAreMatched(step.conditions, {
+              payload: value,
+              eventName: eventType === "event_tracked" ? name : undefined,
+              attributeName: eventType === "attribute_set" ? name : undefined,
+              state: this.statesByEffect[effectName],
+            });
+
+            if (!isMatched) {
+              continue;
+            }
+          }
+
+          // handler
+          if (step.handler) {
+            try {
+              await this.modulesManager.handle(step.handler, effectName, effect, step, value);
+            } catch (handlerError) {
+              this.logger.error(`Effect handler error`, {
+                effectName,
+                step,
+                error: handlerError,
+              });
+
+              stepPassed = false;
+            }
+          }
+
+          // continueOnError
+          if (!stepPassed && typeof step.continueOnError === "boolean" && !step.continueOnError) {
+            break;
+          }
+
+          // transforms
+          if (step.transforms) {
+            this.statesByEffect[effectName] = await transformer.applyAll(
+              this.statesByEffect[effectName],
+              step.transforms,
+              {
+                eventName: eventType === "event_tracked" ? name : undefined,
+                attributeName: eventType === "attribute_set" ? name : undefined,
+                state: this.statesByEffect[effectName],
+              },
+            );
+          }
+        }
+      }
+
+      // persist
+      await persistEntity({
+        datafileReader,
+        conditionsChecker,
+        modulesManager: this.modulesManager,
+        storageKeyPrefix: "effects_",
+        entityName: effectName,
+        entity: effect,
+        value: this.statesByEffect[effectName],
+      });
+    }
+  }
+
+  // called after datafile refresh
+  refresh() {
+    // @TODO: think
+    this.initialize();
+  }
+
+  getAllStates() {
+    return this.statesByEffect;
+  }
+
+  getStateValue(name: EffectName) {
+    return this.statesByEffect[name];
+  }
+}

package/src/emitter.ts

@@ -0,0 +1,64 @@
+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[]> | {}; // eslint-disable-line
+
+export class Emitter {
+  listeners: Listeners;
+
+  constructor() {
+    this.listeners = {};
+  }
+
+  on(emitType: EmitType, callback: EventCallback) {
+    if (!this.listeners[emitType]) {
+      this.listeners[emitType] = [];
+    }
+
+    const listeners = this.listeners[emitType];
+    listeners.push(callback);
+
+    let isActive = true;
+
+    return function unsubscribe() {
+      if (!isActive) {
+        return;
+      }
+
+      isActive = false;
+
+      const index = listeners.indexOf(callback);
+      if (index !== -1) {
+        listeners.splice(index, 1);
+      }
+    };
+  }
+
+  trigger(emitType: EmitType, details: EventDetails = {}) {
+    const listeners = this.listeners[emitType];
+
+    if (!listeners) {
+      return;
+    }
+
+    listeners.forEach(function (listener) {
+      try {
+        listener(details);
+      } catch (err) {
+        console.error(err);
+      }
+    });
+  }
+
+  clearAll() {
+    this.listeners = {};
+  }
+}

package/src/index.spec.ts

@@ -0,0 +1,5 @@
+describe("sdk: Index", function () {
+  it("should be a function", function () {
+    expect(true).toBe(true);
+  });
+});

package/src/index.ts

@@ -0,0 +1,14 @@
+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";