@featurevisor/sdk 1.35.3 → 2.0.1

package/src/instance.ts

@@ -1,359 +1,228 @@
-import {
+import type {
   Context,
-  DatafileContent,
   Feature,
   FeatureKey,
-  InitialFeatures,
   StickyFeatures,
-  VariableType,
+  EvaluatedFeatures,
+  EvaluatedFeature,
   VariableValue,
   VariationValue,
   VariableKey,
+  DatafileContent,
 } from "@featurevisor/types";
 
 import { createLogger, Logger, LogLevel } from "./logger";
+import { HooksManager, Hook } from "./hooks";
+import { Emitter, EventCallback, EventName } from "./emitter";
 import { DatafileReader } from "./datafileReader";
-import { Emitter } from "./emitter";
-import { ConfigureBucketKey, ConfigureBucketValue } from "./bucket";
-import { Evaluation, evaluate } from "./evaluate";
-
-export type ReadyCallback = () => void;
-
-export type ActivationCallback = (
-  featureName: string,
-  variation: VariationValue,
-  context: Context,
-  captureContext: Context,
-) => void;
-
-export interface Statuses {
-  ready: boolean;
-  refreshInProgress: boolean;
-}
-
-const DEFAULT_BUCKET_KEY_SEPARATOR = ".";
-
-export type InterceptContext = (context: Context) => Context;
-
-export interface InstanceOptions {
-  bucketKeySeparator?: string;
-  configureBucketKey?: ConfigureBucketKey;
-  configureBucketValue?: ConfigureBucketValue;
-  datafile?: DatafileContent | string;
-  datafileUrl?: string;
-  handleDatafileFetch?: (datafileUrl: string) => Promise<DatafileContent>;
-  initialFeatures?: InitialFeatures;
-  interceptContext?: InterceptContext;
-  logger?: Logger;
-  onActivation?: ActivationCallback;
-  onReady?: ReadyCallback;
-  onRefresh?: () => void;
-  onUpdate?: () => void;
-  refreshInterval?: number; // seconds
-  stickyFeatures?: StickyFeatures;
-}
+import { Evaluation, EvaluateDependencies, evaluateWithHooks } from "./evaluate";
+import { FeaturevisorChildInstance } from "./child";
+import { getParamsForStickySetEvent, getParamsForDatafileSetEvent } from "./events";
+import { getValueByType } from "./helpers";
 
 const emptyDatafile: DatafileContent = {
-  schemaVersion: "1",
+  schemaVersion: "2",
   revision: "unknown",
-  attributes: [],
-  segments: [],
-  features: [],
+  segments: {},
+  features: {},
 };
 
-export type DatafileFetchHandler = (datafileUrl: string) => Promise<DatafileContent>;
-
-function fetchDatafileContent(
-  datafileUrl,
-  handleDatafileFetch?: DatafileFetchHandler,
-): Promise<DatafileContent> {
-  if (handleDatafileFetch) {
-    return handleDatafileFetch(datafileUrl);
-  }
+export interface OverrideOptions {
+  sticky?: StickyFeatures;
 
-  return fetch(datafileUrl).then((res) => res.json());
+  defaultVariationValue?: VariationValue;
+  defaultVariableValue?: VariableValue;
 }
 
-type FieldType = string | VariableType;
-type ValueType = VariableValue;
-
-export function getValueByType(value: ValueType, fieldType: FieldType): ValueType {
-  try {
-    if (value === undefined) {
-      return undefined;
-    }
-
-    switch (fieldType) {
-      case "string":
-        return typeof value === "string" ? value : undefined;
-      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 : undefined;
-      case "object":
-        return typeof value === "object" ? value : undefined;
-      // @NOTE: `json` is not handled here intentionally
-      default:
-        return value;
-    }
-  } catch (e) {
-    return undefined;
-  }
+export interface InstanceOptions {
+  datafile?: DatafileContent | string;
+  context?: Context;
+  logLevel?: LogLevel;
+  logger?: Logger;
+  sticky?: StickyFeatures;
+  hooks?: Hook[];
 }
 
 export class FeaturevisorInstance {
   // from options
-  private bucketKeySeparator: string;
-  private configureBucketKey?: ConfigureBucketKey;
-  private configureBucketValue?: ConfigureBucketValue;
-  private datafileUrl?: string;
-  private handleDatafileFetch?: DatafileFetchHandler;
-  private initialFeatures?: InitialFeatures;
-  private interceptContext?: InterceptContext;
+  private context: Context = {};
   private logger: Logger;
-  private refreshInterval?: number; // seconds
-  private stickyFeatures?: StickyFeatures;
+  private sticky?: StickyFeatures;
 
   // internally created
   private datafileReader: DatafileReader;
+  private hooksManager: HooksManager;
   private emitter: Emitter;
-  private statuses: Statuses;
-  private intervalId?: ReturnType<typeof setInterval>;
-
-  // exposed from emitter
-  public on: Emitter["addListener"];
-  public addListener: Emitter["addListener"];
-  public off: Emitter["removeListener"];
-  public removeListener: Emitter["removeListener"];
-  public removeAllListeners: Emitter["removeAllListeners"];
 
   constructor(options: InstanceOptions) {
     // from options
-    this.bucketKeySeparator = options.bucketKeySeparator || DEFAULT_BUCKET_KEY_SEPARATOR;
-    this.configureBucketKey = options.configureBucketKey;
-    this.configureBucketValue = options.configureBucketValue;
-    this.datafileUrl = options.datafileUrl;
-    this.handleDatafileFetch = options.handleDatafileFetch;
-    this.initialFeatures = options.initialFeatures;
-    this.interceptContext = options.interceptContext;
-    this.logger = options.logger || createLogger();
-    this.refreshInterval = options.refreshInterval;
-    this.stickyFeatures = options.stickyFeatures;
-
-    // internal
+    this.context = options.context || {};
+    this.logger =
+      options.logger ||
+      createLogger({
+        level: options.logLevel || Logger.defaultLevel,
+      });
+    this.hooksManager = new HooksManager({
+      hooks: options.hooks || [],
+      logger: this.logger,
+    });
     this.emitter = new Emitter();
-    this.statuses = {
-      ready: false,
-      refreshInProgress: false,
-    };
-
-    // register events
-    if (options.onReady) {
-      this.emitter.addListener("ready", options.onReady);
-    }
+    this.sticky = options.sticky;
 
-    if (options.onRefresh) {
-      this.emitter.addListener("refresh", options.onRefresh);
-    }
-
-    if (options.onUpdate) {
-      this.emitter.addListener("update", options.onUpdate);
-    }
-
-    if (options.onActivation) {
-      this.emitter.addListener("activation", options.onActivation);
+    // datafile
+    this.datafileReader = new DatafileReader({
+      datafile: emptyDatafile,
+      logger: this.logger,
+    });
+    if (options.datafile) {
+      this.datafileReader = new DatafileReader({
+        datafile:
+          typeof options.datafile === "string" ? JSON.parse(options.datafile) : options.datafile,
+        logger: this.logger,
+      });
     }
 
-    // expose emitter methods
-    const on = this.emitter.addListener.bind(this.emitter);
-    this.on = on;
-    this.addListener = on;
-
-    const off = this.emitter.removeListener.bind(this.emitter);
-    this.off = off;
-    this.removeListener = off;
+    this.logger.info("Featurevisor SDK initialized");
+  }
 
-    this.removeAllListeners = this.emitter.removeAllListeners.bind(this.emitter);
+  setLogLevel(level: LogLevel) {
+    this.logger.setLevel(level);
+  }
 
-    // datafile
-    if (options.datafileUrl) {
-      this.setDatafile(options.datafile || emptyDatafile);
+  setDatafile(datafile: DatafileContent | string) {
+    try {
+      const newDatafileReader = new DatafileReader({
+        datafile: typeof datafile === "string" ? JSON.parse(datafile) : datafile,
+        logger: this.logger,
+      });
 
-      fetchDatafileContent(options.datafileUrl, options.handleDatafileFetch)
-        .then((datafile) => {
-          this.setDatafile(datafile);
+      const details = getParamsForDatafileSetEvent(this.datafileReader, newDatafileReader);
 
-          this.statuses.ready = true;
-          this.emitter.emit("ready");
+      this.datafileReader = newDatafileReader;
 
-          if (this.refreshInterval) {
-            this.startRefreshing();
-          }
-        })
-        .catch((e) => {
-          this.logger.error("failed to fetch datafile", { error: e });
-        });
-    } else if (options.datafile) {
-      this.setDatafile(options.datafile);
-      this.statuses.ready = true;
-
-      setTimeout(() => {
-        this.emitter.emit("ready");
-      }, 0);
-    } else {
-      throw new Error(
-        "Featurevisor SDK instance cannot be created without both `datafile` and `datafileUrl` options",
-      );
+      this.logger.info("datafile set", details);
+      this.emitter.trigger("datafile_set", details);
+    } catch (e) {
+      this.logger.error("could not parse datafile", { error: e });
     }
   }
 
-  setLogLevels(levels: LogLevel[]) {
-    this.logger.setLevels(levels);
-  }
-
-  onReady(): Promise<FeaturevisorInstance> {
-    return new Promise((resolve) => {
-      if (this.statuses.ready) {
-        return resolve(this);
-      }
-
-      const cb = () => {
-        this.emitter.removeListener("ready", cb);
+  setSticky(sticky: StickyFeatures, replace = false) {
+    const previousStickyFeatures = this.sticky || {};
 
-        resolve(this);
+    if (replace) {
+      this.sticky = { ...sticky };
+    } else {
+      this.sticky = {
+        ...this.sticky,
+        ...sticky,
       };
+    }
 
-      this.emitter.addListener("ready", cb);
-    });
+    const params = getParamsForStickySetEvent(previousStickyFeatures, this.sticky, replace);
+
+    this.logger.info("sticky features set", params);
+    this.emitter.trigger("sticky_set", params);
   }
 
-  setDatafile(datafile: DatafileContent | string) {
-    try {
-      this.datafileReader = new DatafileReader(
-        typeof datafile === "string" ? JSON.parse(datafile) : datafile,
-      );
-    } catch (e) {
-      this.logger.error("could not parse datafile", { error: e });
-    }
+  getRevision(): string {
+    return this.datafileReader.getRevision();
   }
 
-  setStickyFeatures(stickyFeatures: StickyFeatures | undefined) {
-    this.stickyFeatures = stickyFeatures;
+  getFeature(featureKey: string): Feature | undefined {
+    return this.datafileReader.getFeature(featureKey);
   }
 
-  getRevision(): string {
-    return this.datafileReader.getRevision();
+  addHook(hook: Hook) {
+    return this.hooksManager.add(hook);
   }
 
-  getFeature(featureKey: string | Feature): Feature | undefined {
-    return typeof featureKey === "string"
-      ? this.datafileReader.getFeature(featureKey) // only key provided
-      : featureKey; // full feature provided
+  on(eventName: EventName, callback: EventCallback) {
+    return this.emitter.on(eventName, callback);
   }
 
-  /**
-   * Statuses
-   */
-  isReady(): boolean {
-    return this.statuses.ready;
+  close() {
+    this.emitter.clearAll();
   }
 
   /**
-   * Refresh
+   * Context
    */
-  refresh() {
-    this.logger.debug("refreshing datafile");
-
-    if (this.statuses.refreshInProgress) {
-      return this.logger.warn("refresh in progress, skipping");
-    }
-
-    if (!this.datafileUrl) {
-      return this.logger.error("cannot refresh since `datafileUrl` is not provided");
+  setContext(context: Context, replace = false) {
+    if (replace) {
+      this.context = context;
+    } else {
+      this.context = { ...this.context, ...context };
     }
 
-    this.statuses.refreshInProgress = true;
-
-    fetchDatafileContent(this.datafileUrl, this.handleDatafileFetch)
-      .then((datafile) => {
-        const currentRevision = this.getRevision();
-        const newRevision = datafile.revision;
-        const isNotSameRevision = currentRevision !== newRevision;
-
-        this.setDatafile(datafile);
-        this.logger.info("refreshed datafile");
-
-        this.emitter.emit("refresh");
-
-        if (isNotSameRevision) {
-          this.emitter.emit("update");
-        }
-
-        this.statuses.refreshInProgress = false;
-      })
-      .catch((e) => {
-        this.logger.error("failed to refresh datafile", { error: e });
-        this.statuses.refreshInProgress = false;
-      });
+    this.emitter.trigger("context_set", {
+      context: this.context,
+      replaced: replace,
+    });
+    this.logger.debug(replace ? "context replaced" : "context updated", {
+      context: this.context,
+      replaced: replace,
+    });
   }
 
-  startRefreshing() {
-    if (!this.datafileUrl) {
-      return this.logger.error("cannot start refreshing since `datafileUrl` is not provided");
-    }
-
-    if (this.intervalId) {
-      return this.logger.warn("refreshing has already started");
-    }
-
-    if (!this.refreshInterval) {
-      return this.logger.warn("no `refreshInterval` option provided");
-    }
-
-    this.intervalId = setInterval(() => {
-      this.refresh();
-    }, this.refreshInterval * 1000);
+  getContext(context?: Context): Context {
+    return context
+      ? {
+          ...this.context,
+          ...context,
+        }
+      : this.context;
   }
 
-  stopRefreshing() {
-    if (!this.intervalId) {
-      return this.logger.warn("refreshing has not started yet");
-    }
-
-    clearInterval(this.intervalId);
+  spawn(context: Context = {}, options: OverrideOptions = {}): FeaturevisorChildInstance {
+    return new FeaturevisorChildInstance({
+      parent: this,
+      context: this.getContext(context),
+      sticky: options.sticky,
+    });
   }
 
   /**
    * Flag
    */
-  evaluateFlag(featureKey: FeatureKey | Feature, context: Context = {}): Evaluation {
-    return evaluate({
-      type: "flag",
-
-      featureKey,
-      context,
+  private getEvaluationDependencies(
+    context: Context,
+    options: OverrideOptions = {},
+  ): EvaluateDependencies {
+    return {
+      context: this.getContext(context),
 
       logger: this.logger,
+      hooksManager: this.hooksManager,
       datafileReader: this.datafileReader,
-      statuses: this.statuses,
-      interceptContext: this.interceptContext,
 
-      stickyFeatures: this.stickyFeatures,
-      initialFeatures: this.initialFeatures,
+      // OverrideOptions
+      sticky: options.sticky
+        ? {
+            ...this.sticky,
+            ...options.sticky,
+          }
+        : this.sticky,
+      defaultVariationValue: options.defaultVariationValue,
+      defaultVariableValue: options.defaultVariableValue,
+    };
+  }
 
-      bucketKeySeparator: this.bucketKeySeparator,
-      configureBucketKey: this.configureBucketKey,
-      configureBucketValue: this.configureBucketValue,
+  evaluateFlag(
+    featureKey: FeatureKey,
+    context: Context = {},
+    options: OverrideOptions = {},
+  ): Evaluation {
+    return evaluateWithHooks({
+      ...this.getEvaluationDependencies(context, options),
+      type: "flag",
+      featureKey,
     });
   }
 
-  isEnabled(featureKey: FeatureKey | Feature, context: Context = {}): boolean {
+  isEnabled(featureKey: FeatureKey, context: Context = {}, options: OverrideOptions = {}): boolean {
     try {
-      const evaluation = this.evaluateFlag(featureKey, context);
+      const evaluation = this.evaluateFlag(featureKey, context, options);
 
       return evaluation.enabled === true;
     } catch (e) {
@@ -366,33 +235,25 @@ export class FeaturevisorInstance {
   /**
    * Variation
    */
-  evaluateVariation(featureKey: FeatureKey | Feature, context: Context = {}): Evaluation {
-    return evaluate({
+  evaluateVariation(
+    featureKey: FeatureKey,
+    context: Context = {},
+    options: OverrideOptions = {},
+  ): Evaluation {
+    return evaluateWithHooks({
+      ...this.getEvaluationDependencies(context, options),
       type: "variation",
-
       featureKey,
-      context,
-
-      logger: this.logger,
-      datafileReader: this.datafileReader,
-      statuses: this.statuses,
-      interceptContext: this.interceptContext,
-
-      stickyFeatures: this.stickyFeatures,
-      initialFeatures: this.initialFeatures,
-
-      bucketKeySeparator: this.bucketKeySeparator,
-      configureBucketKey: this.configureBucketKey,
-      configureBucketValue: this.configureBucketValue,
     });
   }
 
   getVariation(
-    featureKey: FeatureKey | Feature,
+    featureKey: FeatureKey,
     context: Context = {},
-  ): VariationValue | undefined {
+    options: OverrideOptions = {},
+  ): VariationValue | null {
     try {
-      const evaluation = this.evaluateVariation(featureKey, context);
+      const evaluation = this.evaluateVariation(featureKey, context, options);
 
       if (typeof evaluation.variationValue !== "undefined") {
         return evaluation.variationValue;
@@ -402,56 +263,11 @@ export class FeaturevisorInstance {
         return evaluation.variation.value;
       }
 
-      return undefined;
+      return null;
     } catch (e) {
       this.logger.error("getVariation", { featureKey, error: e });
 
-      return undefined;
-    }
-  }
-
-  /**
-   * Activate
-   */
-  activate(featureKey: FeatureKey, context: Context = {}): VariationValue | undefined {
-    try {
-      const evaluation = this.evaluateVariation(featureKey, context);
-      const variationValue = evaluation.variation
-        ? evaluation.variation.value
-        : evaluation.variationValue;
-
-      if (typeof variationValue === "undefined") {
-        return undefined;
-      }
-
-      const finalContext = this.interceptContext ? this.interceptContext(context) : context;
-
-      const captureContext: Context = {};
-
-      const attributesForCapturing = this.datafileReader
-        .getAllAttributes()
-        .filter((a) => a.capture === true);
-
-      attributesForCapturing.forEach((a) => {
-        if (typeof finalContext[a.key] !== "undefined") {
-          captureContext[a.key] = context[a.key];
-        }
-      });
-
-      this.emitter.emit(
-        "activation",
-        featureKey,
-        variationValue,
-        finalContext,
-        captureContext,
-        evaluation,
-      );
-
-      return variationValue;
-    } catch (e) {
-      this.logger.error("activate", { featureKey, error: e });
-
-      return undefined;
+      return null;
     }
   }
 
@@ -459,38 +275,27 @@ export class FeaturevisorInstance {
    * Variable
    */
   evaluateVariable(
-    featureKey: FeatureKey | Feature,
+    featureKey: FeatureKey,
     variableKey: VariableKey,
     context: Context = {},
+    options: OverrideOptions = {},
   ): Evaluation {
-    return evaluate({
+    return evaluateWithHooks({
+      ...this.getEvaluationDependencies(context, options),
       type: "variable",
-
       featureKey,
       variableKey,
-      context,
-
-      logger: this.logger,
-      datafileReader: this.datafileReader,
-      statuses: this.statuses,
-      interceptContext: this.interceptContext,
-
-      stickyFeatures: this.stickyFeatures,
-      initialFeatures: this.initialFeatures,
-
-      bucketKeySeparator: this.bucketKeySeparator,
-      configureBucketKey: this.configureBucketKey,
-      configureBucketValue: this.configureBucketValue,
     });
   }
 
   getVariable(
-    featureKey: FeatureKey | Feature,
+    featureKey: FeatureKey,
     variableKey: string,
     context: Context = {},
-  ): VariableValue | undefined {
+    options: OverrideOptions = {},
+  ): VariableValue | null {
     try {
-      const evaluation = this.evaluateVariable(featureKey, variableKey, context);
+      const evaluation = this.evaluateVariable(featureKey, variableKey, context, options);
 
       if (typeof evaluation.variableValue !== "undefined") {
         if (
@@ -504,82 +309,133 @@ export class FeaturevisorInstance {
         return evaluation.variableValue;
       }
 
-      return undefined;
+      return null;
     } catch (e) {
       this.logger.error("getVariable", { featureKey, variableKey, error: e });
 
-      return undefined;
+      return null;
     }
   }
 
   getVariableBoolean(
-    featureKey: FeatureKey | Feature,
+    featureKey: FeatureKey,
     variableKey: string,
     context: Context = {},
-  ): boolean | undefined {
-    const variableValue = this.getVariable(featureKey, variableKey, context);
+    options: OverrideOptions = {},
+  ): boolean | null {
+    const variableValue = this.getVariable(featureKey, variableKey, context, options);
 
-    return getValueByType(variableValue, "boolean") as boolean | undefined;
+    return getValueByType(variableValue, "boolean") as boolean | null;
   }
 
   getVariableString(
-    featureKey: FeatureKey | Feature,
+    featureKey: FeatureKey,
     variableKey: string,
     context: Context = {},
-  ): string | undefined {
-    const variableValue = this.getVariable(featureKey, variableKey, context);
+    options: OverrideOptions = {},
+  ): string | null {
+    const variableValue = this.getVariable(featureKey, variableKey, context, options);
 
-    return getValueByType(variableValue, "string") as string | undefined;
+    return getValueByType(variableValue, "string") as string | null;
   }
 
   getVariableInteger(
-    featureKey: FeatureKey | Feature,
+    featureKey: FeatureKey,
     variableKey: string,
     context: Context = {},
-  ): number | undefined {
-    const variableValue = this.getVariable(featureKey, variableKey, context);
+    options: OverrideOptions = {},
+  ): number | null {
+    const variableValue = this.getVariable(featureKey, variableKey, context, options);
 
-    return getValueByType(variableValue, "integer") as number | undefined;
+    return getValueByType(variableValue, "integer") as number | null;
   }
 
   getVariableDouble(
-    featureKey: FeatureKey | Feature,
+    featureKey: FeatureKey,
     variableKey: string,
     context: Context = {},
-  ): number | undefined {
-    const variableValue = this.getVariable(featureKey, variableKey, context);
+    options: OverrideOptions = {},
+  ): number | null {
+    const variableValue = this.getVariable(featureKey, variableKey, context, options);
 
-    return getValueByType(variableValue, "double") as number | undefined;
+    return getValueByType(variableValue, "double") as number | null;
   }
 
   getVariableArray(
-    featureKey: FeatureKey | Feature,
+    featureKey: FeatureKey,
     variableKey: string,
     context: Context = {},
-  ): string[] | undefined {
-    const variableValue = this.getVariable(featureKey, variableKey, context);
+    options: OverrideOptions = {},
+  ): string[] | null {
+    const variableValue = this.getVariable(featureKey, variableKey, context, options);
 
-    return getValueByType(variableValue, "array") as string[] | undefined;
+    return getValueByType(variableValue, "array") as string[] | null;
   }
 
   getVariableObject<T>(
-    featureKey: FeatureKey | Feature,
+    featureKey: FeatureKey,
     variableKey: string,
     context: Context = {},
-  ): T | undefined {
-    const variableValue = this.getVariable(featureKey, variableKey, context);
+    options: OverrideOptions = {},
+  ): T | null {
+    const variableValue = this.getVariable(featureKey, variableKey, context, options);
 
-    return getValueByType(variableValue, "object") as T | undefined;
+    return getValueByType(variableValue, "object") as T | null;
   }
 
   getVariableJSON<T>(
-    featureKey: FeatureKey | Feature,
+    featureKey: FeatureKey,
     variableKey: string,
     context: Context = {},
-  ): T | undefined {
-    const variableValue = this.getVariable(featureKey, variableKey, context);
+    options: OverrideOptions = {},
+  ): T | null {
+    const variableValue = this.getVariable(featureKey, variableKey, context, options);
+
+    return getValueByType(variableValue, "json") as T | null;
+  }
+
+  getAllEvaluations(
+    context: Context = {},
+    featureKeys: string[] = [],
+    options: OverrideOptions = {},
+  ): EvaluatedFeatures {
+    const result: EvaluatedFeatures = {};
+
+    const keys = featureKeys.length > 0 ? featureKeys : this.datafileReader.getFeatureKeys();
+    for (const featureKey of keys) {
+      // isEnabled
+      const evaluatedFeature: EvaluatedFeature = {
+        enabled: this.isEnabled(featureKey, context, options),
+      };
+
+      // variation
+      if (this.datafileReader.hasVariations(featureKey)) {
+        const variation = this.getVariation(featureKey, context, options);
+
+        if (variation) {
+          evaluatedFeature.variation = variation;
+        }
+      }
+
+      // variables
+      const variableKeys = this.datafileReader.getVariableKeys(featureKey);
+      if (variableKeys.length > 0) {
+        evaluatedFeature.variables = {};
+
+        for (const variableKey of variableKeys) {
+          evaluatedFeature.variables[variableKey] = this.getVariable(
+            featureKey,
+            variableKey,
+            context,
+            options,
+          );
+        }
+      }
+
+      result[featureKey] = evaluatedFeature;
+    }
 
-    return getValueByType(variableValue, "json") as T | undefined;
+    return result;
   }
 }