@openfeature/server-sdk 1.9.1 → 1.11.0

package/README.md

@@ -16,8 +16,8 @@
     <img alt="Specification" src="https://img.shields.io/static/v1?label=specification&message=v0.7.0&color=yellow&style=for-the-badge" />
   </a>
   <!-- x-release-please-start-version -->
-  <a href="https://github.com/open-feature/js-sdk/releases/tag/server-sdk-v1.9.1">
-    <img alt="Release" src="https://img.shields.io/static/v1?label=release&message=v1.9.1&color=blue&style=for-the-badge" />
+  <a href="https://github.com/open-feature/js-sdk/releases/tag/server-sdk-v1.11.0">
+    <img alt="Release" src="https://img.shields.io/static/v1?label=release&message=v1.11.0&color=blue&style=for-the-badge" />
   </a>
   <!-- x-release-please-end -->
   <br/>
@@ -271,43 +271,48 @@ This can be a new repository or included in [the existing contrib repository](ht
 You’ll then need to write the provider by implementing the [Provider interface](./src/provider/provider.ts) exported by the OpenFeature SDK.
 
 ```ts
-import { JsonValue, Provider, ResolutionDetails } from '@openfeature/server-sdk';
+import {
+  AnyProviderEvent,
+  EvaluationContext,
+  Hook,
+  JsonValue,
+  Logger,
+  Provider,
+  ProviderEventEmitter,
+  ProviderStatus,
+  ResolutionDetails
+} from '@openfeature/server-sdk';
 
 // implement the provider interface
 class MyProvider implements Provider {
   // Adds runtime validation that the provider is used with the expected SDK
   public readonly runsOn = 'server';
-
   readonly metadata = {
     name: 'My Provider',
   } as const;
-
   // Optional provider managed hooks
-  hooks?: Hook<FlagValue>[];
-
+  hooks?: Hook[];
   resolveBooleanEvaluation(flagKey: string, defaultValue: boolean, context: EvaluationContext, logger: Logger): Promise<ResolutionDetails<boolean>> {
     // code to evaluate a boolean
   }
-
   resolveStringEvaluation(flagKey: string, defaultValue: string, context: EvaluationContext, logger: Logger): Promise<ResolutionDetails<string>> {
     // code to evaluate a string
   }
-
   resolveNumberEvaluation(flagKey: string, defaultValue: number, context: EvaluationContext, logger: Logger): Promise<ResolutionDetails<number>> {
     // code to evaluate a number
   }
-
   resolveObjectEvaluation<T extends JsonValue>(flagKey: string, defaultValue: T, context: EvaluationContext, logger: Logger): Promise<ResolutionDetails<T>> {
     // code to evaluate an object
   }
 
   status?: ProviderStatus | undefined;
-  events?: OpenFeatureEventEmitter | undefined;
+
+  // implement with "new OpenFeatureEventEmitter()", and use "emit()" to emit events
+  events?: ProviderEventEmitter<AnyProviderEvent> | undefined; 
 
   initialize?(context?: EvaluationContext | undefined): Promise<void> {
     // code to initialize your provider
   }
-
   onClose?(): Promise<void> {
     // code to shut down your provider
   }

package/dist/cjs/index.js

@@ -1,27 +1,10 @@
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -44,26 +27,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
 
 // src/index.ts
 var src_exports = {};
@@ -86,11 +49,9 @@ var import_core7 = require("@openfeature/core");
 var import_core = require("@openfeature/core");
 var REASON_NO_OP = "No-op";
 var NoopFeatureProvider = class {
-  constructor() {
-    this.metadata = {
-      name: "No-op Provider"
-    };
-  }
+  metadata = {
+    name: "No-op Provider"
+  };
   get status() {
     return import_core.ProviderStatus.NOT_READY;
   }
@@ -121,6 +82,7 @@ var import_core3 = require("@openfeature/core");
 // src/provider/in-memory-provider/variant-not-found-error.ts
 var import_core2 = require("@openfeature/core");
 var VariantFoundError = class extends import_core2.OpenFeatureError {
+  code;
   constructor(message) {
     super(message);
     Object.setPrototypeOf(this, VariantFoundError.prototype);
@@ -131,13 +93,14 @@ var VariantFoundError = class extends import_core2.OpenFeatureError {
 
 // src/provider/in-memory-provider/in-memory-provider.ts
 var InMemoryProvider = class {
+  events = new OpenFeatureEventEmitter();
+  runsOn = "server";
+  metadata = {
+    name: "in-memory"
+  };
+  _flagConfiguration;
   constructor(flagConfiguration = {}) {
-    this.events = new OpenFeatureEventEmitter();
-    this.runsOn = "server";
-    this.metadata = {
-      name: "in-memory"
-    };
-    this._flagConfiguration = __spreadValues({}, flagConfiguration);
+    this._flagConfiguration = { ...flagConfiguration };
   }
   /**
    * Overwrites the configured flags.
@@ -145,7 +108,7 @@ var InMemoryProvider = class {
    */
   putConfiguration(flagConfiguration) {
     const flagsChanged = Object.entries(flagConfiguration).filter(([key, value]) => this._flagConfiguration[key] !== value).map(([key]) => key);
-    this._flagConfiguration = __spreadValues({}, flagConfiguration);
+    this._flagConfiguration = { ...flagConfiguration };
     this.events.emit(import_core5.ServerProviderEvents.ConfigurationChanged, { flagsChanged });
   }
   resolveBooleanEvaluation(flagKey, defaultValue, context, logger) {
@@ -154,56 +117,49 @@ var InMemoryProvider = class {
   resolveNumberEvaluation(flagKey, defaultValue, context, logger) {
     return this.resolveFlagWithReason(flagKey, defaultValue, context, logger);
   }
-  resolveStringEvaluation(flagKey, defaultValue, context, logger) {
-    return __async(this, null, function* () {
-      return this.resolveFlagWithReason(flagKey, defaultValue, context, logger);
-    });
+  async resolveStringEvaluation(flagKey, defaultValue, context, logger) {
+    return this.resolveFlagWithReason(flagKey, defaultValue, context, logger);
   }
-  resolveObjectEvaluation(flagKey, defaultValue, context, logger) {
-    return __async(this, null, function* () {
-      return this.resolveFlagWithReason(flagKey, defaultValue, context, logger);
-    });
+  async resolveObjectEvaluation(flagKey, defaultValue, context, logger) {
+    return this.resolveFlagWithReason(flagKey, defaultValue, context, logger);
   }
-  resolveFlagWithReason(flagKey, defaultValue, ctx, logger) {
-    return __async(this, null, function* () {
-      try {
-        const resolutionResult = this.lookupFlagValue(flagKey, defaultValue, ctx, logger);
-        if (typeof (resolutionResult == null ? void 0 : resolutionResult.value) != typeof defaultValue) {
-          throw new import_core3.TypeMismatchError();
-        }
-        return resolutionResult;
-      } catch (error) {
-        if (!(error instanceof import_core3.OpenFeatureError)) {
-          throw new import_core3.GeneralError((error == null ? void 0 : error.message) || "unknown error");
-        }
-        throw error;
+  async resolveFlagWithReason(flagKey, defaultValue, ctx, logger) {
+    try {
+      const resolutionResult = this.lookupFlagValue(flagKey, defaultValue, ctx, logger);
+      if (typeof resolutionResult?.value != typeof defaultValue) {
+        throw new import_core3.TypeMismatchError();
       }
-    });
+      return resolutionResult;
+    } catch (error) {
+      if (!(error instanceof import_core3.OpenFeatureError)) {
+        throw new import_core3.GeneralError(error?.message || "unknown error");
+      }
+      throw error;
+    }
   }
   lookupFlagValue(flagKey, defaultValue, ctx, logger) {
-    var _a;
     if (!(flagKey in this._flagConfiguration)) {
       const message = `no flag found with key ${flagKey}`;
-      logger == null ? void 0 : logger.debug(message);
+      logger?.debug(message);
       throw new import_core3.FlagNotFoundError(message);
     }
     const flagSpec = this._flagConfiguration[flagKey];
     if (flagSpec.disabled) {
       return { value: defaultValue, reason: import_core3.StandardResolutionReasons.DISABLED };
     }
-    const isContextEval = ctx && (flagSpec == null ? void 0 : flagSpec.contextEvaluator);
-    const variant = isContextEval ? (_a = flagSpec.contextEvaluator) == null ? void 0 : _a.call(flagSpec, ctx) : flagSpec.defaultVariant;
-    const value = variant && (flagSpec == null ? void 0 : flagSpec.variants[variant]);
+    const isContextEval = ctx && flagSpec?.contextEvaluator;
+    const variant = isContextEval ? flagSpec.contextEvaluator?.(ctx) : flagSpec.defaultVariant;
+    const value = variant && flagSpec?.variants[variant];
     if (value === void 0) {
       const message = `no value associated with variant ${variant}`;
-      logger == null ? void 0 : logger.error(message);
+      logger?.error(message);
       throw new VariantFoundError(message);
     }
-    return __spreadProps(__spreadValues({
-      value
-    }, variant && { variant }), {
+    return {
+      value,
+      ...variant && { variant },
       reason: isContextEval ? import_core3.StandardResolutionReasons.TARGETING_MATCH : import_core3.StandardResolutionReasons.STATIC
-    });
+    };
   }
 };
 
@@ -225,12 +181,11 @@ var NOOP_TRANSACTION_CONTEXT_PROPAGATOR = new NoopTransactionContextPropagator()
 var import_core4 = require("@openfeature/core");
 var import_events = __toESM(require("events"));
 var OpenFeatureEventEmitter = class extends import_core4.GenericEventEmitter {
+  eventEmitter = new import_events.default({ captureRejections: true });
   constructor() {
     super();
-    this.eventEmitter = new import_events.default({ captureRejections: true });
     this.eventEmitter.on("error", (err) => {
-      var _a;
-      (_a = this._logger) == null ? void 0 : _a.error("Error running event handler:", err);
+      this._logger?.error("Error running event handler:", err);
     });
   }
 };
@@ -242,12 +197,12 @@ var import_core5 = require("@openfeature/core");
 var GLOBAL_OPENFEATURE_API_KEY = Symbol.for("@openfeature/js-sdk/api");
 var _globalThis = globalThis;
 var OpenFeatureAPI = class extends import_core6.OpenFeatureCommonAPI {
+  _events = new OpenFeatureEventEmitter();
+  _defaultProvider = NOOP_PROVIDER;
+  _createEventEmitter = () => new OpenFeatureEventEmitter();
+  _transactionContextPropagator = NOOP_TRANSACTION_CONTEXT_PROPAGATOR;
   constructor() {
     super("server");
-    this._events = new OpenFeatureEventEmitter();
-    this._defaultProvider = NOOP_PROVIDER;
-    this._createEventEmitter = () => new OpenFeatureEventEmitter();
-    this._transactionContextPropagator = NOOP_TRANSACTION_CONTEXT_PROPAGATOR;
   }
   /**
    * Gets a singleton instance of the OpenFeature API.
@@ -271,10 +226,9 @@ var OpenFeatureAPI = class extends import_core6.OpenFeatureCommonAPI {
     return this._context;
   }
   getClient(nameOrContext, versionOrContext, contextOrUndefined) {
-    var _a, _b;
     const name = (0, import_core6.stringOrUndefined)(nameOrContext);
     const version = (0, import_core6.stringOrUndefined)(versionOrContext);
-    const context = (_b = (_a = (0, import_core6.objectOrUndefined)(nameOrContext)) != null ? _a : (0, import_core6.objectOrUndefined)(versionOrContext)) != null ? _b : (0, import_core6.objectOrUndefined)(contextOrUndefined);
+    const context = (0, import_core6.objectOrUndefined)(nameOrContext) ?? (0, import_core6.objectOrUndefined)(versionOrContext) ?? (0, import_core6.objectOrUndefined)(contextOrUndefined);
     return new OpenFeatureClient(
       () => this.getProviderForClient(name),
       () => this.buildAndCacheEventEmitterForClient(name),
@@ -292,9 +246,9 @@ var OpenFeatureAPI = class extends import_core6.OpenFeatureCommonAPI {
   }
   setTransactionContextPropagator(transactionContextPropagator) {
     const baseMessage = "Invalid TransactionContextPropagator, will not be set: ";
-    if (typeof (transactionContextPropagator == null ? void 0 : transactionContextPropagator.getTransactionContext) !== "function") {
+    if (typeof transactionContextPropagator?.getTransactionContext !== "function") {
       this._logger.error(`${baseMessage}: getTransactionContext is not a function.`);
-    } else if (typeof (transactionContextPropagator == null ? void 0 : transactionContextPropagator.setTransactionContext) !== "function") {
+    } else if (typeof transactionContextPropagator?.setTransactionContext !== "function") {
       this._logger.error(`${baseMessage}: setTransactionContext is not a function.`);
     } else {
       this._transactionContextPropagator = transactionContextPropagator;
@@ -309,8 +263,8 @@ var OpenFeatureAPI = class extends import_core6.OpenFeatureCommonAPI {
       return this._transactionContextPropagator.getTransactionContext();
     } catch (err) {
       const error = err;
-      this._logger.error(`Error getting transaction context: ${error == null ? void 0 : error.message}, returning empty context.`);
-      this._logger.error(error == null ? void 0 : error.stack);
+      this._logger.error(`Error getting transaction context: ${error?.message}, returning empty context.`);
+      this._logger.error(error?.stack);
       return {};
     }
   }
@@ -324,9 +278,11 @@ var OpenFeatureClient = class {
     this.emitterAccessor = emitterAccessor;
     this.globalLogger = globalLogger;
     this.options = options;
-    this._hooks = [];
     this._context = context;
   }
+  _context;
+  _hooks = [];
+  _clientLogger;
   get metadata() {
     return {
       name: this.options.name,
@@ -335,14 +291,13 @@ var OpenFeatureClient = class {
     };
   }
   addHandler(eventType, handler) {
-    var _a;
     this.emitterAccessor().addHandler(eventType, handler);
     const shouldRunNow = (0, import_core7.statusMatchesEvent)(eventType, this._provider.status);
     if (shouldRunNow) {
       try {
         handler({ clientName: this.metadata.name, providerName: this._provider.metadata.name });
       } catch (err) {
-        (_a = this._logger) == null ? void 0 : _a.error("Error running event handler:", err);
+        this._logger?.error("Error running event handler:", err);
       }
     }
   }
@@ -374,10 +329,8 @@ var OpenFeatureClient = class {
     this._hooks = [];
     return this;
   }
-  getBooleanValue(flagKey, defaultValue, context, options) {
-    return __async(this, null, function* () {
-      return (yield this.getBooleanDetails(flagKey, defaultValue, context, options)).value;
-    });
+  async getBooleanValue(flagKey, defaultValue, context, options) {
+    return (await this.getBooleanDetails(flagKey, defaultValue, context, options)).value;
   }
   getBooleanDetails(flagKey, defaultValue, context, options) {
     return this.evaluate(
@@ -389,10 +342,8 @@ var OpenFeatureClient = class {
       options
     );
   }
-  getStringValue(flagKey, defaultValue, context, options) {
-    return __async(this, null, function* () {
-      return (yield this.getStringDetails(flagKey, defaultValue, context, options)).value;
-    });
+  async getStringValue(flagKey, defaultValue, context, options) {
+    return (await this.getStringDetails(flagKey, defaultValue, context, options)).value;
   }
   getStringDetails(flagKey, defaultValue, context, options) {
     return this.evaluate(
@@ -405,10 +356,8 @@ var OpenFeatureClient = class {
       options
     );
   }
-  getNumberValue(flagKey, defaultValue, context, options) {
-    return __async(this, null, function* () {
-      return (yield this.getNumberDetails(flagKey, defaultValue, context, options)).value;
-    });
+  async getNumberValue(flagKey, defaultValue, context, options) {
+    return (await this.getNumberDetails(flagKey, defaultValue, context, options)).value;
   }
   getNumberDetails(flagKey, defaultValue, context, options) {
     return this.evaluate(
@@ -421,109 +370,101 @@ var OpenFeatureClient = class {
       options
     );
   }
-  getObjectValue(flagKey, defaultValue, context, options) {
-    return __async(this, null, function* () {
-      return (yield this.getObjectDetails(flagKey, defaultValue, context, options)).value;
-    });
+  async getObjectValue(flagKey, defaultValue, context, options) {
+    return (await this.getObjectDetails(flagKey, defaultValue, context, options)).value;
   }
   getObjectDetails(flagKey, defaultValue, context, options) {
     return this.evaluate(flagKey, this._provider.resolveObjectEvaluation, defaultValue, "object", context, options);
   }
-  evaluate(_0, _1, _2, _3) {
-    return __async(this, arguments, function* (flagKey, resolver, defaultValue, flagType, invocationContext = {}, options = {}) {
-      var _a;
-      const allHooks = [
-        ...OpenFeature.getHooks(),
-        ...this.getHooks(),
-        ...options.hooks || [],
-        ...this._provider.hooks || []
-      ];
-      const allHooksReversed = [...allHooks].reverse();
-      const mergedContext = __spreadValues(__spreadValues(__spreadValues(__spreadValues({}, OpenFeature.getContext()), OpenFeature.getTransactionContext()), this._context), invocationContext);
-      const hookContext = {
-        flagKey,
-        defaultValue,
-        flagValueType: flagType,
-        clientMetadata: this.metadata,
-        providerMetadata: OpenFeature.providerMetadata,
-        context: mergedContext,
-        logger: this._logger
+  async evaluate(flagKey, resolver, defaultValue, flagType, invocationContext = {}, options = {}) {
+    const allHooks = [
+      ...OpenFeature.getHooks(),
+      ...this.getHooks(),
+      ...options.hooks || [],
+      ...this._provider.hooks || []
+    ];
+    const allHooksReversed = [...allHooks].reverse();
+    const mergedContext = {
+      ...OpenFeature.getContext(),
+      ...OpenFeature.getTransactionContext(),
+      ...this._context,
+      ...invocationContext
+    };
+    const hookContext = {
+      flagKey,
+      defaultValue,
+      flagValueType: flagType,
+      clientMetadata: this.metadata,
+      providerMetadata: OpenFeature.providerMetadata,
+      context: mergedContext,
+      logger: this._logger
+    };
+    try {
+      const frozenContext = await this.beforeHooks(allHooks, hookContext, options);
+      const resolution = await resolver.call(this._provider, flagKey, defaultValue, frozenContext, this._logger);
+      const evaluationDetails = {
+        ...resolution,
+        flagMetadata: Object.freeze(resolution.flagMetadata ?? {}),
+        flagKey
       };
-      try {
-        const frozenContext = yield this.beforeHooks(allHooks, hookContext, options);
-        const resolution = yield resolver.call(this._provider, flagKey, defaultValue, frozenContext, this._logger);
-        const evaluationDetails = __spreadProps(__spreadValues({}, resolution), {
-          flagMetadata: Object.freeze((_a = resolution.flagMetadata) != null ? _a : {}),
-          flagKey
-        });
-        yield this.afterHooks(allHooksReversed, hookContext, evaluationDetails, options);
-        return evaluationDetails;
-      } catch (err) {
-        const errorMessage = err == null ? void 0 : err.message;
-        const errorCode = (err == null ? void 0 : err.code) || import_core7.ErrorCode.GENERAL;
-        yield this.errorHooks(allHooksReversed, hookContext, err, options);
-        return {
-          errorCode,
-          errorMessage,
-          value: defaultValue,
-          reason: import_core7.StandardResolutionReasons.ERROR,
-          flagMetadata: Object.freeze({}),
-          flagKey
-        };
-      } finally {
-        yield this.finallyHooks(allHooksReversed, hookContext, options);
-      }
-    });
+      await this.afterHooks(allHooksReversed, hookContext, evaluationDetails, options);
+      return evaluationDetails;
+    } catch (err) {
+      const errorMessage = err?.message;
+      const errorCode = err?.code || import_core7.ErrorCode.GENERAL;
+      await this.errorHooks(allHooksReversed, hookContext, err, options);
+      return {
+        errorCode,
+        errorMessage,
+        value: defaultValue,
+        reason: import_core7.StandardResolutionReasons.ERROR,
+        flagMetadata: Object.freeze({}),
+        flagKey
+      };
+    } finally {
+      await this.finallyHooks(allHooksReversed, hookContext, options);
+    }
   }
-  beforeHooks(hooks, hookContext, 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))));
-      }
-      return Object.freeze(hookContext.context);
-    });
+  async beforeHooks(hooks, hookContext, options) {
+    for (const hook of hooks) {
+      Object.freeze(hookContext);
+      Object.assign(hookContext.context, {
+        ...hookContext.context,
+        ...await hook?.before?.(hookContext, Object.freeze(options.hookHints))
+      });
+    }
+    return Object.freeze(hookContext.context);
   }
-  afterHooks(hooks, hookContext, evaluationDetails, options) {
-    return __async(this, null, function* () {
-      var _a;
-      for (const hook of hooks) {
-        yield (_a = hook == null ? void 0 : hook.after) == null ? void 0 : _a.call(hook, hookContext, evaluationDetails, options.hookHints);
-      }
-    });
+  async afterHooks(hooks, hookContext, evaluationDetails, options) {
+    for (const hook of hooks) {
+      await hook?.after?.(hookContext, evaluationDetails, options.hookHints);
+    }
   }
-  errorHooks(hooks, hookContext, err, options) {
-    return __async(this, null, function* () {
-      var _a;
-      for (const hook of hooks) {
-        try {
-          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}`);
-          if (err2 instanceof Error) {
-            this._logger.error(err2.stack);
-          }
-          this._logger.error(err2 == null ? void 0 : err2.stack);
+  async errorHooks(hooks, hookContext, err, options) {
+    for (const hook of hooks) {
+      try {
+        await hook?.error?.(hookContext, err, options.hookHints);
+      } catch (err2) {
+        this._logger.error(`Unhandled error during 'error' hook: ${err2}`);
+        if (err2 instanceof Error) {
+          this._logger.error(err2.stack);
         }
+        this._logger.error(err2?.stack);
       }
-    });
+    }
   }
-  finallyHooks(hooks, hookContext, options) {
-    return __async(this, null, function* () {
-      var _a;
-      for (const hook of hooks) {
-        try {
-          yield (_a = hook == null ? void 0 : hook.finally) == null ? void 0 : _a.call(hook, hookContext, options.hookHints);
-        } 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);
+  async finallyHooks(hooks, hookContext, options) {
+    for (const hook of hooks) {
+      try {
+        await hook?.finally?.(hookContext, options.hookHints);
+      } catch (err) {
+        this._logger.error(`Unhandled error during 'finally' hook: ${err}`);
+        if (err instanceof Error) {
+          this._logger.error(err.stack);
         }
+        this._logger.error(err?.stack);
       }
-    });
+    }
   }
   get _provider() {
     return this.providerAccessor();