@openfeature/web-sdk 0.4.12 → 0.4.14

package/dist/esm/index.js

@@ -399,7 +399,8 @@ var require_events = __commonJS({
 // src/client/open-feature-client.ts
 import {
   ErrorCode as ErrorCode2,
-  ProviderStatus as ProviderStatus3,
+  ProviderFatalError,
+  ProviderNotReadyError,
   SafeLogger,
   StandardResolutionReasons as StandardResolutionReasons2,
   statusMatchesEvent
@@ -408,6 +409,7 @@ import {
 // src/open-feature.ts
 import {
   OpenFeatureCommonAPI,
+  ProviderWrapper,
   objectOrUndefined,
   stringOrUndefined
 } from "@openfeature/core";
@@ -416,7 +418,7 @@ import {
 var import_events = __toESM(require_events());
 import { GenericEventEmitter } from "@openfeature/core";
 var OpenFeatureEventEmitter = class extends GenericEventEmitter {
-  eventEmitter = new import_events.default({ captureRejections: true });
+  eventEmitter = new import_events.EventEmitter({ captureRejections: true });
   constructor() {
     super();
     this.eventEmitter.on("error", (err) => {
@@ -428,16 +430,15 @@ var OpenFeatureEventEmitter = class extends GenericEventEmitter {
 // src/events/events.ts
 import { ClientProviderEvents } from "@openfeature/core";
 
+// src/provider/provider.ts
+import { ClientProviderStatus } from "@openfeature/core";
+
 // src/provider/no-op-provider.ts
-import { ProviderStatus } from "@openfeature/core";
 var REASON_NO_OP = "No-op";
 var NoopFeatureProvider = class {
   metadata = {
     name: "No-op Provider"
   };
-  get status() {
-    return ProviderStatus.NOT_READY;
-  }
   resolveBooleanEvaluation(_, defaultValue) {
     return this.noOp(defaultValue);
   }
@@ -465,17 +466,16 @@ import {
   GeneralError,
   OpenFeatureError as OpenFeatureError2,
   StandardResolutionReasons,
-  TypeMismatchError,
-  ProviderStatus as ProviderStatus2
+  TypeMismatchError
 } from "@openfeature/core";
 
 // src/provider/in-memory-provider/variant-not-found-error.ts
 import { ErrorCode, OpenFeatureError } from "@openfeature/core";
-var VariantNotFoundError = class extends OpenFeatureError {
+var VariantNotFoundError = class _VariantNotFoundError extends OpenFeatureError {
   code;
   constructor(message) {
     super(message);
-    Object.setPrototypeOf(this, VariantNotFoundError.prototype);
+    Object.setPrototypeOf(this, _VariantNotFoundError.prototype);
     this.name = "VariantNotFoundError";
     this.code = ErrorCode.GENERAL;
   }
@@ -485,7 +485,6 @@ var VariantNotFoundError = class extends OpenFeatureError {
 var InMemoryProvider = class {
   events = new OpenFeatureEventEmitter();
   runsOn = "client";
-  status = ProviderStatus2.NOT_READY;
   metadata = {
     name: "in-memory"
   };
@@ -500,10 +499,8 @@ var InMemoryProvider = class {
         this.resolveFlagWithReason(key, context);
       }
       this._context = context;
-      this.status = ProviderStatus2.READY;
-    } catch (error) {
-      this.status = ProviderStatus2.ERROR;
-      throw error;
+    } catch (err) {
+      throw new Error("initialization failure", { cause: err });
     }
   }
   /**
@@ -512,13 +509,10 @@ var InMemoryProvider = class {
    */
   async putConfiguration(flagConfiguration) {
     const flagsChanged = Object.entries(flagConfiguration).filter(([key, value]) => this._flagConfiguration[key] !== value).map(([key]) => key);
-    this.status = ProviderStatus2.STALE;
-    this.events.emit(ClientProviderEvents.Stale);
     this._flagConfiguration = { ...flagConfiguration };
-    this.events.emit(ClientProviderEvents.ConfigurationChanged, { flagsChanged });
     try {
       await this.initialize(this._context);
-      this.events.emit(ClientProviderEvents.Ready);
+      this.events.emit(ClientProviderEvents.ConfigurationChanged, { flagsChanged });
     } catch (err) {
       this.events.emit(ClientProviderEvents.Error);
       throw err;
@@ -572,8 +566,7 @@ var InMemoryProvider = class {
     const isContextEval = ctx && flagSpec?.contextEvaluator;
     const variant = isContextEval ? flagSpec.contextEvaluator?.(ctx) : flagSpec.defaultVariant;
     const value = variant && flagSpec?.variants[variant];
-    const evalReason = isContextEval ? StandardResolutionReasons.TARGETING_MATCH : StandardResolutionReasons.STATIC;
-    const reason = this.status === ProviderStatus2.STALE ? StandardResolutionReasons.CACHED : evalReason;
+    const reason = isContextEval ? StandardResolutionReasons.TARGETING_MATCH : StandardResolutionReasons.STATIC;
     return {
       value,
       ...variant && { variant },
@@ -585,11 +578,12 @@ var InMemoryProvider = class {
 // src/open-feature.ts
 var GLOBAL_OPENFEATURE_API_KEY = Symbol.for("@openfeature/web-sdk/api");
 var _globalThis = globalThis;
-var OpenFeatureAPI = class extends OpenFeatureCommonAPI {
-  _events = new OpenFeatureEventEmitter();
-  _defaultProvider = NOOP_PROVIDER;
+var OpenFeatureAPI = class _OpenFeatureAPI extends OpenFeatureCommonAPI {
+  _statusEnumType = ClientProviderStatus;
+  _apiEmitter = new OpenFeatureEventEmitter();
+  _defaultProvider = new ProviderWrapper(NOOP_PROVIDER, ClientProviderStatus.NOT_READY, this._statusEnumType);
+  _domainScopedProviders = /* @__PURE__ */ new Map();
   _createEventEmitter = () => new OpenFeatureEventEmitter();
-  _namedProviderContext = /* @__PURE__ */ new Map();
   constructor() {
     super("client");
   }
@@ -603,64 +597,70 @@ var OpenFeatureAPI = class extends OpenFeatureCommonAPI {
     if (globalApi) {
       return globalApi;
     }
-    const instance = new OpenFeatureAPI();
+    const instance = new _OpenFeatureAPI();
     _globalThis[GLOBAL_OPENFEATURE_API_KEY] = instance;
     return instance;
   }
-  async setContext(nameOrContext, contextOrUndefined) {
-    const clientName = stringOrUndefined(nameOrContext);
-    const context = objectOrUndefined(nameOrContext) ?? objectOrUndefined(contextOrUndefined) ?? {};
-    if (clientName) {
-      const provider = this._clientProviders.get(clientName);
-      if (provider) {
-        const oldContext = this.getContext(clientName);
-        this._namedProviderContext.set(clientName, context);
-        await this.runProviderContextChangeHandler(clientName, provider, oldContext, context);
+  getProviderStatus(domain) {
+    if (!domain) {
+      return this._defaultProvider.status;
+    }
+    return this._domainScopedProviders.get(domain)?.status ?? this._defaultProvider.status;
+  }
+  async setContext(domainOrContext, contextOrUndefined) {
+    const domain = stringOrUndefined(domainOrContext);
+    const context = objectOrUndefined(domainOrContext) ?? objectOrUndefined(contextOrUndefined) ?? {};
+    if (domain) {
+      const wrapper = this._domainScopedProviders.get(domain);
+      if (wrapper) {
+        const oldContext = this.getContext(domain);
+        this._domainScopedContext.set(domain, context);
+        await this.runProviderContextChangeHandler(domain, wrapper, oldContext, context);
       } else {
-        this._namedProviderContext.set(clientName, context);
+        this._domainScopedContext.set(domain, context);
       }
     } else {
       const oldContext = this._context;
       this._context = context;
-      const defaultContextNameProviders = Array.from(this._clientProviders.entries()).filter(([name]) => !this._namedProviderContext.has(name)).reduce((acc, [name, provider]) => {
-        acc.push({ name, provider });
+      const unboundProviders = Array.from(this._domainScopedProviders.entries()).filter(([domain2]) => !this._domainScopedContext.has(domain2)).reduce((acc, [domain2, wrapper]) => {
+        acc.push({ domain: domain2, wrapper });
         return acc;
       }, []);
-      const allProviders = [
-        // add in the default (no name)
-        { name: void 0, provider: this._defaultProvider },
-        ...defaultContextNameProviders
+      const allDomainRecords = [
+        // add in the default (no domain)
+        { domain: void 0, wrapper: this._defaultProvider },
+        ...unboundProviders
       ];
       await Promise.all(
-        allProviders.map(
-          (tuple) => this.runProviderContextChangeHandler(tuple.name, tuple.provider, oldContext, context)
+        allDomainRecords.map(
+          (dm) => this.runProviderContextChangeHandler(dm.domain, dm.wrapper, oldContext, context)
         )
       );
     }
   }
-  getContext(nameOrUndefined) {
-    const clientName = stringOrUndefined(nameOrUndefined);
-    if (clientName) {
-      const context = this._namedProviderContext.get(clientName);
+  getContext(domainOrUndefined) {
+    const domain = stringOrUndefined(domainOrUndefined);
+    if (domain) {
+      const context = this._domainScopedContext.get(domain);
       if (context) {
         return context;
       } else {
-        this._logger.debug(`Unable to find context for '${clientName}'.`);
+        this._logger.debug(`Unable to find context for '${domain}'.`);
       }
     }
     return this._context;
   }
-  async clearContext(nameOrUndefined) {
-    const clientName = stringOrUndefined(nameOrUndefined);
-    if (clientName) {
-      const provider = this._clientProviders.get(clientName);
-      if (provider) {
-        const oldContext = this.getContext(clientName);
-        this._namedProviderContext.delete(clientName);
+  async clearContext(domainOrUndefined) {
+    const domain = stringOrUndefined(domainOrUndefined);
+    if (domain) {
+      const wrapper = this._domainScopedProviders.get(domain);
+      if (wrapper) {
+        const oldContext = this.getContext(domain);
+        this._domainScopedContext.delete(domain);
         const newContext = this.getContext();
-        await this.runProviderContextChangeHandler(clientName, provider, oldContext, newContext);
+        await this.runProviderContextChangeHandler(domain, wrapper, oldContext, newContext);
       } else {
-        this._namedProviderContext.delete(clientName);
+        this._domainScopedContext.delete(domain);
       }
     } else {
       return this.setContext({});
@@ -668,11 +668,11 @@ var OpenFeatureAPI = class extends OpenFeatureCommonAPI {
   }
   /**
    * Resets the global evaluation context and removes the evaluation context for
-   * all named clients.
+   * all domains.
    */
   async clearContexts() {
     await this.clearContext();
-    await Promise.allSettled(Array.from(this._clientProviders.keys()).map((name) => this.clearContext(name)));
+    await Promise.allSettled(Array.from(this._domainScopedProviders.keys()).map((domain) => this.clearContext(domain)));
   }
   /**
    * A factory function for creating new named OpenFeature clients. Clients can contain
@@ -681,18 +681,19 @@ var OpenFeatureAPI = class extends OpenFeatureCommonAPI {
    *
    * If there is already a provider bound to this name via {@link this.setProvider setProvider}, this provider will be used.
    * Otherwise, the default provider is used until a provider is assigned to that name.
-   * @param {string} name The name of the client
+   * @param {string} domain An identifier which logically binds clients with providers
    * @param {string} version The version of the client (only used for metadata)
    * @returns {Client} OpenFeature Client
    */
-  getClient(name, version) {
+  getClient(domain, version) {
     return new OpenFeatureClient(
       // functions are passed here to make sure that these values are always up to date,
       // and so we don't have to make these public properties on the API class.
-      () => this.getProviderForClient(name),
-      () => this.buildAndCacheEventEmitterForClient(name),
+      () => this.getProviderForClient(domain),
+      () => this.getProviderStatus(domain),
+      () => this.buildAndCacheEventEmitterForClient(domain),
       () => this._logger,
-      { name, version }
+      { domain, version }
     );
   }
   /**
@@ -701,24 +702,40 @@ var OpenFeatureAPI = class extends OpenFeatureCommonAPI {
    */
   async clearProviders() {
     await super.clearProvidersAndSetDefault(NOOP_PROVIDER);
-    this._namedProviderContext.clear();
+    this._domainScopedContext.clear();
   }
-  async runProviderContextChangeHandler(clientName, provider, oldContext, newContext) {
-    const providerName = provider.metadata.name;
+  async runProviderContextChangeHandler(domain, wrapper, oldContext, newContext) {
+    const providerName = wrapper.provider?.metadata?.name || "unnamed-provider";
     try {
-      await provider.onContextChange?.(oldContext, newContext);
-      this.getAssociatedEventEmitters(clientName).forEach((emitter) => {
-        emitter?.emit(ClientProviderEvents.ContextChanged, { clientName, providerName });
-      });
-      this._events?.emit(ClientProviderEvents.ContextChanged, { clientName, providerName });
+      if (typeof wrapper.provider.onContextChange === "function") {
+        wrapper.incrementPendingContextChanges();
+        wrapper.status = this._statusEnumType.RECONCILING;
+        this.getAssociatedEventEmitters(domain).forEach((emitter) => {
+          emitter?.emit(ClientProviderEvents.Reconciling, { domain, providerName });
+        });
+        this._apiEmitter?.emit(ClientProviderEvents.Reconciling, { domain, providerName });
+        await wrapper.provider.onContextChange(oldContext, newContext);
+        wrapper.decrementPendingContextChanges();
+      }
+      wrapper.status = this._statusEnumType.READY;
+      if (wrapper.allContextChangesSettled) {
+        this.getAssociatedEventEmitters(domain).forEach((emitter) => {
+          emitter?.emit(ClientProviderEvents.ContextChanged, { clientName: domain, domain, providerName });
+        });
+        this._apiEmitter?.emit(ClientProviderEvents.ContextChanged, { clientName: domain, domain, providerName });
+      }
     } catch (err) {
-      const error = err;
-      const message = `Error running ${provider?.metadata?.name}'s context change handler: ${error?.message}`;
-      this._logger?.error(`${message}`, err);
-      this.getAssociatedEventEmitters(clientName).forEach((emitter) => {
-        emitter?.emit(ClientProviderEvents.Error, { clientName, providerName, message });
-      });
-      this._events?.emit(ClientProviderEvents.Error, { clientName, providerName, message });
+      wrapper.decrementPendingContextChanges();
+      wrapper.status = this._statusEnumType.ERROR;
+      if (wrapper.allContextChangesSettled) {
+        const error = err;
+        const message = `Error running ${providerName}'s context change handler: ${error?.message}`;
+        this._logger?.error(`${message}`, err);
+        this.getAssociatedEventEmitters(domain).forEach((emitter) => {
+          emitter?.emit(ClientProviderEvents.Error, { clientName: domain, domain, providerName, message });
+        });
+        this._apiEmitter?.emit(ClientProviderEvents.Error, { clientName: domain, domain, providerName, message });
+      }
     }
   }
 };
@@ -726,8 +743,9 @@ var OpenFeature = OpenFeatureAPI.getInstance();
 
 // src/client/open-feature-client.ts
 var OpenFeatureClient = class {
-  constructor(providerAccessor, emitterAccessor, globalLogger, options) {
+  constructor(providerAccessor, providerStatusAccessor, emitterAccessor, globalLogger, options) {
     this.providerAccessor = providerAccessor;
+    this.providerStatusAccessor = providerStatusAccessor;
     this.emitterAccessor = emitterAccessor;
     this.globalLogger = globalLogger;
     this.options = options;
@@ -736,20 +754,26 @@ var OpenFeatureClient = class {
   _clientLogger;
   get metadata() {
     return {
-      name: this.options.name,
+      // Use domain if name is not provided
+      name: this.options.domain ?? this.options.name,
+      domain: this.options.domain ?? this.options.name,
       version: this.options.version,
       providerMetadata: this.providerAccessor().metadata
     };
   }
   get providerStatus() {
-    return this.providerAccessor()?.status || ProviderStatus3.READY;
+    return this.providerStatusAccessor();
   }
   addHandler(eventType, handler) {
     this.emitterAccessor().addHandler(eventType, handler);
-    const shouldRunNow = statusMatchesEvent(eventType, this._provider.status);
+    const shouldRunNow = statusMatchesEvent(eventType, this.providerStatus);
     if (shouldRunNow) {
       try {
-        handler({ clientName: this.metadata.name, providerName: this._provider.metadata.name });
+        handler({
+          clientName: this.metadata.name,
+          domain: this.metadata.domain,
+          providerName: this._provider.metadata.name
+        });
       } catch (err) {
         this._logger?.error("Error running event handler:", err);
       }
@@ -823,7 +847,7 @@ var OpenFeatureClient = class {
     ];
     const allHooksReversed = [...allHooks].reverse();
     const context = {
-      ...OpenFeature.getContext(this?.options?.name)
+      ...OpenFeature.getContext(this?.options?.domain)
     };
     const hookContext = {
       flagKey,
@@ -836,6 +860,11 @@ var OpenFeatureClient = class {
     };
     try {
       this.beforeHooks(allHooks, hookContext, options);
+      if (this.providerStatus === ClientProviderStatus.NOT_READY) {
+        throw new ProviderNotReadyError("provider has not yet initialized");
+      } else if (this.providerStatus === ClientProviderStatus.FATAL) {
+        throw new ProviderFatalError("provider is in an irrecoverable error state");
+      }
       const resolution = resolver.call(this._provider, flagKey, defaultValue, context, this._logger);
       const evaluationDetails = {
         ...resolution,
@@ -915,6 +944,7 @@ export {
   OpenFeatureAPI,
   OpenFeatureClient,
   OpenFeatureEventEmitter,
-  ClientProviderEvents as ProviderEvents
+  ClientProviderEvents as ProviderEvents,
+  ClientProviderStatus as ProviderStatus
 };
 //# sourceMappingURL=index.js.map