@eventvisor/sdk 0.0.2

package/src/transformer.ts

@@ -0,0 +1,316 @@
+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 class Transformer {
+  private logger: Logger;
+  private conditionsChecker: ConditionsChecker;
+  private sourceResolver: SourceResolver;
+
+  constructor(options: TransformerOptions) {
+    this.logger = options.logger;
+    this.conditionsChecker = options.conditionsChecker;
+    this.sourceResolver = options.sourceResolver;
+  }
+
+  async applyAll(value: Value, transforms: Transform[], inputs: Inputs = {}): Promise<Value> {
+    let result = value;
+
+    for (const transform of transforms) {
+      /**
+       * Conditions
+       */
+      if (transform.conditions) {
+        const conditionMatched = await this.conditionsChecker.allAreMatched(
+          transform.conditions,
+          inputs,
+        );
+
+        if (!conditionMatched) {
+          continue;
+        }
+      }
+
+      /**
+       * Source value
+       */
+      let sourceValue = await this.sourceResolver.resolve(transform, inputs);
+
+      // when Transform has no source, but only target
+      if (sourceValue === null || sourceValue === undefined) {
+        if (transform.target) {
+          sourceValue = await this.sourceResolver.resolve(
+            {
+              payload: transform.target,
+            },
+            typeof inputs.payload === "undefined"
+              ? {
+                  ...inputs,
+                  payload: value,
+                }
+              : inputs,
+          );
+        }
+      }
+
+      /**
+       * Transform value
+       */
+      // plain target
+      if (transform.target) {
+        // @TODO: target is always single string. tidy it up
+        const targets = Array.isArray(transform.target) ? transform.target : [transform.target];
+
+        for (const target of targets) {
+          // @TODO: use if/elseif below later
+
+          // string only
+          if (typeof sourceValue === "string") {
+            if (transform.type === "trim") {
+              result = Transformer.setValueAtPath(result, target, sourceValue.trim());
+            }
+          }
+
+          // array only
+          if (Array.isArray(sourceValue)) {
+            if (transform.type === "concat") {
+              const separator = transform.separator || " ";
+              result = Transformer.setValueAtPath(result, target, sourceValue.join(separator));
+            }
+          }
+
+          // others
+          if (transform.type === "set") {
+            if ("value" in transform) {
+              result = Transformer.setValueAtPath(result, target, transform.value);
+            } else {
+              result = Transformer.setValueAtPath(result, target, sourceValue);
+            }
+          }
+
+          if (transform.type === "remove") {
+            result = Transformer.removeValueAt(result, target);
+          }
+
+          // to other types
+          if (transform.type === "toInteger") {
+            result = Transformer.setValueAtPath(result, target, parseInt(String(sourceValue)));
+          } else if (transform.type === "toDouble") {
+            result = Transformer.setValueAtPath(result, target, parseFloat(String(sourceValue)));
+          } else if (transform.type === "toString") {
+            result = Transformer.setValueAtPath(result, target, String(sourceValue) || "");
+          } else if (transform.type === "toBoolean") {
+            const lowerCasedValue = String(sourceValue).toLowerCase();
+
+            result = Transformer.setValueAtPath(
+              result,
+              target,
+              ["true", "1", "checked", "yes", "on", "y"].indexOf(lowerCasedValue) !== -1 ||
+                sourceValue === true,
+            );
+          }
+        }
+      } else {
+        // without target (meaning, self)
+
+        // set
+        if (transform.type === "set") {
+          if ("value" in transform) {
+            result = transform.value;
+          }
+        }
+      }
+
+      if (transform.type === "spread") {
+        if (transform.target) {
+          const currentTargetValue = Transformer.getValueAtPath(result, transform.target);
+          result = Transformer.setValueAtPath(result, transform.target, {
+            ...((currentTargetValue as object) || {}),
+            ...((sourceValue as object) || {}),
+          });
+        } else {
+          result = {
+            ...((result as object) || {}),
+            ...((sourceValue as object) || {}),
+          };
+        }
+      }
+
+      // mathematical
+      if (transform.type === "increment") {
+        const by = typeof transform.value === "number" ? transform.value : 1;
+
+        if (transform.target) {
+          result = Transformer.setValueAtPath(result, transform.target, Number(sourceValue) + by);
+        } else {
+          result = (result as number) + by;
+        }
+      } else if (transform.type === "decrement") {
+        const by = typeof transform.value === "number" ? transform.value : 1;
+
+        if (transform.target) {
+          result = Transformer.setValueAtPath(result, transform.target, Number(sourceValue) - by);
+        } else {
+          result = (result as number) - by;
+        }
+      }
+
+      // target map
+      if (transform.targetMap) {
+        const targetMaps: Record<string, string>[] = [];
+
+        // @TODO: tidy it up
+        if (Array.isArray(transform.targetMap)) {
+          for (const targetMap of transform.targetMap) {
+            Object.entries(targetMap).forEach(([key, value]) => {
+              targetMaps.push({ [key]: value });
+            });
+          }
+        } else {
+          Object.entries(transform.targetMap).forEach(([key, value]) => {
+            targetMaps.push({ [key]: value });
+          });
+        }
+
+        for (const targetMap of targetMaps) {
+          // rename
+          if (transform.type === "rename") {
+            result = Transformer.renameValueAt(result, targetMap as Record<string, string>);
+          }
+        }
+      }
+    }
+
+    return result;
+  }
+
+  // Helper function to rename value at path
+  public static renameValueAt(obj: any, target: Record<string, string>): any {
+    if (!obj || typeof obj !== "object") return obj;
+    if (!target || typeof target !== "object") return obj;
+
+    const entries = Object.entries(target);
+    if (entries.length === 0) return obj;
+
+    const [oldKey, newKey] = entries[0];
+    if (!oldKey || !newKey) return obj;
+
+    // Get the value at old path
+    const oldValue = Transformer.getValueAtPath(obj, oldKey);
+    if (oldValue === undefined) return obj;
+
+    // Create a copy to avoid mutating the original
+    const result = JSON.parse(JSON.stringify(obj));
+
+    // Remove old property
+    const oldKeys = oldKey.split(".");
+    let current = result;
+
+    // Navigate to parent of old property
+    for (let i = 0; i < oldKeys.length - 1; i++) {
+      const key = oldKeys[i];
+      if (current[key] === undefined) return result;
+      current = current[key];
+    }
+
+    // Remove old property
+    delete current[oldKeys[oldKeys.length - 1]];
+
+    // Set at new path
+    return Transformer.setValueAtPath(result, newKey, oldValue);
+  }
+
+  // Helper function to get value at path
+  public static getValueAtPath(obj: any, path: string): any {
+    if (!path || typeof path !== "string") return undefined;
+
+    const keys = path.split(".");
+    let current = obj;
+
+    for (const key of keys) {
+      if (current === null || current === undefined) return undefined;
+      if (typeof current === "object" && !Array.isArray(current)) {
+        current = (current as any)[key];
+      } else if (Array.isArray(current) && /^\d+$/.test(key)) {
+        current = current[parseInt(key)];
+      } else {
+        return undefined;
+      }
+    }
+
+    return current;
+  }
+
+  // Helper function to set value at path
+  public static setValueAtPath(obj: any, path: string, value: any): any {
+    if (!path || typeof path !== "string") return obj;
+    if (obj === null || obj === undefined) return obj;
+
+    // Create a copy to avoid mutating the original
+    const result = JSON.parse(JSON.stringify(obj));
+    const keys = path.split(".");
+    let current = result as any;
+
+    // Navigate to the parent of the target path
+    for (let i = 0; i < keys.length - 1; i++) {
+      const key = keys[i];
+      if (current[key] === undefined) {
+        // Create nested object or array as needed
+        if (/^\d+$/.test(keys[i + 1])) {
+          current[key] = [];
+        } else {
+          current[key] = {};
+        }
+      }
+      current = current[key];
+    }
+
+    // Set the final value
+    const finalKey = keys[keys.length - 1];
+    current[finalKey] = value;
+
+    return result;
+  }
+
+  // Helper function to remove value at path
+  public static removeValueAt(obj: any, path: string): any {
+    if (!path || typeof path !== "string") return obj;
+    if (obj === null || obj === undefined) return obj;
+
+    // Create a copy to avoid mutating the original
+    const result = JSON.parse(JSON.stringify(obj));
+    const keys = path.split(".");
+    let current = result as any;
+
+    // Navigate to the parent of the target path
+    for (let i = 0; i < keys.length - 1; i++) {
+      const key = keys[i];
+      if (current[key] === undefined) {
+        return result; // Path doesn't exist, nothing to remove
+      }
+      current = current[key];
+    }
+
+    // Remove the property
+    const finalKey = keys[keys.length - 1];
+    if (Array.isArray(current)) {
+      if (/^\d+$/.test(finalKey)) {
+        current.splice(parseInt(finalKey), 1);
+      }
+    } else if (typeof current === "object" && current !== null) {
+      delete current[finalKey];
+    }
+
+    return result;
+  }
+}

package/src/transformer_static.spec.ts

@@ -0,0 +1,377 @@
+import { Transformer } from "./transformer";
+
+describe("Transformer static methods", () => {
+  describe("getValueAtPath", () => {
+    const testObj = {
+      user: {
+        profile: {
+          name: "John Doe",
+          email: "john@example.com",
+          settings: {
+            theme: "dark",
+            notifications: true,
+          },
+        },
+        preferences: ["reading", "music"],
+      },
+      config: {
+        version: "1.0.0",
+        features: ["auth", "api"],
+      },
+    };
+
+    it("should get value at simple path", () => {
+      const result = Transformer.getValueAtPath(testObj, "user.profile.name");
+      expect(result).toBe("John Doe");
+    });
+
+    it("should get value at nested path", () => {
+      const result = Transformer.getValueAtPath(testObj, "user.profile.settings.theme");
+      expect(result).toBe("dark");
+    });
+
+    it("should get value at root level", () => {
+      const result = Transformer.getValueAtPath(testObj, "config");
+      expect(result).toEqual({
+        version: "1.0.0",
+        features: ["auth", "api"],
+      });
+    });
+
+    it("should get array value", () => {
+      const result = Transformer.getValueAtPath(testObj, "user.preferences");
+      expect(result).toEqual(["reading", "music"]);
+    });
+
+    it("should get array element by index", () => {
+      const result = Transformer.getValueAtPath(testObj, "user.preferences.0");
+      expect(result).toBe("reading");
+    });
+
+    it("should get array element by numeric string", () => {
+      const result = Transformer.getValueAtPath(testObj, "user.preferences.1");
+      expect(result).toBe("music");
+    });
+
+    it("should return undefined for non-existent path", () => {
+      const result = Transformer.getValueAtPath(testObj, "user.profile.age");
+      expect(result).toBeUndefined();
+    });
+
+    it("should return undefined for invalid path", () => {
+      const result = Transformer.getValueAtPath(testObj, "");
+      expect(result).toBeUndefined();
+    });
+
+    it("should return undefined for null path", () => {
+      const result = Transformer.getValueAtPath(testObj, null as any);
+      expect(result).toBeUndefined();
+    });
+
+    it("should return undefined for non-string path", () => {
+      const result = Transformer.getValueAtPath(testObj, 123 as any);
+      expect(result).toBeUndefined();
+    });
+
+    it("should return undefined for non-existent array index", () => {
+      const result = Transformer.getValueAtPath(testObj, "user.preferences.5");
+      expect(result).toBeUndefined();
+    });
+
+    it("should return undefined for invalid array index", () => {
+      const result = Transformer.getValueAtPath(testObj, "user.preferences.abc");
+      expect(result).toBeUndefined();
+    });
+
+    it("should handle null object", () => {
+      const result = Transformer.getValueAtPath(null, "user.profile.name");
+      expect(result).toBeUndefined();
+    });
+
+    it("should handle undefined object", () => {
+      const result = Transformer.getValueAtPath(undefined, "user.profile.name");
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe("setValueAtPath", () => {
+    let testObj: any;
+
+    beforeEach(() => {
+      testObj = {
+        user: {
+          profile: {
+            name: "John Doe",
+            email: "john@example.com",
+          },
+          preferences: ["reading", "music"],
+        },
+        config: {
+          version: "1.0.0",
+        },
+      };
+    });
+
+    it("should set value at simple path", () => {
+      const result = Transformer.setValueAtPath(testObj, "user.profile.age", 30);
+      expect(result.user.profile.age).toBe(30);
+    });
+
+    it("should set value at nested path", () => {
+      const result = Transformer.setValueAtPath(testObj, "user.profile.settings.theme", "light");
+      expect(result.user.profile.settings.theme).toBe("light");
+    });
+
+    it("should set value at root level", () => {
+      const result = Transformer.setValueAtPath(testObj, "appName", "MyApp");
+      expect(result.appName).toBe("MyApp");
+    });
+
+    it("should set array element by index", () => {
+      const result = Transformer.setValueAtPath(testObj, "user.preferences.0", "gaming");
+      expect(result.user.preferences[0]).toBe("gaming");
+    });
+
+    it("should create nested objects when they don't exist", () => {
+      const result = Transformer.setValueAtPath(testObj, "user.profile.address.city", "New York");
+      expect(result.user.profile.address.city).toBe("New York");
+    });
+
+    it("should create arrays when numeric keys are expected", () => {
+      const result = Transformer.setValueAtPath(testObj, "user.scores.0", 100);
+      expect(Array.isArray(result.user.scores)).toBe(true);
+      expect(result.user.scores[0]).toBe(100);
+    });
+
+    it("should handle empty path", () => {
+      const result = Transformer.setValueAtPath(testObj, "", "value");
+      expect(result).toBe(testObj);
+    });
+
+    it("should handle null path", () => {
+      const result = Transformer.setValueAtPath(testObj, null as any, "value");
+      expect(result).toBe(testObj);
+    });
+
+    it("should handle non-string path", () => {
+      const result = Transformer.setValueAtPath(testObj, 123 as any, "value");
+      expect(result).toBe(testObj);
+    });
+
+    it("should handle null object", () => {
+      const result = Transformer.setValueAtPath(null, "user.profile.name", "Jane");
+      expect(result).toBe(null);
+    });
+
+    it("should handle undefined object", () => {
+      const result = Transformer.setValueAtPath(undefined, "user.profile.name", "Jane");
+      expect(result).toBe(undefined);
+    });
+
+    it("should not mutate original object", () => {
+      const original = JSON.parse(JSON.stringify(testObj));
+      Transformer.setValueAtPath(testObj, "user.profile.age", 30);
+      expect(testObj).toEqual(original);
+    });
+  });
+
+  describe("removeValueAt", () => {
+    let testObj: any;
+
+    beforeEach(() => {
+      testObj = {
+        user: {
+          profile: {
+            name: "John Doe",
+            email: "john@example.com",
+            settings: {
+              theme: "dark",
+              notifications: true,
+            },
+          },
+          preferences: ["reading", "music", "gaming"],
+        },
+        config: {
+          version: "1.0.0",
+        },
+      };
+    });
+
+    it("should remove value at simple path", () => {
+      const result = Transformer.removeValueAt(testObj, "user.profile.email");
+      expect(result.user.profile.email).toBeUndefined();
+      expect(result.user.profile.name).toBe("John Doe"); // Other properties should remain
+    });
+
+    it("should remove value at nested path", () => {
+      const result = Transformer.removeValueAt(testObj, "user.profile.settings.theme");
+      expect(result.user.profile.settings.theme).toBeUndefined();
+      expect(result.user.profile.settings.notifications).toBe(true); // Other properties should remain
+    });
+
+    it("should remove value at root level", () => {
+      const result = Transformer.removeValueAt(testObj, "config");
+      expect(result.config).toBeUndefined();
+      expect(result.user).toBeDefined(); // Other properties should remain
+    });
+
+    it("should remove array element by index", () => {
+      const result = Transformer.removeValueAt(testObj, "user.preferences.1");
+      expect(result.user.preferences).toEqual(["reading", "gaming"]);
+      expect(result.user.preferences.length).toBe(2);
+    });
+
+    it("should handle non-existent path gracefully", () => {
+      const result = Transformer.removeValueAt(testObj, "user.profile.age");
+      expect(result).toEqual(testObj); // Should return original object unchanged
+    });
+
+    it("should handle empty path", () => {
+      const result = Transformer.removeValueAt(testObj, "");
+      expect(result).toEqual(testObj);
+    });
+
+    it("should handle null path", () => {
+      const result = Transformer.removeValueAt(testObj, null as any);
+      expect(result).toEqual(testObj);
+    });
+
+    it("should handle non-string path", () => {
+      const result = Transformer.removeValueAt(testObj, 123 as any);
+      expect(result).toEqual(testObj);
+    });
+
+    it("should handle null object", () => {
+      const result = Transformer.removeValueAt(null, "user.profile.name");
+      expect(result).toBe(null);
+    });
+
+    it("should handle undefined object", () => {
+      const result = Transformer.removeValueAt(undefined, "user.profile.name");
+      expect(result).toBe(undefined);
+    });
+
+    it("should not mutate original object", () => {
+      const original = JSON.parse(JSON.stringify(testObj));
+      Transformer.removeValueAt(testObj, "user.profile.email");
+      expect(testObj).toEqual(original);
+    });
+  });
+
+  describe("renameValueAt", () => {
+    let testObj: any;
+
+    beforeEach(() => {
+      testObj = {
+        user: {
+          profile: {
+            name: "John Doe",
+            email: "john@example.com",
+            settings: {
+              theme: "dark",
+              notifications: true,
+            },
+          },
+          preferences: ["reading", "music"],
+        },
+        config: {
+          version: "1.0.0",
+        },
+      };
+    });
+
+    it("should rename single property", () => {
+      const result = Transformer.renameValueAt(
+        {
+          name: "John Doe",
+        },
+        { name: "fullName" },
+      );
+      expect(result.fullName).toBe("John Doe");
+      expect(result.name).toBeUndefined();
+    });
+
+    it("should rename simple property", () => {
+      const result = Transformer.renameValueAt(testObj, {
+        "user.profile.name": "user.profile.fullName",
+      });
+      expect(result.user.profile.fullName).toBe("John Doe");
+      expect(result.user.profile.name).toBeUndefined();
+    });
+
+    it("should rename nested property", () => {
+      const result = Transformer.renameValueAt(testObj, {
+        "user.profile.email": "user.profile.userEmail",
+      });
+      expect(result.user.profile.userEmail).toBe("john@example.com");
+      expect(result.user.profile.email).toBeUndefined();
+    });
+
+    it("should rename to nested path", () => {
+      const result = Transformer.renameValueAt(testObj, {
+        "user.profile.name": "user.profile.fullName",
+      });
+      expect(result.user.profile.fullName).toBe("John Doe");
+      expect(result.user.profile.name).toBeUndefined();
+    });
+
+    it("should rename root property", () => {
+      const result = Transformer.renameValueAt(testObj, { config: "configuration" });
+      expect(result.configuration.version).toBe("1.0.0");
+      expect(result.config).toBeUndefined();
+    });
+
+    it("should handle non-existent source path gracefully", () => {
+      const result = Transformer.renameValueAt(testObj, { "user.profile.age": "userAge" });
+      expect(result).toEqual(testObj); // Should return original object unchanged
+    });
+
+    it("should handle empty target object", () => {
+      const result = Transformer.renameValueAt(testObj, {});
+      expect(result).toEqual(testObj);
+    });
+
+    it("should handle null target object", () => {
+      const result = Transformer.renameValueAt(testObj, null as any);
+      expect(result).toEqual(testObj);
+    });
+
+    it("should handle null object", () => {
+      const result = Transformer.renameValueAt(null, { name: "fullName" });
+      expect(result).toBe(null);
+    });
+
+    it("should handle undefined object", () => {
+      const result = Transformer.renameValueAt(undefined, { name: "fullName" });
+      expect(result).toBe(undefined);
+    });
+
+    it("should handle non-object", () => {
+      const result = Transformer.renameValueAt("string", { name: "fullName" });
+      expect(result).toBe("string");
+    });
+
+    it("should not mutate original object", () => {
+      const original = JSON.parse(JSON.stringify(testObj));
+      Transformer.renameValueAt(testObj, { "user.profile.name": "user.profile.fullName" });
+      expect(testObj).toEqual(original);
+    });
+
+    it("should handle complex nested rename", () => {
+      const result = Transformer.renameValueAt(testObj, {
+        "user.profile.settings.theme": "user.profile.settings.colorScheme",
+      });
+      expect(result.user.profile.settings.colorScheme).toBe("dark");
+      expect(result.user.profile.settings.theme).toBeUndefined();
+    });
+
+    it("should handle rename with array path", () => {
+      const result = Transformer.renameValueAt(testObj, {
+        "user.preferences.0": "user.preferences.1",
+      });
+      expect(result.user.preferences[1]).toBe("reading");
+      expect(result.user.preferences.length).toBe(2); // Array length extends to accommodate index 1
+      // Note: Array manipulation during rename can be complex due to splice operations
+    });
+  });
+});