@eventvisor/sdk 0.0.2

package/src/sourceResolver.spec.ts

@@ -0,0 +1,253 @@
+import { SourceResolver } from "./sourceResolver";
+import { Emitter } from "./emitter";
+import { createLogger } from "./logger";
+import { ModulesManager } from "./modulesManager";
+import { AttributesManager } from "./attributesManager";
+import { EffectsManager } from "./effectsManager";
+import { DatafileReader } from "./datafileReader";
+import { Validator } from "./validator";
+import { ConditionsChecker } from "./conditions";
+import { Transformer } from "./transformer";
+
+describe("SourceResolver", () => {
+  // initialize the dependencies
+  const emitter = new Emitter();
+
+  const logger = createLogger({ level: "fatal" });
+
+  const datafileReader = new DatafileReader({
+    datafile: {
+      schemaVersion: "1",
+      revision: "0",
+      attributes: {
+        attribute1: {
+          type: "string",
+        },
+        attribute2: {
+          type: "number",
+        },
+        attribute3: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+            },
+          },
+        },
+      },
+      events: {},
+      destinations: {},
+      effects: {
+        effect1: {
+          state: {
+            nested: {
+              value: "effect1 value",
+            },
+          },
+        },
+        effect2: {
+          state: 123,
+        },
+      },
+    },
+    logger,
+  });
+
+  const modulesManager = new ModulesManager({
+    logger,
+    getDatafileReader: () => datafileReader,
+    getSourceResolver: () => sourceResolver,
+  });
+
+  modulesManager.registerModule({
+    name: "module1",
+    lookup: async ({ key }) => {
+      if (!key) {
+        return "module1 lookup value";
+      }
+
+      return `module1 lookup value: ${key}`;
+    },
+  });
+
+  const validator = new Validator({
+    logger,
+    getSourceResolver: () => sourceResolver,
+  });
+
+  const attributesManager = new AttributesManager({
+    logger,
+    emitter,
+    validator,
+    getDatafileReader: () => datafileReader,
+    getTransformer: () => transformer,
+    getConditionsChecker: () => conditionsChecker,
+    modulesManager,
+  });
+
+  attributesManager.setAttribute("attribute1", "attribute1 value");
+  attributesManager.setAttribute("attribute2", 200);
+  attributesManager.setAttribute("attribute3", { name: "attribute3 value" });
+
+  const effectsManager = new EffectsManager({
+    logger,
+    getDatafileReader: () => datafileReader,
+    getTransformer: () => transformer,
+    getConditionsChecker: () => conditionsChecker,
+    modulesManager: modulesManager,
+  });
+
+  const sourceResolver = new SourceResolver({
+    logger,
+    modulesManager,
+    attributesManager,
+    effectsManager,
+  });
+
+  const conditionsChecker = new ConditionsChecker({
+    logger,
+    getRegex: (regexString, regexFlags) => new RegExp(regexString, regexFlags),
+    sourceResolver,
+  });
+
+  const transformer = new Transformer({
+    logger,
+    conditionsChecker,
+    sourceResolver,
+  });
+
+  effectsManager.initialize();
+
+  it("should resolve plain source from inputs", async () => {
+    expect(
+      await sourceResolver.resolve("payload.age", {
+        payload: {
+          age: 25,
+        },
+      }),
+    ).toEqual(25);
+
+    expect(
+      await sourceResolver.resolve(
+        {
+          payload: "age",
+        },
+        {
+          payload: {
+            age: 25,
+          },
+        },
+      ),
+    ).toEqual(25);
+
+    expect(
+      await sourceResolver.resolve(
+        {
+          source: "payload.age",
+        },
+        {
+          payload: {
+            age: 25,
+          },
+        },
+      ),
+    ).toEqual(25);
+
+    expect(
+      await sourceResolver.resolve(
+        {
+          source: "payload.age",
+        },
+        {
+          payload: {
+            age: 25,
+          },
+        },
+      ),
+    ).toEqual(25);
+  });
+
+  it("should resolve attributes", async () => {
+    // all attributes
+    expect(await sourceResolver.resolve("attributes")).toEqual({
+      attribute1: "attribute1 value",
+      attribute2: 200,
+      attribute3: {
+        name: "attribute3 value",
+      },
+    });
+
+    // direct source
+    expect(await sourceResolver.resolve("attributes.attribute1")).toEqual("attribute1 value");
+    expect(await sourceResolver.resolve("attributes.attribute2")).toEqual(200);
+    expect(await sourceResolver.resolve("attributes.attribute3")).toEqual({
+      name: "attribute3 value",
+    });
+    expect(await sourceResolver.resolve("attributes.attribute3.name")).toEqual("attribute3 value");
+    expect(await sourceResolver.resolve("attributes.attribute4")).toEqual(null);
+
+    // attribute
+    expect(await sourceResolver.resolve({ attribute: "attribute1" })).toEqual("attribute1 value");
+    expect(await sourceResolver.resolve({ attribute: "attribute2" })).toEqual(200);
+    expect(await sourceResolver.resolve({ attribute: "attribute3" })).toEqual({
+      name: "attribute3 value",
+    });
+    expect(await sourceResolver.resolve({ attribute: "attribute3.name" })).toEqual(
+      "attribute3 value",
+    );
+    expect(await sourceResolver.resolve({ attribute: "attribute4" })).toEqual(null);
+  });
+
+  it("should resolve effect", async () => {
+    // all effects
+    expect(await sourceResolver.resolve("effects")).toEqual({
+      effect1: {
+        nested: {
+          value: "effect1 value",
+        },
+      },
+      effect2: 123,
+    });
+
+    // direct source
+    expect(await sourceResolver.resolve("effects.effect1")).toEqual({
+      nested: {
+        value: "effect1 value",
+      },
+    });
+    expect(await sourceResolver.resolve("effects.effect2")).toEqual(123);
+    // expect(await sourceResolver.resolve("effects.effect3")).toEqual(null);
+
+    // effect
+    expect(await sourceResolver.resolve({ effect: "effect1" })).toEqual({
+      nested: {
+        value: "effect1 value",
+      },
+    });
+    expect(await sourceResolver.resolve({ effect: "effect2" })).toEqual(123);
+    // expect(await sourceResolver.resolve({ effect: "effect3" })).toEqual(null);
+  });
+
+  it("should resolve state when inside an effect", async () => {
+    expect(
+      await sourceResolver.resolve(
+        { state: "counter" },
+        {
+          state: {
+            counter: 10,
+          },
+        },
+      ),
+    ).toEqual(10);
+  });
+
+  it("should resolve lookup", async () => {
+    expect(await sourceResolver.resolve({ lookup: "module1" })).toEqual("module1 lookup value");
+    expect(await sourceResolver.resolve({ lookup: "module1.key" })).toEqual(
+      "module1 lookup value: key",
+    );
+    expect(await sourceResolver.resolve({ lookup: "module1.key.subkey" })).toEqual(
+      "module1 lookup value: key.subkey",
+    );
+  });
+});

package/src/sourceResolver.ts

@@ -0,0 +1,213 @@
+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;
+
+const SOURCE_PATH_SEPARATOR = ".";
+
+export interface SourceResolverOptions {
+  logger: Logger;
+  modulesManager: ModulesManager;
+  attributesManager: AttributesManager;
+  effectsManager: EffectsManager;
+}
+
+export interface SourcePath {
+  name: string;
+  path: string[]; // dot-separated path after the name
+  fullKey: string;
+}
+
+export type SourceOrigin = SourcePath & {
+  originType: "attribute" | "attributes" | "effect" | "payload" | "lookup" | string;
+};
+
+function findValueAtPath(obj: any, path: string[]): any {
+  return path.reduce((acc, part) => acc[part], obj);
+}
+
+// @TODO: redo it with a better approach
+export class SourceResolver {
+  private logger: Logger;
+
+  private modulesManager: ModulesManager;
+  private attributesManager: AttributesManager;
+  private effectsManager: EffectsManager;
+
+  constructor(options: SourceResolverOptions) {
+    const { logger, modulesManager, attributesManager, effectsManager } = options;
+
+    this.logger = logger;
+    this.modulesManager = modulesManager;
+    this.attributesManager = attributesManager;
+    this.effectsManager = effectsManager;
+  }
+
+  getPath(p: string): SourcePath {
+    const parts = p.split(SOURCE_PATH_SEPARATOR);
+
+    return {
+      name: parts[0],
+      path: parts.slice(1),
+      fullKey: p,
+    };
+  }
+
+  getOrigin(source: Source | Partial<SourceBase>): SourceOrigin | SourceOrigin[] | null {
+    if (typeof source === "string") {
+      const parts = source.split(SOURCE_PATH_SEPARATOR);
+      const originType = parts[0] as SourceOrigin["originType"];
+
+      // @TODO: validate type as one of known types
+
+      return {
+        originType,
+        name: parts[1],
+        path: parts.slice(2),
+        fullKey: source,
+      };
+    }
+
+    // @TODO: fix it better
+    if ("source" in source) {
+      return this.getOrigin(source.source as string);
+    }
+
+    if ("source" in source) {
+      return this.getOrigin(source.source as string);
+    }
+
+    if ("attribute" in source) {
+      return {
+        originType: "attribute",
+        ...this.getPath(source.attribute as string), // @TODO: consider array of strings here
+      };
+    }
+
+    if ("effect" in source) {
+      return {
+        originType: "effect",
+        ...this.getPath(source.effect as string),
+      };
+    }
+
+    if ("payload" in source) {
+      if (Array.isArray(source.payload)) {
+        return source.payload.map((p) => ({
+          originType: "payload",
+          ...this.getPath(p as string),
+        }));
+      } else {
+        return {
+          originType: "payload",
+          ...this.getPath(source.payload as string),
+        };
+      }
+    }
+
+    if ("lookup" in source) {
+      return {
+        originType: "lookup",
+        ...this.getPath(source.lookup as string),
+      };
+    }
+
+    if ("state" in source) {
+      return {
+        originType: "state",
+        ...this.getPath(source.state as string),
+      };
+    }
+
+    return null;
+  }
+
+  async resolveByOrigin(origin: SourceOrigin | null, inputs: Inputs = {}): Promise<Value> {
+    if (origin === null) {
+      return null;
+    }
+
+    if (origin.originType === "attributes") {
+      const result = origin.name
+        ? this.attributesManager.getAttributeValue(origin.name)
+        : this.attributesManager.getAttributesMap();
+
+      if (origin.path.length > 0) {
+        return findValueAtPath(result, origin.path);
+      }
+
+      return result;
+    }
+
+    if (origin.originType === "attribute") {
+      const result = this.attributesManager.getAttributeValue(origin.name);
+
+      if (origin.path.length > 0) {
+        return findValueAtPath(result, origin.path);
+      }
+
+      return result;
+    }
+
+    if (origin.originType === "effects") {
+      const result = origin.name
+        ? this.effectsManager.getStateValue(origin.name)
+        : this.effectsManager.getAllStates();
+
+      if (origin.path.length > 0) {
+        return findValueAtPath(result, origin.path);
+      }
+
+      return result;
+    }
+
+    if (origin.originType === "effect") {
+      const result = this.effectsManager.getStateValue(origin.name);
+
+      if (origin.path.length > 0) {
+        return findValueAtPath(result, origin.path);
+      }
+
+      return result;
+    }
+
+    if (origin.originType === "lookup") {
+      return this.modulesManager.lookup(origin.fullKey);
+    }
+
+    // if (origin.originType === "payload" && inputs.payload) {
+    //   return findValueAtPath(inputs.payload, [...origin.path, ...[origin.name]]); // @TODO: make it better
+    // }
+
+    // if (origin.originType === "attributes" && inputs.attributes) {
+    //   const p = [...origin.path, ...[origin.name]].filter(Boolean);
+    //   return findValueAtPath(inputs["attributes"], p); // @TODO: make it better
+    // }
+
+    // handle any other input that is not known early
+    if (typeof inputs[origin.originType] !== "undefined") {
+      return findValueAtPath(
+        inputs[origin.originType],
+        [...[origin.name, ...origin.path]].filter(Boolean),
+      ); // @TODO: make it better
+    }
+
+    return null;
+  }
+
+  async resolve(source: Source | Partial<SourceBase>, inputs: Inputs = {}): Promise<Value> {
+    const origin = this.getOrigin(source);
+
+    if (Array.isArray(origin)) {
+      return Promise.all(origin.map((o) => this.resolveByOrigin(o, inputs)));
+    }
+
+    const result = await this.resolveByOrigin(origin, inputs);
+
+    return result;
+  }
+}