@openfeature/server-sdk 1.20.0 → 1.20.2

package/dist/esm/index.js

@@ -39,9 +39,7 @@ var __async = (__this, __arguments, generator) => {
 };
 
 // src/provider/provider.ts
-import {
-  ServerProviderStatus
-} from "@openfeature/core";
+import { ServerProviderStatus } from "@openfeature/core";
 
 // src/provider/no-op-provider.ts
 var REASON_NO_OP = "No-op";
@@ -171,7 +169,37 @@ var InMemoryProvider = class {
 };
 
 // src/provider/multi-provider/multi-provider.ts
-import { DefaultLogger, ErrorCode as ErrorCode3, GeneralError as GeneralError4, StandardResolutionReasons as StandardResolutionReasons2 } from "@openfeature/core";
+import {
+  DefaultLogger,
+  ErrorCode as ErrorCode2,
+  GeneralError as GeneralError2,
+  StandardResolutionReasons as StandardResolutionReasons2,
+  constructAggregateError,
+  throwAggregateErrorFromPromiseResults,
+  StatusTracker
+} from "@openfeature/core";
+
+// src/provider/multi-provider/strategies.ts
+import {
+  BaseFirstMatchStrategy,
+  BaseFirstSuccessfulStrategy,
+  BaseComparisonStrategy
+} from "@openfeature/core";
+var FirstMatchStrategy = class extends BaseFirstMatchStrategy {
+  constructor() {
+    super(ServerProviderStatus);
+  }
+};
+var FirstSuccessfulStrategy = class extends BaseFirstSuccessfulStrategy {
+  constructor() {
+    super(ServerProviderStatus);
+  }
+};
+var ComparisonStrategy = class extends BaseComparisonStrategy {
+  constructor(fallbackProvider, onMismatch) {
+    super(ServerProviderStatus, fallbackProvider, onMismatch);
+  }
+};
 
 // src/events/open-feature-event-emitter.ts
 import { GenericEventEmitter } from "@openfeature/core";
@@ -187,40 +215,8 @@ var OpenFeatureEventEmitter = class extends GenericEventEmitter {
   }
 };
 
-// src/provider/multi-provider/errors.ts
-import { GeneralError as GeneralError2, OpenFeatureError as OpenFeatureError3 } from "@openfeature/core";
-var ErrorWithCode = class extends OpenFeatureError3 {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-  }
-};
-var AggregateError = class extends GeneralError2 {
-  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/events/events.ts
+import { ServerProviderEvents } from "@openfeature/core";
 
 // src/provider/multi-provider/hook-executor.ts
 var HookExecutor = class {
@@ -279,193 +275,6 @@ var HookExecutor = class {
   }
 };
 
-// src/events/events.ts
-import { ServerProviderEvents } from "@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(ServerProviderEvents.Error, (details) => {
-      this.changeProviderStatus(providerEntry.name, ServerProviderStatus.ERROR, details);
-    });
-    (_b = provider.events) == null ? void 0 : _b.addHandler(ServerProviderEvents.Stale, (details) => {
-      this.changeProviderStatus(providerEntry.name, ServerProviderStatus.STALE, details);
-    });
-    (_c = provider.events) == null ? void 0 : _c.addHandler(ServerProviderEvents.ConfigurationChanged, (details) => {
-      this.events.emit(ServerProviderEvents.ConfigurationChanged, details);
-    });
-    (_d = provider.events) == null ? void 0 : _d.addHandler(ServerProviderEvents.Ready, (details) => {
-      this.changeProviderStatus(providerEntry.name, ServerProviderStatus.READY, details);
-    });
-  }
-  providerStatus(name) {
-    return this.providerStatuses[name];
-  }
-  getStatusFromProviderStatuses() {
-    const statuses = Object.values(this.providerStatuses);
-    if (statuses.includes(ServerProviderStatus.FATAL)) {
-      return ServerProviderStatus.FATAL;
-    } else if (statuses.includes(ServerProviderStatus.NOT_READY)) {
-      return ServerProviderStatus.NOT_READY;
-    } else if (statuses.includes(ServerProviderStatus.ERROR)) {
-      return ServerProviderStatus.ERROR;
-    } else if (statuses.includes(ServerProviderStatus.STALE)) {
-      return ServerProviderStatus.STALE;
-    }
-    return ServerProviderStatus.READY;
-  }
-  changeProviderStatus(name, status, details) {
-    const currentStatus = this.getStatusFromProviderStatuses();
-    this.providerStatuses[name] = status;
-    const newStatus = this.getStatusFromProviderStatuses();
-    if (currentStatus !== newStatus) {
-      if (newStatus === ServerProviderStatus.FATAL || newStatus === ServerProviderStatus.ERROR) {
-        this.events.emit(ServerProviderEvents.Error, details);
-      } else if (newStatus === ServerProviderStatus.STALE) {
-        this.events.emit(ServerProviderEvents.Stale, details);
-      } else if (newStatus === ServerProviderStatus.READY) {
-        this.events.emit(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 === ServerProviderStatus.NOT_READY || strategyContext.providerStatus === ServerProviderStatus.FATAL) {
-      return false;
-    }
-    return true;
-  }
-  shouldEvaluateNextProvider(_strategyContext, _context, _result) {
-    return true;
-  }
-  shouldTrackWithThisProvider(strategyContext, _context, _trackingEventName, _trackingEventDetails) {
-    if (strategyContext.providerStatus === ServerProviderStatus.NOT_READY || strategyContext.providerStatus === 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
-import { ErrorCode as ErrorCode2 } from "@openfeature/core";
-var FirstMatchStrategy = class extends BaseEvaluationStrategy {
-  shouldEvaluateNextProvider(strategyContext, context, result) {
-    if (this.hasErrorWithCode(result, ErrorCode2.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
-import { GeneralError as GeneralError3 } from "@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 GeneralError3("Fallback provider not found in resolution results");
-    }
-    if (!finalResolution) {
-      throw new GeneralError3("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 DefaultLogger()) {
@@ -478,7 +287,7 @@ var MultiProvider = class _MultiProvider {
     this.hookHints = /* @__PURE__ */ new WeakMap();
     this.providerEntries = [];
     this.providerEntriesByName = {};
-    this.statusTracker = new StatusTracker(this.events);
+    this.statusTracker = new StatusTracker(this.events, ServerProviderStatus, ServerProviderEvents);
     this.hookExecutor = new HookExecutor(this.logger);
     this.registerProviders(constructorProviders);
     const aggregateMetadata = Object.keys(this.providerEntriesByName).reduce((acc, name) => {
@@ -550,7 +359,7 @@ var MultiProvider = class _MultiProvider {
       const hookContext = this.hookContexts.get(context);
       const hookHints = this.hookHints.get(context);
       if (!hookContext || !hookHints) {
-        throw new GeneralError4("Hook context not available for evaluation");
+        throw new GeneralError2("Hook context not available for evaluation");
       }
       const tasks = [];
       for (const providerEntry of this.providerEntries) {
@@ -578,7 +387,7 @@ var MultiProvider = class _MultiProvider {
         throw constructAggregateError(finalResult.errors);
       }
       if (!finalResult.details) {
-        throw new GeneralError4("No result was returned from any provider");
+        throw new GeneralError2("No result was returned from any provider");
       }
       return finalResult.details;
     });
@@ -657,7 +466,7 @@ var MultiProvider = class _MultiProvider {
         case "boolean":
           return yield provider.resolveBooleanEvaluation(flagKey, defaultValue, context, this.logger);
         default:
-          throw new GeneralError4("Invalid flag evaluation type");
+          throw new GeneralError2("Invalid flag evaluation type");
       }
     });
   }
@@ -702,7 +511,7 @@ var MultiProvider = class _MultiProvider {
   }
   getErrorEvaluationDetails(flagKey, defaultValue, err, flagMetadata = {}) {
     const errorMessage = err == null ? void 0 : err.message;
-    const errorCode = (err == null ? void 0 : err.code) || ErrorCode3.GENERAL;
+    const errorCode = (err == null ? void 0 : err.code) || ErrorCode2.GENERAL;
     return {
       errorCode,
       errorMessage,
@@ -715,16 +524,11 @@ var MultiProvider = class _MultiProvider {
 };
 
 // src/open-feature.ts
-import {
-  OpenFeatureCommonAPI,
-  ProviderWrapper,
-  objectOrUndefined,
-  stringOrUndefined
-} from "@openfeature/core";
+import { OpenFeatureCommonAPI, ProviderWrapper, objectOrUndefined, stringOrUndefined } from "@openfeature/core";
 
 // src/client/internal/open-feature-client.ts
 import {
-  ErrorCode as ErrorCode4,
+  ErrorCode as ErrorCode3,
   ProviderFatalError,
   ProviderNotReadyError,
   SafeLogger,
@@ -928,17 +732,15 @@ var OpenFeatureClient = class {
   beforeHooks(hooks, hookContexts, mergedContext, options) {
     return __async(this, null, function* () {
       var _a;
-      let accumulatedContext = mergedContext;
+      const 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);
-          }
+          Object.assign(accumulatedContext, hookResult);
+          Object.assign(hookContext.context, accumulatedContext);
         }
       }
       return Object.freeze(accumulatedContext);
@@ -1008,7 +810,7 @@ var OpenFeatureClient = class {
   }
   getErrorEvaluationDetails(flagKey, defaultValue, err, flagMetadata = {}) {
     const errorMessage = err == null ? void 0 : err.message;
-    const errorCode = (err == null ? void 0 : err.code) || ErrorCode4.GENERAL;
+    const errorCode = (err == null ? void 0 : err.code) || ErrorCode3.GENERAL;
     return {
       errorCode,
       errorMessage,
@@ -1164,11 +966,8 @@ var OpenFeature = OpenFeatureAPI.getInstance();
 // src/index.ts
 export * from "@openfeature/core";
 export {
-  AggregateError,
   AsyncLocalStorageTransactionContextPropagator,
-  BaseEvaluationStrategy,
   ComparisonStrategy,
-  ErrorWithCode,
   FirstMatchStrategy,
   FirstSuccessfulStrategy,
   InMemoryProvider,
@@ -1179,8 +978,6 @@ export {
   OpenFeatureAPI,
   OpenFeatureEventEmitter,
   ServerProviderEvents as ProviderEvents,
-  ServerProviderStatus as ProviderStatus,
-  constructAggregateError,
-  throwAggregateErrorFromPromiseResults
+  ServerProviderStatus as ProviderStatus
 };
 //# sourceMappingURL=index.js.map