@openfeature/server-sdk 1.18.0 → 1.20.0

package/dist/cjs/index.js

@@ -58,15 +58,24 @@ var __async = (__this, __arguments, generator) => {
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AggregateError: () => AggregateError,
   AsyncLocalStorageTransactionContextPropagator: () => AsyncLocalStorageTransactionContextPropagator,
+  BaseEvaluationStrategy: () => BaseEvaluationStrategy,
+  ComparisonStrategy: () => ComparisonStrategy,
+  ErrorWithCode: () => ErrorWithCode,
+  FirstMatchStrategy: () => FirstMatchStrategy,
+  FirstSuccessfulStrategy: () => FirstSuccessfulStrategy,
   InMemoryProvider: () => InMemoryProvider,
+  MultiProvider: () => MultiProvider,
   NOOP_PROVIDER: () => NOOP_PROVIDER,
   NOOP_TRANSACTION_CONTEXT_PROPAGATOR: () => NOOP_TRANSACTION_CONTEXT_PROPAGATOR,
   OpenFeature: () => OpenFeature,
   OpenFeatureAPI: () => OpenFeatureAPI,
   OpenFeatureEventEmitter: () => OpenFeatureEventEmitter,
   ProviderEvents: () => import_core6.ServerProviderEvents,
-  ProviderStatus: () => import_core.ServerProviderStatus
+  ProviderStatus: () => import_core.ServerProviderStatus,
+  constructAggregateError: () => constructAggregateError,
+  throwAggregateErrorFromPromiseResults: () => throwAggregateErrorFromPromiseResults
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -194,11 +203,555 @@ var InMemoryProvider = class {
   }
 };
 
-// src/open-feature.ts
+// src/provider/multi-provider/multi-provider.ts
+var import_core9 = require("@openfeature/core");
+
+// src/events/open-feature-event-emitter.ts
+var import_core4 = require("@openfeature/core");
+var import_node_events = require("node:events");
+var OpenFeatureEventEmitter = class extends import_core4.GenericEventEmitter {
+  constructor() {
+    super();
+    this.eventEmitter = new import_node_events.EventEmitter({ captureRejections: true });
+    this.eventEmitter.on("error", (err) => {
+      var _a;
+      (_a = this._logger) == null ? void 0 : _a.error("Error running event handler:", err);
+    });
+  }
+};
+
+// src/provider/multi-provider/errors.ts
+var import_core5 = require("@openfeature/core");
+var ErrorWithCode = class extends import_core5.OpenFeatureError {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+var AggregateError = class extends import_core5.GeneralError {
+  constructor(message, originalErrors) {
+    super(message);
+    this.originalErrors = originalErrors;
+  }
+};
+var constructAggregateError = (providerErrors) => {
+  const errorsWithSource = providerErrors.map(({ providerName, error }) => {
+    return { source: providerName, error };
+  }).flat();
+  return new AggregateError(
+    `Provider errors occurred: ${errorsWithSource[0].source}: ${errorsWithSource[0].error}`,
+    errorsWithSource
+  );
+};
+var throwAggregateErrorFromPromiseResults = (result, providerEntries) => {
+  const errors = result.map((r, i) => {
+    if (r.status === "rejected") {
+      return { error: r.reason, providerName: providerEntries[i].name };
+    }
+    return null;
+  }).filter((val) => Boolean(val));
+  if (errors.length) {
+    throw constructAggregateError(errors);
+  }
+};
+
+// src/provider/multi-provider/hook-executor.ts
+var HookExecutor = class {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  beforeHooks(hooks, hookContext, hints) {
+    return __async(this, null, function* () {
+      var _a;
+      for (const hook of hooks != null ? hooks : []) {
+        Object.freeze(hookContext);
+        Object.assign(hookContext.context, __spreadValues({}, yield (_a = hook == null ? void 0 : hook.before) == null ? void 0 : _a.call(hook, hookContext, Object.freeze(hints))));
+      }
+      return Object.freeze(hookContext.context);
+    });
+  }
+  afterHooks(hooks, hookContext, evaluationDetails, hints) {
+    return __async(this, null, function* () {
+      var _a;
+      for (const hook of hooks != null ? hooks : []) {
+        yield (_a = hook == null ? void 0 : hook.after) == null ? void 0 : _a.call(hook, hookContext, evaluationDetails, hints);
+      }
+    });
+  }
+  errorHooks(hooks, hookContext, err, hints) {
+    return __async(this, null, function* () {
+      var _a;
+      for (const hook of hooks != null ? hooks : []) {
+        try {
+          yield (_a = hook == null ? void 0 : hook.error) == null ? void 0 : _a.call(hook, hookContext, err, hints);
+        } catch (err2) {
+          this.logger.error(`Unhandled error during 'error' hook: ${err2}`);
+          if (err2 instanceof Error) {
+            this.logger.error(err2.stack);
+          }
+          this.logger.error(err2 == null ? void 0 : err2.stack);
+        }
+      }
+    });
+  }
+  finallyHooks(hooks, hookContext, evaluationDetails, hints) {
+    return __async(this, null, function* () {
+      var _a;
+      for (const hook of hooks != null ? hooks : []) {
+        try {
+          yield (_a = hook == null ? void 0 : hook.finally) == null ? void 0 : _a.call(hook, hookContext, evaluationDetails, hints);
+        } catch (err) {
+          this.logger.error(`Unhandled error during 'finally' hook: ${err}`);
+          if (err instanceof Error) {
+            this.logger.error(err.stack);
+          }
+          this.logger.error(err == null ? void 0 : err.stack);
+        }
+      }
+    });
+  }
+};
+
+// src/events/events.ts
+var import_core6 = require("@openfeature/core");
+
+// src/provider/multi-provider/status-tracker.ts
+var StatusTracker = class {
+  constructor(events) {
+    this.events = events;
+    this.providerStatuses = {};
+  }
+  wrapEventHandler(providerEntry) {
+    var _a, _b, _c, _d;
+    const provider = providerEntry.provider;
+    (_a = provider.events) == null ? void 0 : _a.addHandler(import_core6.ServerProviderEvents.Error, (details) => {
+      this.changeProviderStatus(providerEntry.name, import_core.ServerProviderStatus.ERROR, details);
+    });
+    (_b = provider.events) == null ? void 0 : _b.addHandler(import_core6.ServerProviderEvents.Stale, (details) => {
+      this.changeProviderStatus(providerEntry.name, import_core.ServerProviderStatus.STALE, details);
+    });
+    (_c = provider.events) == null ? void 0 : _c.addHandler(import_core6.ServerProviderEvents.ConfigurationChanged, (details) => {
+      this.events.emit(import_core6.ServerProviderEvents.ConfigurationChanged, details);
+    });
+    (_d = provider.events) == null ? void 0 : _d.addHandler(import_core6.ServerProviderEvents.Ready, (details) => {
+      this.changeProviderStatus(providerEntry.name, import_core.ServerProviderStatus.READY, details);
+    });
+  }
+  providerStatus(name) {
+    return this.providerStatuses[name];
+  }
+  getStatusFromProviderStatuses() {
+    const statuses = Object.values(this.providerStatuses);
+    if (statuses.includes(import_core.ServerProviderStatus.FATAL)) {
+      return import_core.ServerProviderStatus.FATAL;
+    } else if (statuses.includes(import_core.ServerProviderStatus.NOT_READY)) {
+      return import_core.ServerProviderStatus.NOT_READY;
+    } else if (statuses.includes(import_core.ServerProviderStatus.ERROR)) {
+      return import_core.ServerProviderStatus.ERROR;
+    } else if (statuses.includes(import_core.ServerProviderStatus.STALE)) {
+      return import_core.ServerProviderStatus.STALE;
+    }
+    return import_core.ServerProviderStatus.READY;
+  }
+  changeProviderStatus(name, status, details) {
+    const currentStatus = this.getStatusFromProviderStatuses();
+    this.providerStatuses[name] = status;
+    const newStatus = this.getStatusFromProviderStatuses();
+    if (currentStatus !== newStatus) {
+      if (newStatus === import_core.ServerProviderStatus.FATAL || newStatus === import_core.ServerProviderStatus.ERROR) {
+        this.events.emit(import_core6.ServerProviderEvents.Error, details);
+      } else if (newStatus === import_core.ServerProviderStatus.STALE) {
+        this.events.emit(import_core6.ServerProviderEvents.Stale, details);
+      } else if (newStatus === import_core.ServerProviderStatus.READY) {
+        this.events.emit(import_core6.ServerProviderEvents.Ready, details);
+      }
+    }
+  }
+};
+
+// src/provider/multi-provider/strategies/base-evaluation-strategy.ts
+var BaseEvaluationStrategy = class {
+  constructor() {
+    this.runMode = "sequential";
+  }
+  shouldEvaluateThisProvider(strategyContext, _evalContext) {
+    if (strategyContext.providerStatus === import_core.ServerProviderStatus.NOT_READY || strategyContext.providerStatus === import_core.ServerProviderStatus.FATAL) {
+      return false;
+    }
+    return true;
+  }
+  shouldEvaluateNextProvider(_strategyContext, _context, _result) {
+    return true;
+  }
+  shouldTrackWithThisProvider(strategyContext, _context, _trackingEventName, _trackingEventDetails) {
+    if (strategyContext.providerStatus === import_core.ServerProviderStatus.NOT_READY || strategyContext.providerStatus === import_core.ServerProviderStatus.FATAL) {
+      return false;
+    }
+    return true;
+  }
+  hasError(resolution) {
+    return "thrownError" in resolution || !!resolution.details.errorCode;
+  }
+  hasErrorWithCode(resolution, code) {
+    var _a;
+    return "thrownError" in resolution ? ((_a = resolution.thrownError) == null ? void 0 : _a.code) === code : resolution.details.errorCode === code;
+  }
+  collectProviderErrors(resolutions) {
+    var _a;
+    const errors = [];
+    for (const resolution of resolutions) {
+      if ("thrownError" in resolution) {
+        errors.push({ providerName: resolution.providerName, error: resolution.thrownError });
+      } else if (resolution.details.errorCode) {
+        errors.push({
+          providerName: resolution.providerName,
+          error: new ErrorWithCode(resolution.details.errorCode, (_a = resolution.details.errorMessage) != null ? _a : "unknown error")
+        });
+      }
+    }
+    return { errors };
+  }
+  resolutionToFinalResult(resolution) {
+    return { details: resolution.details, provider: resolution.provider, providerName: resolution.providerName };
+  }
+};
+
+// src/provider/multi-provider/strategies/first-match-strategy.ts
 var import_core7 = require("@openfeature/core");
+var FirstMatchStrategy = class extends BaseEvaluationStrategy {
+  shouldEvaluateNextProvider(strategyContext, context, result) {
+    if (this.hasErrorWithCode(result, import_core7.ErrorCode.FLAG_NOT_FOUND)) {
+      return true;
+    }
+    if (this.hasError(result)) {
+      return false;
+    }
+    return false;
+  }
+  determineFinalResult(strategyContext, context, resolutions) {
+    const finalResolution = resolutions[resolutions.length - 1];
+    if (this.hasError(finalResolution)) {
+      return this.collectProviderErrors(resolutions);
+    }
+    return this.resolutionToFinalResult(finalResolution);
+  }
+};
+
+// src/provider/multi-provider/strategies/first-successful-strategy.ts
+var FirstSuccessfulStrategy = class extends BaseEvaluationStrategy {
+  shouldEvaluateNextProvider(strategyContext, context, result) {
+    return this.hasError(result);
+  }
+  determineFinalResult(strategyContext, context, resolutions) {
+    const finalResolution = resolutions[resolutions.length - 1];
+    if (this.hasError(finalResolution)) {
+      return this.collectProviderErrors(resolutions);
+    }
+    return this.resolutionToFinalResult(finalResolution);
+  }
+};
+
+// src/provider/multi-provider/strategies/comparison-strategy.ts
+var import_core8 = require("@openfeature/core");
+var ComparisonStrategy = class extends BaseEvaluationStrategy {
+  constructor(fallbackProvider, onMismatch) {
+    super();
+    this.fallbackProvider = fallbackProvider;
+    this.onMismatch = onMismatch;
+    this.runMode = "parallel";
+  }
+  determineFinalResult(strategyContext, context, resolutions) {
+    var _a;
+    let value;
+    let fallbackResolution;
+    let finalResolution;
+    let mismatch = false;
+    for (const [i, resolution] of resolutions.entries()) {
+      if (this.hasError(resolution)) {
+        return this.collectProviderErrors(resolutions);
+      }
+      if (resolution.provider === this.fallbackProvider) {
+        fallbackResolution = resolution;
+      }
+      if (i === 0) {
+        finalResolution = resolution;
+      }
+      if (typeof value !== "undefined" && value !== resolution.details.value) {
+        mismatch = true;
+      } else {
+        value = resolution.details.value;
+      }
+    }
+    if (!fallbackResolution) {
+      throw new import_core8.GeneralError("Fallback provider not found in resolution results");
+    }
+    if (!finalResolution) {
+      throw new import_core8.GeneralError("Final resolution not found in resolution results");
+    }
+    if (mismatch) {
+      (_a = this.onMismatch) == null ? void 0 : _a.call(this, resolutions);
+      return {
+        details: fallbackResolution.details,
+        provider: fallbackResolution.provider
+      };
+    }
+    return this.resolutionToFinalResult(finalResolution);
+  }
+};
+
+// src/provider/multi-provider/multi-provider.ts
+var MultiProvider = class _MultiProvider {
+  constructor(constructorProviders, evaluationStrategy = new FirstMatchStrategy(), logger = new import_core9.DefaultLogger()) {
+    this.constructorProviders = constructorProviders;
+    this.evaluationStrategy = evaluationStrategy;
+    this.logger = logger;
+    this.runsOn = "server";
+    this.events = new OpenFeatureEventEmitter();
+    this.hookContexts = /* @__PURE__ */ new WeakMap();
+    this.hookHints = /* @__PURE__ */ new WeakMap();
+    this.providerEntries = [];
+    this.providerEntriesByName = {};
+    this.statusTracker = new StatusTracker(this.events);
+    this.hookExecutor = new HookExecutor(this.logger);
+    this.registerProviders(constructorProviders);
+    const aggregateMetadata = Object.keys(this.providerEntriesByName).reduce((acc, name) => {
+      return __spreadProps(__spreadValues({}, acc), { [name]: this.providerEntriesByName[name].provider.metadata });
+    }, {});
+    this.metadata = __spreadProps(__spreadValues({}, aggregateMetadata), {
+      name: _MultiProvider.name
+    });
+  }
+  registerProviders(constructorProviders) {
+    var _a, _b;
+    const providersByName = {};
+    for (const constructorProvider of constructorProviders) {
+      const providerName = constructorProvider.provider.metadata.name;
+      const candidateName = (_a = constructorProvider.name) != null ? _a : providerName;
+      if (constructorProvider.name && providersByName[constructorProvider.name]) {
+        throw new Error("Provider names must be unique");
+      }
+      (_b = providersByName[candidateName]) != null ? _b : providersByName[candidateName] = [];
+      providersByName[candidateName].push(constructorProvider.provider);
+    }
+    for (const name of Object.keys(providersByName)) {
+      const useIndexedNames = providersByName[name].length > 1;
+      for (let i = 0; i < providersByName[name].length; i++) {
+        const indexedName = useIndexedNames ? `${name}-${i + 1}` : name;
+        this.providerEntriesByName[indexedName] = { provider: providersByName[name][i], name: indexedName };
+        this.providerEntries.push(this.providerEntriesByName[indexedName]);
+        this.statusTracker.wrapEventHandler(this.providerEntriesByName[indexedName]);
+      }
+    }
+    Object.freeze(this.providerEntries);
+    Object.freeze(this.providerEntriesByName);
+  }
+  initialize(context) {
+    return __async(this, null, function* () {
+      const result = yield Promise.allSettled(
+        this.providerEntries.map((provider) => {
+          var _a, _b;
+          return (_b = (_a = provider.provider).initialize) == null ? void 0 : _b.call(_a, context);
+        })
+      );
+      throwAggregateErrorFromPromiseResults(result, this.providerEntries);
+    });
+  }
+  onClose() {
+    return __async(this, null, function* () {
+      const result = yield Promise.allSettled(this.providerEntries.map((provider) => {
+        var _a, _b;
+        return (_b = (_a = provider.provider).onClose) == null ? void 0 : _b.call(_a);
+      }));
+      throwAggregateErrorFromPromiseResults(result, this.providerEntries);
+    });
+  }
+  resolveBooleanEvaluation(flagKey, defaultValue, context) {
+    return this.flagResolutionProxy(flagKey, "boolean", defaultValue, context);
+  }
+  resolveStringEvaluation(flagKey, defaultValue, context) {
+    return this.flagResolutionProxy(flagKey, "string", defaultValue, context);
+  }
+  resolveNumberEvaluation(flagKey, defaultValue, context) {
+    return this.flagResolutionProxy(flagKey, "number", defaultValue, context);
+  }
+  resolveObjectEvaluation(flagKey, defaultValue, context) {
+    return this.flagResolutionProxy(flagKey, "object", defaultValue, context);
+  }
+  flagResolutionProxy(flagKey, flagType, defaultValue, context) {
+    return __async(this, null, function* () {
+      var _a;
+      const hookContext = this.hookContexts.get(context);
+      const hookHints = this.hookHints.get(context);
+      if (!hookContext || !hookHints) {
+        throw new import_core9.GeneralError("Hook context not available for evaluation");
+      }
+      const tasks = [];
+      for (const providerEntry of this.providerEntries) {
+        const task = this.evaluateProviderEntry(
+          flagKey,
+          flagType,
+          defaultValue,
+          providerEntry,
+          hookContext,
+          hookHints,
+          context
+        );
+        tasks.push(task);
+        if (this.evaluationStrategy.runMode === "sequential") {
+          const [shouldEvaluateNext] = yield task;
+          if (!shouldEvaluateNext) {
+            break;
+          }
+        }
+      }
+      const results = yield Promise.all(tasks);
+      const resolutions = results.map(([, resolution]) => resolution).filter((r) => Boolean(r));
+      const finalResult = this.evaluationStrategy.determineFinalResult({ flagKey, flagType }, context, resolutions);
+      if ((_a = finalResult.errors) == null ? void 0 : _a.length) {
+        throw constructAggregateError(finalResult.errors);
+      }
+      if (!finalResult.details) {
+        throw new import_core9.GeneralError("No result was returned from any provider");
+      }
+      return finalResult.details;
+    });
+  }
+  evaluateProviderEntry(flagKey, flagType, defaultValue, providerEntry, hookContext, hookHints, context) {
+    return __async(this, null, function* () {
+      let evaluationResult = void 0;
+      const provider = providerEntry.provider;
+      const strategyContext = {
+        flagKey,
+        flagType,
+        provider,
+        providerName: providerEntry.name,
+        providerStatus: this.statusTracker.providerStatus(providerEntry.name)
+      };
+      if (!this.evaluationStrategy.shouldEvaluateThisProvider(strategyContext, context)) {
+        return [true, null];
+      }
+      let resolution;
+      try {
+        evaluationResult = yield this.evaluateProviderAndHooks(flagKey, defaultValue, provider, hookContext, hookHints);
+        resolution = {
+          details: evaluationResult,
+          provider,
+          providerName: providerEntry.name
+        };
+      } catch (error) {
+        resolution = {
+          thrownError: error,
+          provider,
+          providerName: providerEntry.name
+        };
+      }
+      return [
+        this.evaluationStrategy.runMode === "sequential" ? this.evaluationStrategy.shouldEvaluateNextProvider(strategyContext, context, resolution) : true,
+        resolution
+      ];
+    });
+  }
+  evaluateProviderAndHooks(flagKey, defaultValue, provider, hookContext, hookHints) {
+    return __async(this, null, function* () {
+      var _a;
+      let providerContext = void 0;
+      let evaluationDetails;
+      const hookContextCopy = __spreadProps(__spreadValues({}, hookContext), { context: __spreadValues({}, hookContext.context) });
+      try {
+        providerContext = yield this.hookExecutor.beforeHooks(provider.hooks, hookContextCopy, hookHints);
+        const resolutionDetails = yield this.callProviderResolve(
+          provider,
+          flagKey,
+          defaultValue,
+          providerContext || {}
+        );
+        evaluationDetails = __spreadProps(__spreadValues({}, resolutionDetails), {
+          flagMetadata: Object.freeze((_a = resolutionDetails.flagMetadata) != null ? _a : {}),
+          flagKey
+        });
+        yield this.hookExecutor.afterHooks(provider.hooks, hookContextCopy, evaluationDetails, hookHints);
+      } catch (error) {
+        yield this.hookExecutor.errorHooks(provider.hooks, hookContextCopy, error, hookHints);
+        evaluationDetails = this.getErrorEvaluationDetails(flagKey, defaultValue, error);
+      }
+      yield this.hookExecutor.finallyHooks(provider.hooks, hookContextCopy, evaluationDetails, hookHints);
+      return evaluationDetails;
+    });
+  }
+  callProviderResolve(provider, flagKey, defaultValue, context) {
+    return __async(this, null, function* () {
+      switch (typeof defaultValue) {
+        case "string":
+          return yield provider.resolveStringEvaluation(flagKey, defaultValue, context, this.logger);
+        case "number":
+          return yield provider.resolveNumberEvaluation(flagKey, defaultValue, context, this.logger);
+        case "object":
+          return yield provider.resolveObjectEvaluation(flagKey, defaultValue, context, this.logger);
+        case "boolean":
+          return yield provider.resolveBooleanEvaluation(flagKey, defaultValue, context, this.logger);
+        default:
+          throw new import_core9.GeneralError("Invalid flag evaluation type");
+      }
+    });
+  }
+  get hooks() {
+    return [
+      {
+        before: (hookContext, hints) => __async(this, null, function* () {
+          this.hookContexts.set(hookContext.context, hookContext);
+          this.hookHints.set(hookContext.context, hints != null ? hints : {});
+          return hookContext.context;
+        })
+      }
+    ];
+  }
+  track(trackingEventName, context, trackingEventDetails) {
+    var _a, _b;
+    for (const providerEntry of this.providerEntries) {
+      if (!providerEntry.provider.track) {
+        continue;
+      }
+      const strategyContext = {
+        provider: providerEntry.provider,
+        providerName: providerEntry.name,
+        providerStatus: this.statusTracker.providerStatus(providerEntry.name)
+      };
+      if (this.evaluationStrategy.shouldTrackWithThisProvider(
+        strategyContext,
+        context,
+        trackingEventName,
+        trackingEventDetails
+      )) {
+        try {
+          (_b = (_a = providerEntry.provider).track) == null ? void 0 : _b.call(_a, trackingEventName, context, trackingEventDetails);
+        } catch (error) {
+          this.logger.error(
+            `Error tracking event "${trackingEventName}" with provider "${providerEntry.name}":`,
+            error
+          );
+        }
+      }
+    }
+  }
+  getErrorEvaluationDetails(flagKey, defaultValue, err, flagMetadata = {}) {
+    const errorMessage = err == null ? void 0 : err.message;
+    const errorCode = (err == null ? void 0 : err.code) || import_core9.ErrorCode.GENERAL;
+    return {
+      errorCode,
+      errorMessage,
+      value: defaultValue,
+      reason: import_core9.StandardResolutionReasons.ERROR,
+      flagMetadata: Object.freeze(flagMetadata),
+      flagKey
+    };
+  }
+};
+
+// src/open-feature.ts
+var import_core11 = require("@openfeature/core");
 
 // src/client/internal/open-feature-client.ts
-var import_core4 = require("@openfeature/core");
+var import_core10 = require("@openfeature/core");
 var OpenFeatureClient = class {
   constructor(providerAccessor, providerStatusAccessor, emitterAccessor, apiContextAccessor, apiHooksAccessor, transactionContextAccessor, globalLogger, options, context = {}) {
     this.providerAccessor = providerAccessor;
@@ -228,7 +781,7 @@ var OpenFeatureClient = class {
   addHandler(eventType, handler, options) {
     var _a;
     this.emitterAccessor().addHandler(eventType, handler);
-    const shouldRunNow = (0, import_core4.statusMatchesEvent)(eventType, this._providerStatus);
+    const shouldRunNow = (0, import_core10.statusMatchesEvent)(eventType, this._providerStatus);
     if (shouldRunNow) {
       try {
         handler({
@@ -253,7 +806,7 @@ var OpenFeatureClient = class {
     return this.emitterAccessor().getHandlers(eventType);
   }
   setLogger(logger) {
-    this._clientLogger = new import_core4.SafeLogger(logger);
+    this._clientLogger = new import_core10.SafeLogger(logger);
     return this;
   }
   setContext(context) {
@@ -354,18 +907,21 @@ var OpenFeatureClient = class {
       ];
       const allHooksReversed = [...allHooks].reverse();
       const mergedContext = this.mergeContexts(invocationContext);
-      const hookContext = {
-        flagKey,
-        defaultValue,
-        flagValueType: flagType,
-        clientMetadata: this.metadata,
-        providerMetadata: this._provider.metadata,
-        context: mergedContext,
-        logger: this._logger
-      };
+      const hookContexts = allHooksReversed.map(
+        () => Object.freeze({
+          flagKey,
+          defaultValue,
+          flagValueType: flagType,
+          clientMetadata: this.metadata,
+          providerMetadata: this._provider.metadata,
+          context: mergedContext,
+          logger: this._logger,
+          hookData: new import_core10.MapHookData()
+        })
+      );
       let evaluationDetails;
       try {
-        const frozenContext = yield this.beforeHooks(allHooks, hookContext, options);
+        const frozenContext = yield this.beforeHooks(allHooks, hookContexts, mergedContext, options);
         this.shortCircuitIfNotReady();
         const resolution = yield resolver.call(this._provider, flagKey, defaultValue, frozenContext, this._logger);
         const resolutionDetails = __spreadProps(__spreadValues({}, resolution), {
@@ -373,44 +929,55 @@ var OpenFeatureClient = class {
           flagKey
         });
         if (resolutionDetails.errorCode) {
-          const err = (0, import_core4.instantiateErrorByErrorCode)(resolutionDetails.errorCode, resolutionDetails.errorMessage);
-          yield this.errorHooks(allHooksReversed, hookContext, err, options);
+          const err = (0, import_core10.instantiateErrorByErrorCode)(resolutionDetails.errorCode, resolutionDetails.errorMessage);
+          yield this.errorHooks(allHooksReversed, hookContexts, err, options);
           evaluationDetails = this.getErrorEvaluationDetails(flagKey, defaultValue, err, resolutionDetails.flagMetadata);
         } else {
-          yield this.afterHooks(allHooksReversed, hookContext, resolutionDetails, options);
+          yield this.afterHooks(allHooksReversed, hookContexts, resolutionDetails, options);
           evaluationDetails = resolutionDetails;
         }
       } catch (err) {
-        yield this.errorHooks(allHooksReversed, hookContext, err, options);
+        yield this.errorHooks(allHooksReversed, hookContexts, err, options);
         evaluationDetails = this.getErrorEvaluationDetails(flagKey, defaultValue, err);
       }
-      yield this.finallyHooks(allHooksReversed, hookContext, evaluationDetails, options);
+      yield this.finallyHooks(allHooksReversed, hookContexts, evaluationDetails, options);
       return evaluationDetails;
     });
   }
-  beforeHooks(hooks, hookContext, options) {
+  beforeHooks(hooks, hookContexts, mergedContext, options) {
     return __async(this, null, function* () {
       var _a;
-      for (const hook of hooks) {
-        Object.freeze(hookContext);
-        Object.assign(hookContext.context, __spreadValues(__spreadValues({}, hookContext.context), yield (_a = hook == null ? void 0 : hook.before) == null ? void 0 : _a.call(hook, hookContext, Object.freeze(options.hookHints))));
+      let accumulatedContext = mergedContext;
+      for (const [index, hook] of hooks.entries()) {
+        const hookContextIndex = hooks.length - 1 - index;
+        const hookContext = hookContexts[hookContextIndex];
+        Object.assign(hookContext.context, accumulatedContext);
+        const hookResult = yield (_a = hook == null ? void 0 : hook.before) == null ? void 0 : _a.call(hook, hookContext, Object.freeze(options.hookHints));
+        if (hookResult) {
+          accumulatedContext = __spreadValues(__spreadValues({}, accumulatedContext), hookResult);
+          for (let i = 0; i < hooks.length; i++) {
+            Object.assign(hookContexts[hookContextIndex].context, accumulatedContext);
+          }
+        }
       }
-      return Object.freeze(hookContext.context);
+      return Object.freeze(accumulatedContext);
     });
   }
-  afterHooks(hooks, hookContext, evaluationDetails, options) {
+  afterHooks(hooks, hookContexts, evaluationDetails, options) {
     return __async(this, null, function* () {
       var _a;
-      for (const hook of hooks) {
+      for (const [index, hook] of hooks.entries()) {
+        const hookContext = hookContexts[index];
         yield (_a = hook == null ? void 0 : hook.after) == null ? void 0 : _a.call(hook, hookContext, evaluationDetails, options.hookHints);
       }
     });
   }
-  errorHooks(hooks, hookContext, err, options) {
+  errorHooks(hooks, hookContexts, err, options) {
     return __async(this, null, function* () {
       var _a;
-      for (const hook of hooks) {
+      for (const [index, hook] of hooks.entries()) {
         try {
+          const hookContext = hookContexts[index];
           yield (_a = hook == null ? void 0 : hook.error) == null ? void 0 : _a.call(hook, hookContext, err, options.hookHints);
         } catch (err2) {
           this._logger.error(`Unhandled error during 'error' hook: ${err2}`);
@@ -422,11 +989,12 @@ var OpenFeatureClient = class {
       }
     });
   }
-  finallyHooks(hooks, hookContext, evaluationDetails, options) {
+  finallyHooks(hooks, hookContexts, evaluationDetails, options) {
     return __async(this, null, function* () {
       var _a;
-      for (const hook of hooks) {
+      for (const [index, hook] of hooks.entries()) {
         try {
+          const hookContext = hookContexts[index];
           yield (_a = hook == null ? void 0 : hook.finally) == null ? void 0 : _a.call(hook, hookContext, evaluationDetails, options.hookHints);
         } catch (err) {
           this._logger.error(`Unhandled error during 'finally' hook: ${err}`);
@@ -452,42 +1020,25 @@ var OpenFeatureClient = class {
   }
   shortCircuitIfNotReady() {
     if (this.providerStatus === import_core.ServerProviderStatus.NOT_READY) {
-      throw new import_core4.ProviderNotReadyError("provider has not yet initialized");
+      throw new import_core10.ProviderNotReadyError("provider has not yet initialized");
     } else if (this.providerStatus === import_core.ServerProviderStatus.FATAL) {
-      throw new import_core4.ProviderFatalError("provider is in an irrecoverable error state");
+      throw new import_core10.ProviderFatalError("provider is in an irrecoverable error state");
     }
   }
   getErrorEvaluationDetails(flagKey, defaultValue, err, flagMetadata = {}) {
     const errorMessage = err == null ? void 0 : err.message;
-    const errorCode = (err == null ? void 0 : err.code) || import_core4.ErrorCode.GENERAL;
+    const errorCode = (err == null ? void 0 : err.code) || import_core10.ErrorCode.GENERAL;
     return {
       errorCode,
       errorMessage,
       value: defaultValue,
-      reason: import_core4.StandardResolutionReasons.ERROR,
+      reason: import_core10.StandardResolutionReasons.ERROR,
       flagMetadata: Object.freeze(flagMetadata),
       flagKey
     };
   }
 };
 
-// src/events/open-feature-event-emitter.ts
-var import_core5 = require("@openfeature/core");
-var import_node_events = require("node:events");
-var OpenFeatureEventEmitter = class extends import_core5.GenericEventEmitter {
-  constructor() {
-    super();
-    this.eventEmitter = new import_node_events.EventEmitter({ captureRejections: true });
-    this.eventEmitter.on("error", (err) => {
-      var _a;
-      (_a = this._logger) == null ? void 0 : _a.error("Error running event handler:", err);
-    });
-  }
-};
-
-// src/events/events.ts
-var import_core6 = require("@openfeature/core");
-
 // src/transaction-context/no-op-transaction-context-propagator.ts
 var NoopTransactionContextPropagator = class {
   getTransactionContext() {
@@ -517,12 +1068,12 @@ var AsyncLocalStorageTransactionContextPropagator = class {
 // src/open-feature.ts
 var GLOBAL_OPENFEATURE_API_KEY = Symbol.for("@openfeature/js-sdk/api");
 var _globalThis = globalThis;
-var OpenFeatureAPI = class _OpenFeatureAPI extends import_core7.OpenFeatureCommonAPI {
+var OpenFeatureAPI = class _OpenFeatureAPI extends import_core11.OpenFeatureCommonAPI {
   constructor() {
     super("server");
     this._statusEnumType = import_core.ServerProviderStatus;
     this._apiEmitter = new OpenFeatureEventEmitter();
-    this._defaultProvider = new import_core7.ProviderWrapper(
+    this._defaultProvider = new import_core11.ProviderWrapper(
       NOOP_PROVIDER,
       import_core.ServerProviderStatus.NOT_READY,
       this._statusEnumType
@@ -554,14 +1105,14 @@ var OpenFeatureAPI = class _OpenFeatureAPI extends import_core7.OpenFeatureCommo
   }
   setProviderAndWait(domainOrProvider, providerOrUndefined) {
     return __async(this, null, function* () {
-      const domain = (0, import_core7.stringOrUndefined)(domainOrProvider);
-      const provider = domain ? (0, import_core7.objectOrUndefined)(providerOrUndefined) : (0, import_core7.objectOrUndefined)(domainOrProvider);
+      const domain = (0, import_core11.stringOrUndefined)(domainOrProvider);
+      const provider = domain ? (0, import_core11.objectOrUndefined)(providerOrUndefined) : (0, import_core11.objectOrUndefined)(domainOrProvider);
       yield this.setAwaitableProvider(domain, provider);
     });
   }
   setProvider(clientOrProvider, providerOrUndefined) {
-    const domain = (0, import_core7.stringOrUndefined)(clientOrProvider);
-    const provider = domain ? (0, import_core7.objectOrUndefined)(providerOrUndefined) : (0, import_core7.objectOrUndefined)(clientOrProvider);
+    const domain = (0, import_core11.stringOrUndefined)(clientOrProvider);
+    const provider = domain ? (0, import_core11.objectOrUndefined)(providerOrUndefined) : (0, import_core11.objectOrUndefined)(clientOrProvider);
     const maybePromise = this.setAwaitableProvider(domain, provider);
     Promise.resolve(maybePromise).catch((err) => {
       this._logger.error("Error during provider initialization:", err);
@@ -580,9 +1131,9 @@ var OpenFeatureAPI = class _OpenFeatureAPI extends import_core7.OpenFeatureCommo
   }
   getClient(domainOrContext, versionOrContext, contextOrUndefined) {
     var _a, _b;
-    const domain = (0, import_core7.stringOrUndefined)(domainOrContext);
-    const version = (0, import_core7.stringOrUndefined)(versionOrContext);
-    const context = (_b = (_a = (0, import_core7.objectOrUndefined)(domainOrContext)) != null ? _a : (0, import_core7.objectOrUndefined)(versionOrContext)) != null ? _b : (0, import_core7.objectOrUndefined)(contextOrUndefined);
+    const domain = (0, import_core11.stringOrUndefined)(domainOrContext);
+    const version = (0, import_core11.stringOrUndefined)(versionOrContext);
+    const context = (_b = (_a = (0, import_core11.objectOrUndefined)(domainOrContext)) != null ? _a : (0, import_core11.objectOrUndefined)(versionOrContext)) != null ? _b : (0, import_core11.objectOrUndefined)(contextOrUndefined);
     return new OpenFeatureClient(
       () => this.getProviderForClient(domain),
       () => this.getProviderStatus(domain),
@@ -633,8 +1184,15 @@ var OpenFeature = OpenFeatureAPI.getInstance();
 __reExport(index_exports, require("@openfeature/core"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AggregateError,
   AsyncLocalStorageTransactionContextPropagator,
+  BaseEvaluationStrategy,
+  ComparisonStrategy,
+  ErrorWithCode,
+  FirstMatchStrategy,
+  FirstSuccessfulStrategy,
   InMemoryProvider,
+  MultiProvider,
   NOOP_PROVIDER,
   NOOP_TRANSACTION_CONTEXT_PROPAGATOR,
   OpenFeature,
@@ -642,6 +1200,8 @@ __reExport(index_exports, require("@openfeature/core"), module.exports);
   OpenFeatureEventEmitter,
   ProviderEvents,
   ProviderStatus,
+  constructAggregateError,
+  throwAggregateErrorFromPromiseResults,
   ...require("@openfeature/core")
 });
 //# sourceMappingURL=index.js.map