@openfeature/web-sdk 1.6.2 → 1.7.1

package/dist/esm/index.js

@@ -378,6 +378,515 @@ var InMemoryProvider = class {
   }
 };
 
+// src/provider/multi-provider/multi-provider-web.ts
+import { DefaultLogger, GeneralError as GeneralError4, ErrorCode as ErrorCode3, StandardResolutionReasons as StandardResolutionReasons2 } from "@openfeature/core";
+
+// src/provider/multi-provider/hook-executor.ts
+var HookExecutor = class {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  beforeHooks(hooks, hookContext, hints) {
+    var _a;
+    for (const hook of hooks != null ? hooks : []) {
+      (_a = hook == null ? void 0 : hook.before) == null ? void 0 : _a.call(hook, hookContext, Object.freeze(hints));
+    }
+  }
+  afterHooks(hooks, hookContext, evaluationDetails, hints) {
+    var _a;
+    for (const hook of hooks != null ? hooks : []) {
+      (_a = hook == null ? void 0 : hook.after) == null ? void 0 : _a.call(hook, hookContext, evaluationDetails, hints);
+    }
+  }
+  errorHooks(hooks, hookContext, err, hints) {
+    var _a;
+    for (const hook of hooks != null ? hooks : []) {
+      try {
+        (_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);
+        }
+      }
+    }
+  }
+  finallyHooks(hooks, hookContext, evaluationDetails, hints) {
+    var _a;
+    for (const hook of hooks != null ? hooks : []) {
+      try {
+        (_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);
+        }
+      }
+    }
+  }
+};
+
+// 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/provider/multi-provider/strategies/base-evaluation-strategy.ts
+var BaseEvaluationStrategy = class {
+  shouldEvaluateThisProvider(strategyContext, _evalContext) {
+    if (strategyContext.providerStatus === ClientProviderStatus.NOT_READY || strategyContext.providerStatus === ClientProviderStatus.FATAL) {
+      return false;
+    }
+    return true;
+  }
+  shouldEvaluateNextProvider(_strategyContext, _context, _result) {
+    return true;
+  }
+  shouldTrackWithThisProvider(strategyContext, _context, _trackingEventName, _trackingEventDetails) {
+    if (strategyContext.providerStatus === ClientProviderStatus.NOT_READY || strategyContext.providerStatus === ClientProviderStatus.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;
+  }
+  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/status-tracker.ts
+var StatusTracker = class {
+  constructor(events) {
+    this.events = events;
+    this.providerStatuses = {};
+  }
+  wrapEventHandler(providerEntry) {
+    var _a, _b, _c, _d, _e;
+    const provider = providerEntry.provider;
+    (_a = provider.events) == null ? void 0 : _a.addHandler(ClientProviderEvents.Error, (details) => {
+      this.changeProviderStatus(providerEntry.name, ClientProviderStatus.ERROR, details);
+    });
+    (_b = provider.events) == null ? void 0 : _b.addHandler(ClientProviderEvents.Stale, (details) => {
+      this.changeProviderStatus(providerEntry.name, ClientProviderStatus.STALE, details);
+    });
+    (_c = provider.events) == null ? void 0 : _c.addHandler(ClientProviderEvents.ConfigurationChanged, (details) => {
+      this.events.emit(ClientProviderEvents.ConfigurationChanged, details);
+    });
+    (_d = provider.events) == null ? void 0 : _d.addHandler(ClientProviderEvents.Ready, (details) => {
+      this.changeProviderStatus(providerEntry.name, ClientProviderStatus.READY, details);
+    });
+    (_e = provider.events) == null ? void 0 : _e.addHandler(ClientProviderEvents.Reconciling, (details) => {
+      this.changeProviderStatus(providerEntry.name, ClientProviderStatus.RECONCILING, details);
+    });
+  }
+  providerStatus(name) {
+    return this.providerStatuses[name];
+  }
+  getStatusFromProviderStatuses() {
+    const statuses = Object.values(this.providerStatuses);
+    if (statuses.includes(ClientProviderStatus.FATAL)) {
+      return ClientProviderStatus.FATAL;
+    } else if (statuses.includes(ClientProviderStatus.NOT_READY)) {
+      return ClientProviderStatus.NOT_READY;
+    } else if (statuses.includes(ClientProviderStatus.ERROR)) {
+      return ClientProviderStatus.ERROR;
+    } else if (statuses.includes(ClientProviderStatus.STALE)) {
+      return ClientProviderStatus.STALE;
+    } else if (statuses.includes(ClientProviderStatus.RECONCILING)) {
+      return ClientProviderStatus.RECONCILING;
+    }
+    return ClientProviderStatus.READY;
+  }
+  changeProviderStatus(name, status, details) {
+    const currentStatus = this.getStatusFromProviderStatuses();
+    this.providerStatuses[name] = status;
+    const newStatus = this.getStatusFromProviderStatuses();
+    if (currentStatus !== newStatus) {
+      if (newStatus === ClientProviderStatus.FATAL || newStatus === ClientProviderStatus.ERROR) {
+        this.events.emit(ClientProviderEvents.Error, details);
+      } else if (newStatus === ClientProviderStatus.STALE) {
+        this.events.emit(ClientProviderEvents.Stale, details);
+      } else if (newStatus === ClientProviderStatus.READY) {
+        this.events.emit(ClientProviderEvents.Ready, details);
+      } else if (newStatus === ClientProviderStatus.RECONCILING) {
+        this.events.emit(ClientProviderEvents.Reconciling, details);
+      }
+    }
+  }
+};
+
+// src/provider/multi-provider/multi-provider-web.ts
+var MultiProvider = class _MultiProvider {
+  constructor(constructorProviders, evaluationStrategy = new FirstMatchStrategy(), logger = new DefaultLogger()) {
+    this.constructorProviders = constructorProviders;
+    this.evaluationStrategy = evaluationStrategy;
+    this.logger = logger;
+    this.runsOn = "client";
+    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);
+    });
+  }
+  onContextChange(oldContext, newContext) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      for (const providerEntry of this.providerEntries) {
+        yield (_b = (_a = providerEntry.provider).onContextChange) == null ? void 0 : _b.call(_a, oldContext, newContext);
+      }
+    });
+  }
+  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);
+  }
+  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
+          );
+        }
+      }
+    }
+  }
+  flagResolutionProxy(flagKey, flagType, defaultValue, context) {
+    var _a;
+    const hookContext = this.hookContexts.get(context);
+    const hookHints = this.hookHints.get(context);
+    if (!hookContext || !hookHints) {
+      throw new GeneralError4("Hook context not available for evaluation");
+    }
+    const results = [];
+    for (const providerEntry of this.providerEntries) {
+      const [shouldEvaluateNext, result] = this.evaluateProviderEntry(
+        flagKey,
+        flagType,
+        defaultValue,
+        providerEntry,
+        hookContext,
+        hookHints,
+        context
+      );
+      results.push(result);
+      if (!shouldEvaluateNext) {
+        break;
+      }
+    }
+    const resolutions = results.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 GeneralError4("No result was returned from any provider");
+    }
+    return finalResult.details;
+  }
+  evaluateProviderEntry(flagKey, flagType, defaultValue, providerEntry, hookContext, hookHints, context) {
+    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 = 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.shouldEvaluateNextProvider(strategyContext, context, resolution), resolution];
+  }
+  evaluateProviderAndHooks(flagKey, defaultValue, provider, hookContext, hookHints) {
+    var _a;
+    let evaluationDetails;
+    try {
+      this.hookExecutor.beforeHooks(provider.hooks, hookContext, hookHints);
+      const resolutionDetails = this.callProviderResolve(
+        provider,
+        flagKey,
+        defaultValue,
+        hookContext.context
+      );
+      evaluationDetails = __spreadProps(__spreadValues({}, resolutionDetails), {
+        flagMetadata: Object.freeze((_a = resolutionDetails.flagMetadata) != null ? _a : {}),
+        flagKey
+      });
+      this.hookExecutor.afterHooks(provider.hooks, hookContext, evaluationDetails, hookHints);
+    } catch (error) {
+      this.hookExecutor.errorHooks(provider.hooks, hookContext, error, hookHints);
+      evaluationDetails = this.getErrorEvaluationDetails(flagKey, defaultValue, error);
+    }
+    this.hookExecutor.finallyHooks(provider.hooks, hookContext, evaluationDetails, hookHints);
+    return evaluationDetails;
+  }
+  callProviderResolve(provider, flagKey, defaultValue, context) {
+    switch (typeof defaultValue) {
+      case "string":
+        return provider.resolveStringEvaluation(flagKey, defaultValue, context, this.logger);
+      case "number":
+        return provider.resolveNumberEvaluation(flagKey, defaultValue, context, this.logger);
+      case "object":
+        return provider.resolveObjectEvaluation(flagKey, defaultValue, context, this.logger);
+      case "boolean":
+        return provider.resolveBooleanEvaluation(flagKey, defaultValue, context, this.logger);
+      default:
+        throw new GeneralError4("Invalid flag evaluation type");
+    }
+  }
+  get hooks() {
+    return [
+      {
+        before: (hookContext, hints) => {
+          this.hookContexts.set(hookContext.context, hookContext);
+          this.hookHints.set(hookContext.context, hints != null ? hints : {});
+          return hookContext.context;
+        }
+      }
+    ];
+  }
+  getErrorEvaluationDetails(flagKey, defaultValue, err, flagMetadata = {}) {
+    const errorMessage = err == null ? void 0 : err.message;
+    const errorCode = (err == null ? void 0 : err.code) || ErrorCode3.GENERAL;
+    return {
+      errorCode,
+      errorMessage,
+      value: defaultValue,
+      reason: StandardResolutionReasons2.ERROR,
+      flagMetadata: Object.freeze(flagMetadata),
+      flagKey
+    };
+  }
+};
+
 // src/open-feature.ts
 import {
   OpenFeatureCommonAPI,
@@ -388,11 +897,11 @@ import {
 
 // src/client/internal/open-feature-client.ts
 import {
-  ErrorCode as ErrorCode2,
+  ErrorCode as ErrorCode4,
   ProviderFatalError,
   ProviderNotReadyError,
   SafeLogger,
-  StandardResolutionReasons as StandardResolutionReasons2,
+  StandardResolutionReasons as StandardResolutionReasons3,
   instantiateErrorByErrorCode,
   statusMatchesEvent,
   MapHookData
@@ -623,12 +1132,12 @@ var OpenFeatureClient = class {
   }
   getErrorEvaluationDetails(flagKey, defaultValue, err, flagMetadata = {}) {
     const errorMessage = err == null ? void 0 : err.message;
-    const errorCode = (err == null ? void 0 : err.code) || ErrorCode2.GENERAL;
+    const errorCode = (err == null ? void 0 : err.code) || ErrorCode4.GENERAL;
     return {
       errorCode,
       errorMessage,
       value: defaultValue,
-      reason: StandardResolutionReasons2.ERROR,
+      reason: StandardResolutionReasons3.ERROR,
       flagMetadata: Object.freeze(flagMetadata),
       flagKey
     };
@@ -859,12 +1368,21 @@ var OpenFeature = OpenFeatureAPI.getInstance();
 // src/index.ts
 export * from "@openfeature/core";
 export {
+  AggregateError,
+  BaseEvaluationStrategy,
+  ComparisonStrategy,
+  ErrorWithCode,
+  FirstMatchStrategy,
+  FirstSuccessfulStrategy,
   InMemoryProvider,
+  MultiProvider,
   NOOP_PROVIDER,
   OpenFeature,
   OpenFeatureAPI,
   OpenFeatureEventEmitter,
   ClientProviderEvents as ProviderEvents,
-  ClientProviderStatus as ProviderStatus
+  ClientProviderStatus as ProviderStatus,
+  constructAggregateError,
+  throwAggregateErrorFromPromiseResults
 };
 //# sourceMappingURL=index.js.map