@featurevisor/sdk 1.35.3 → 2.0.0

package/src/events.spec.ts

@@ -0,0 +1,154 @@
+import { DatafileReader } from "./datafileReader";
+import { createLogger } from "./logger";
+
+import { getParamsForDatafileSetEvent, getParamsForStickySetEvent } from "./events";
+
+describe("sdk: events", function () {
+  describe("getParamsForStickySetEvent", function () {
+    it("should get params for sticky set event: empty to new", function () {
+      const previousStickyFeatures = {};
+      const newStickyFeatures = {
+        feature2: { enabled: true },
+        feature3: { enabled: true },
+      };
+      const replace = true;
+
+      const result = getParamsForStickySetEvent(previousStickyFeatures, newStickyFeatures, replace);
+
+      expect(result).toEqual({
+        features: ["feature2", "feature3"],
+        replaced: replace,
+      });
+    });
+
+    it("should get params for sticky set event: add, change, remove", function () {
+      const previousStickyFeatures = {
+        feature1: { enabled: true },
+        feature2: { enabled: true },
+      };
+      const newStickyFeatures = {
+        feature2: { enabled: true },
+        feature3: { enabled: true },
+      };
+      const replace = true;
+
+      const result = getParamsForStickySetEvent(previousStickyFeatures, newStickyFeatures, replace);
+
+      expect(result).toEqual({
+        features: ["feature1", "feature2", "feature3"],
+        replaced: replace,
+      });
+    });
+  });
+
+  describe("getParamsForDatafileSetEvent", function () {
+    const logger = createLogger({
+      level: "error",
+    });
+
+    it("should get params for datafile set event: empty to new", function () {
+      const previousDatafileReader = new DatafileReader({
+        datafile: {
+          schemaVersion: "1.0.0",
+          revision: "1",
+          features: {},
+          segments: {},
+        },
+        logger,
+      });
+      const newDatafileReader = new DatafileReader({
+        datafile: {
+          schemaVersion: "1.0.0",
+          revision: "2",
+          features: {
+            feature1: { bucketBy: "userId", hash: "hash1", traffic: [] },
+            feature2: { bucketBy: "userId", hash: "hash2", traffic: [] },
+          },
+          segments: {},
+        },
+        logger,
+      });
+
+      const result = getParamsForDatafileSetEvent(previousDatafileReader, newDatafileReader);
+
+      expect(result).toEqual({
+        revision: "2",
+        previousRevision: "1",
+        revisionChanged: true,
+        features: ["feature1", "feature2"],
+      });
+    });
+
+    it("should get params for datafile set event: change hash, addition", function () {
+      const previousDatafileReader = new DatafileReader({
+        datafile: {
+          schemaVersion: "1.0.0",
+          revision: "1",
+          features: {
+            feature1: { bucketBy: "userId", hash: "hash-same", traffic: [] },
+            feature2: { bucketBy: "userId", hash: "hash1-2", traffic: [] },
+          },
+          segments: {},
+        },
+        logger,
+      });
+      const newDatafileReader = new DatafileReader({
+        datafile: {
+          schemaVersion: "1.0.0",
+          revision: "2",
+          features: {
+            feature1: { bucketBy: "userId", hash: "hash-same", traffic: [] },
+            feature2: { bucketBy: "userId", hash: "hash2-2", traffic: [] },
+            feature3: { bucketBy: "userId", hash: "hash2-3", traffic: [] },
+          },
+          segments: {},
+        },
+        logger,
+      });
+
+      const result = getParamsForDatafileSetEvent(previousDatafileReader, newDatafileReader);
+
+      expect(result).toEqual({
+        revision: "2",
+        previousRevision: "1",
+        revisionChanged: true,
+        features: ["feature2", "feature3"],
+      });
+    });
+
+    it("should get params for datafile set event: change hash, removal", function () {
+      const previousDatafileReader = new DatafileReader({
+        datafile: {
+          schemaVersion: "1.0.0",
+          revision: "1",
+          features: {
+            feature1: { bucketBy: "userId", hash: "hash-same", traffic: [] },
+            feature2: { bucketBy: "userId", hash: "hash1-2", traffic: [] },
+          },
+          segments: {},
+        },
+        logger,
+      });
+      const newDatafileReader = new DatafileReader({
+        datafile: {
+          schemaVersion: "1.0.0",
+          revision: "2",
+          features: {
+            feature2: { bucketBy: "userId", hash: "hash2-2", traffic: [] },
+          },
+          segments: {},
+        },
+        logger,
+      });
+
+      const result = getParamsForDatafileSetEvent(previousDatafileReader, newDatafileReader);
+
+      expect(result).toEqual({
+        revision: "2",
+        previousRevision: "1",
+        revisionChanged: true,
+        features: ["feature1", "feature2"],
+      });
+    });
+  });
+});

package/src/events.ts

@@ -0,0 +1,83 @@
+import type { StickyFeatures, FeatureKey } from "@featurevisor/types";
+
+import type { EventDetails } from "./emitter";
+import type { DatafileReader } from "./datafileReader";
+
+export function getParamsForStickySetEvent(
+  previousStickyFeatures: StickyFeatures = {},
+  newStickyFeatures: StickyFeatures = {},
+  replace,
+): EventDetails {
+  const keysBefore = Object.keys(previousStickyFeatures);
+  const keysAfter = Object.keys(newStickyFeatures);
+
+  const allKeys = [...keysBefore, ...keysAfter];
+  const uniqueFeaturesAffected = allKeys.filter(
+    (element, index) => allKeys.indexOf(element) === index,
+  );
+
+  return {
+    features: uniqueFeaturesAffected,
+    replaced: replace,
+  };
+}
+
+export function getParamsForDatafileSetEvent(
+  previousDatafileReader: DatafileReader,
+  newDatafileReader: DatafileReader,
+): EventDetails {
+  const previousRevision = previousDatafileReader.getRevision();
+  const previousFeatureKeys = previousDatafileReader.getFeatureKeys();
+
+  const newRevision = newDatafileReader.getRevision();
+  const newFeatureKeys = newDatafileReader.getFeatureKeys();
+
+  // results
+  const removedFeatures: FeatureKey[] = [];
+  const changedFeatures: FeatureKey[] = [];
+  const addedFeatures: FeatureKey[] = [];
+
+  // checking against existing datafile
+  for (const previousFeatureKey of previousFeatureKeys) {
+    if (newFeatureKeys.indexOf(previousFeatureKey) === -1) {
+      // feature was removed in new datafile
+      removedFeatures.push(previousFeatureKey);
+
+      continue;
+    }
+
+    // feature exists in both datafiles, check if it was changed
+    const previousFeature = previousDatafileReader.getFeature(previousFeatureKey);
+    const newFeature = newDatafileReader.getFeature(previousFeatureKey);
+
+    if (previousFeature?.hash !== newFeature?.hash) {
+      // feature was changed in new datafile
+      changedFeatures.push(previousFeatureKey);
+    }
+  }
+
+  // checking against new datafile
+  for (const newFeatureKey of newFeatureKeys) {
+    if (previousFeatureKeys.indexOf(newFeatureKey) === -1) {
+      // feature was added in new datafile
+      addedFeatures.push(newFeatureKey);
+    }
+  }
+
+  // combine all affected feature keys
+  const allAffectedFeatures: FeatureKey[] = [
+    ...removedFeatures,
+    ...changedFeatures,
+    ...addedFeatures,
+  ].filter((element, index, array) => array.indexOf(element) === index);
+
+  const details = {
+    revision: newRevision,
+    previousRevision,
+    revisionChanged: previousRevision !== newRevision,
+
+    features: allAffectedFeatures,
+  };
+
+  return details;
+}

package/src/helpers.ts

@@ -0,0 +1,33 @@
+import type { VariableType, VariableValue } from "@featurevisor/types";
+
+type FieldType = string | VariableType;
+type ValueType = VariableValue;
+
+export function getValueByType(value: ValueType, fieldType: FieldType): ValueType {
+  try {
+    if (value === undefined) {
+      return null;
+    }
+
+    switch (fieldType) {
+      case "string":
+        return typeof value === "string" ? value : null;
+      case "integer":
+        return parseInt(value as string, 10);
+      case "double":
+        return parseFloat(value as string);
+      case "boolean":
+        return value === true;
+      case "array":
+        return Array.isArray(value) ? value : null;
+      case "object":
+        return typeof value === "object" ? value : null;
+      // @NOTE: `json` is not handled here intentionally
+      default:
+        return value;
+    }
+    // eslint-disable-next-line
+  } catch (e) {
+    return null;
+  }
+}

package/src/hooks.ts

@@ -0,0 +1,88 @@
+import type { BucketBy, BucketKey, BucketValue, Context, FeatureKey } from "@featurevisor/types";
+
+import type { EvaluateOptions, Evaluation } from "./evaluate";
+import type { Logger } from "./logger";
+
+/**
+ * bucketKey
+ */
+export interface ConfigureBucketKeyOptions {
+  featureKey: FeatureKey;
+  context: Context;
+  bucketBy: BucketBy;
+  bucketKey: string; // the initial bucket key, which can be modified by hooks
+}
+
+export type ConfigureBucketKey = (options: ConfigureBucketKeyOptions) => BucketKey;
+
+/**
+ * bucketValue
+ */
+export interface ConfigureBucketValueOptions {
+  featureKey: FeatureKey;
+  bucketKey: string;
+  context: Context;
+  bucketValue: number; // the initial bucket value, which can be modified by hooks
+}
+
+export type ConfigureBucketValue = (options: ConfigureBucketValueOptions) => BucketValue;
+
+/**
+ * Hooks
+ */
+export interface Hook {
+  name: string;
+
+  before?: (options: EvaluateOptions) => EvaluateOptions;
+
+  bucketKey?: ConfigureBucketKey;
+
+  bucketValue?: ConfigureBucketValue;
+
+  after?: (evaluation: Evaluation, options: EvaluateOptions) => Evaluation;
+}
+
+export interface HooksManagerOptions {
+  hooks?: Hook[];
+  logger: Logger;
+}
+
+export class HooksManager {
+  private hooks: Hook[] = [];
+  private logger: Logger;
+
+  constructor(options: HooksManagerOptions) {
+    this.logger = options.logger;
+
+    if (options.hooks) {
+      options.hooks.forEach((hook) => {
+        this.add(hook);
+      });
+    }
+  }
+
+  add(hook: Hook): (() => void) | undefined {
+    if (this.hooks.some((existingHook) => existingHook.name === hook.name)) {
+      this.logger.error(`Hook with name "${hook.name}" already exists.`, {
+        name: hook.name,
+        hook: hook,
+      });
+
+      return;
+    }
+
+    this.hooks.push(hook);
+
+    return () => {
+      this.remove(hook.name);
+    };
+  }
+
+  remove(name: string): void {
+    this.hooks = this.hooks.filter((hook) => hook.name !== name);
+  }
+
+  getAll(): Hook[] {
+    return this.hooks;
+  }
+}

package/src/index.ts

@@ -1,6 +1,7 @@
-export * from "./bucket";
+export * from "./bucketer";
 export * from "./instance";
 export * from "./logger";
 export * from "./conditions";
-export * from "./emitter";
 export * from "./evaluate";
+export * from "./datafileReader";
+export * from "./child";