@openfeature/ofrep-web-provider 0.3.1 → 0.3.3

package/index.cjs.js

@@ -1,12 +1,40 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var tslib = require('tslib');
-var core = require('@openfeature/core');
 var ofrepCore = require('@openfeature/ofrep-core');
 var webSdk = require('@openfeature/web-sdk');
 
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
 var BulkEvaluationStatus;
 (function (BulkEvaluationStatus) {
     BulkEvaluationStatus["SUCCESS_NO_CHANGES"] = "SUCCESS_NO_CHANGES";
@@ -20,6 +48,16 @@ function isResolutionError(response) {
     return 'reason' in response && 'errorCode' in response && !('value' in response);
 }
 
+const ErrorMessageMap = {
+    [webSdk.ErrorCode.FLAG_NOT_FOUND]: 'Flag was not found',
+    [webSdk.ErrorCode.GENERAL]: 'General error',
+    [webSdk.ErrorCode.INVALID_CONTEXT]: 'Context is invalid or could be parsed',
+    [webSdk.ErrorCode.PARSE_ERROR]: 'Flag or flag configuration could not be parsed',
+    [webSdk.ErrorCode.PROVIDER_FATAL]: 'Provider is in a fatal error state',
+    [webSdk.ErrorCode.PROVIDER_NOT_READY]: 'Provider is not yet ready',
+    [webSdk.ErrorCode.TARGETING_KEY_MISSING]: 'Targeting key is missing',
+    [webSdk.ErrorCode.TYPE_MISMATCH]: 'Flag is not of expected type',
+};
 class OFREPWebProvider {
     constructor(options, logger) {
         var _a;
@@ -30,6 +68,7 @@ class OFREPWebProvider {
         this.runsOn = 'client';
         this.events = new webSdk.OpenFeatureEventEmitter();
         this._flagCache = {};
+        this._flagSetMetadataCache = {};
         this._options = options;
         this._logger = logger;
         this._etag = null;
@@ -47,11 +86,11 @@ class OFREPWebProvider {
      * @param context - the context to use for the evaluation
      */
     initialize(context) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, void 0, void 0, function* () {
             var _a;
             try {
                 this._context = context;
-                yield this._evaluateFlags(context);
+                yield this._fetchFlags(context);
                 if (this._pollingInterval > 0) {
                     this.startPolling();
                 }
@@ -59,7 +98,7 @@ class OFREPWebProvider {
             }
             catch (error) {
                 if (error instanceof ofrepCore.OFREPApiUnauthorizedError || error instanceof ofrepCore.OFREPForbiddenError) {
-                    throw new webSdk.ProviderFatalError('Initialization failed', error);
+                    throw new webSdk.ProviderFatalError('Initialization failed', { cause: error });
                 }
                 throw error;
             }
@@ -68,18 +107,17 @@ class OFREPWebProvider {
     /* eslint-disable @typescript-eslint/no-unused-vars*/
     /* to make overrides easier we keep these unused vars */
     resolveBooleanEvaluation(flagKey, defaultValue, context) {
-        return this.evaluate(flagKey, 'boolean');
+        return this._resolve(flagKey, 'boolean', defaultValue);
     }
     resolveStringEvaluation(flagKey, defaultValue, context) {
-        return this.evaluate(flagKey, 'string');
+        return this._resolve(flagKey, 'string', defaultValue);
     }
     resolveNumberEvaluation(flagKey, defaultValue, context) {
-        return this.evaluate(flagKey, 'number');
+        return this._resolve(flagKey, 'number', defaultValue);
     }
     resolveObjectEvaluation(flagKey, defaultValue, context) {
-        return this.evaluate(flagKey, 'object');
+        return this._resolve(flagKey, 'object', defaultValue);
     }
-    /* eslint-enable @typescript-eslint/no-unused-vars */
     /**
      * onContextChange is called when the context changes, it will re-evaluate the flags with the new context
      * and update the cache.
@@ -87,7 +125,7 @@ class OFREPWebProvider {
      * @param newContext - the new evaluation context
      */
     onContextChange(oldContext, newContext) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c;
             try {
                 this._context = newContext;
@@ -96,7 +134,7 @@ class OFREPWebProvider {
                     // we do nothing because we should not call the endpoint
                     return;
                 }
-                yield this._evaluateFlags(newContext);
+                yield this._fetchFlags(newContext);
             }
             catch (error) {
                 if (error instanceof ofrepCore.OFREPApiTooManyRequestsError) {
@@ -122,7 +160,7 @@ class OFREPWebProvider {
         return Promise.resolve();
     }
     /**
-     * _evaluateFlags is a function that will call the bulk evaluate flags endpoint to get the flags values.
+     * _fetchFlags is a function that will call the bulk evaluate flags endpoint to get the flags values.
      * @param context - the context to use for the evaluation
      * @private
      * @returns EvaluationStatus if the evaluation the API returned a 304, 200.
@@ -131,9 +169,9 @@ class OFREPWebProvider {
      * @throws ParseError if the API returned a 400 with the error code ParseError
      * @throws GeneralError if the API returned a 400 with an unknown error code
      */
-    _evaluateFlags(context) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
+    _fetchFlags(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             try {
                 const evalReq = {
                     context,
@@ -144,31 +182,38 @@ class OFREPWebProvider {
                     return { status: BulkEvaluationStatus.SUCCESS_NO_CHANGES, flags: [] };
                 }
                 if (response.httpStatus !== 200) {
-                    ofrepCore.handleEvaluationError(response);
+                    throw new webSdk.GeneralError(`Failed OFREP bulk evaluation request, status: ${response.httpStatus}`);
                 }
                 const bulkSuccessResp = response.value;
                 const newCache = {};
-                (_a = bulkSuccessResp.flags) === null || _a === void 0 ? void 0 : _a.forEach((evalResp) => {
-                    if (ofrepCore.isEvaluationFailureResponse(evalResp)) {
-                        newCache[evalResp.key] = {
-                            errorCode: evalResp.errorCode,
-                            errorDetails: evalResp.errorDetails,
-                            reason: core.StandardResolutionReasons.ERROR,
-                        };
-                    }
-                    if (ofrepCore.isEvaluationSuccessResponse(evalResp) && evalResp.key) {
-                        newCache[evalResp.key] = {
-                            value: evalResp.value,
-                            flagMetadata: evalResp.metadata,
-                            reason: evalResp.reason,
-                            variant: evalResp.variant,
-                        };
-                    }
-                });
-                const listUpdatedFlags = this._getListUpdatedFlags(this._flagCache, newCache);
-                this._flagCache = newCache;
-                this._etag = (_b = response.httpResponse) === null || _b === void 0 ? void 0 : _b.headers.get('etag');
-                return { status: BulkEvaluationStatus.SUCCESS_WITH_CHANGES, flags: listUpdatedFlags };
+                if ('flags' in bulkSuccessResp && Array.isArray(bulkSuccessResp.flags)) {
+                    bulkSuccessResp.flags.forEach((evalResp) => {
+                        if (ofrepCore.isEvaluationFailureResponse(evalResp)) {
+                            newCache[evalResp.key] = {
+                                reason: webSdk.StandardResolutionReasons.ERROR,
+                                flagMetadata: evalResp.metadata,
+                                errorCode: evalResp.errorCode,
+                                errorDetails: evalResp.errorDetails,
+                            };
+                        }
+                        if (ofrepCore.isEvaluationSuccessResponse(evalResp) && evalResp.key) {
+                            newCache[evalResp.key] = {
+                                value: evalResp.value,
+                                variant: evalResp.variant,
+                                reason: evalResp.reason,
+                                flagMetadata: evalResp.metadata,
+                            };
+                        }
+                    });
+                    const listUpdatedFlags = this._getListUpdatedFlags(this._flagCache, newCache);
+                    this._flagCache = newCache;
+                    this._etag = (_a = response.httpResponse) === null || _a === void 0 ? void 0 : _a.headers.get('etag');
+                    this._flagSetMetadataCache = typeof bulkSuccessResp.metadata === 'object' ? bulkSuccessResp.metadata : {};
+                    return { status: BulkEvaluationStatus.SUCCESS_WITH_CHANGES, flags: listUpdatedFlags };
+                }
+                else {
+                    throw new Error('No flags in OFREP bulk evaluation response');
+                }
             }
             catch (error) {
                 if (error instanceof ofrepCore.OFREPApiTooManyRequestsError && error.retryAfterDate !== null) {
@@ -204,33 +249,34 @@ class OFREPWebProvider {
         return changedKeys;
     }
     /**
-     * Evaluate is a function retrieving the value from a flag in the cache.
+     * _resolve is a function retrieving the value from a flag in the cache.
      * @param flagKey - name of the flag to retrieve
      * @param type - type of the flag
+     * @param defaultValue - default value
      * @private
      */
-    evaluate(flagKey, type) {
+    _resolve(flagKey, type, defaultValue) {
         const resolved = this._flagCache[flagKey];
         if (!resolved) {
-            throw new webSdk.FlagNotFoundError(`flag key ${flagKey} not found in cache`);
+            return {
+                value: defaultValue,
+                flagMetadata: this._flagSetMetadataCache,
+                reason: webSdk.StandardResolutionReasons.ERROR,
+                errorCode: webSdk.ErrorCode.FLAG_NOT_FOUND,
+                errorMessage: ErrorMessageMap[webSdk.ErrorCode.FLAG_NOT_FOUND],
+            };
         }
         if (isResolutionError(resolved)) {
-            switch (resolved.errorCode) {
-                case ofrepCore.EvaluationFailureErrorCode.FlagNotFound:
-                    throw new webSdk.FlagNotFoundError(`flag key ${flagKey} not found: ${resolved.errorDetails}`);
-                case ofrepCore.EvaluationFailureErrorCode.TargetingKeyMissing:
-                    throw new core.TargetingKeyMissingError(`targeting key missing for flag key ${flagKey}: ${resolved.errorDetails}`);
-                case ofrepCore.EvaluationFailureErrorCode.InvalidContext:
-                    throw new core.InvalidContextError(`invalid context for flag key ${flagKey}: ${resolved.errorDetails}`);
-                case ofrepCore.EvaluationFailureErrorCode.ParseError:
-                    throw new core.ParseError(`parse error for flag key ${flagKey}: ${resolved.errorDetails}`);
-                case ofrepCore.EvaluationFailureErrorCode.General:
-                default:
-                    throw new webSdk.GeneralError(`general error during flag evaluation for flag key ${flagKey}: ${resolved.errorDetails}`);
-            }
+            return Object.assign(Object.assign({}, resolved), { value: defaultValue, errorMessage: ErrorMessageMap[resolved.errorCode] });
         }
         if (typeof resolved.value !== type) {
-            throw new webSdk.TypeMismatchError(`flag key ${flagKey} is not of type ${type}`);
+            return {
+                value: defaultValue,
+                flagMetadata: resolved.flagMetadata,
+                reason: webSdk.StandardResolutionReasons.ERROR,
+                errorCode: webSdk.ErrorCode.TYPE_MISMATCH,
+                errorMessage: ErrorMessageMap[webSdk.ErrorCode.TYPE_MISMATCH],
+            };
         }
         return {
             variant: resolved.variant,
@@ -246,14 +292,14 @@ class OFREPWebProvider {
      * @private
      */
     startPolling() {
-        this._pollingIntervalId = setInterval(() => tslib.__awaiter(this, void 0, void 0, function* () {
+        this._pollingIntervalId = setInterval(() => __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
             try {
                 const now = new Date();
                 if (this._retryPollingAfter !== undefined && this._retryPollingAfter > now) {
                     return;
                 }
-                const res = yield this._evaluateFlags(this._context);
+                const res = yield this._fetchFlags(this._context);
                 if (res.status === BulkEvaluationStatus.SUCCESS_WITH_CHANGES) {
                     (_a = this.events) === null || _a === void 0 ? void 0 : _a.emit(webSdk.ClientProviderEvents.ConfigurationChanged, {
                         message: 'Flags updated',

package/index.esm.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/index.esm.js

@@ -1,7 +1,37 @@
-import { __awaiter } from 'tslib';
-import { StandardResolutionReasons, ParseError, InvalidContextError, TargetingKeyMissingError } from '@openfeature/core';
-import { OFREPApi, OFREPApiUnauthorizedError, OFREPForbiddenError, OFREPApiTooManyRequestsError, OFREPApiFetchError, handleEvaluationError, isEvaluationFailureResponse, isEvaluationSuccessResponse, EvaluationFailureErrorCode } from '@openfeature/ofrep-core';
-import { OpenFeatureEventEmitter, ProviderFatalError, ClientProviderEvents, OpenFeatureError, FlagNotFoundError, GeneralError, TypeMismatchError } from '@openfeature/web-sdk';
+import { OFREPApi, OFREPApiUnauthorizedError, OFREPForbiddenError, OFREPApiTooManyRequestsError, OFREPApiFetchError, isEvaluationFailureResponse, isEvaluationSuccessResponse } from '@openfeature/ofrep-core';
+import { ErrorCode, OpenFeatureEventEmitter, StandardResolutionReasons, ProviderFatalError, ClientProviderEvents, OpenFeatureError, GeneralError } from '@openfeature/web-sdk';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
 
 var BulkEvaluationStatus;
 (function (BulkEvaluationStatus) {
@@ -16,6 +46,16 @@ function isResolutionError(response) {
     return 'reason' in response && 'errorCode' in response && !('value' in response);
 }
 
+const ErrorMessageMap = {
+    [ErrorCode.FLAG_NOT_FOUND]: 'Flag was not found',
+    [ErrorCode.GENERAL]: 'General error',
+    [ErrorCode.INVALID_CONTEXT]: 'Context is invalid or could be parsed',
+    [ErrorCode.PARSE_ERROR]: 'Flag or flag configuration could not be parsed',
+    [ErrorCode.PROVIDER_FATAL]: 'Provider is in a fatal error state',
+    [ErrorCode.PROVIDER_NOT_READY]: 'Provider is not yet ready',
+    [ErrorCode.TARGETING_KEY_MISSING]: 'Targeting key is missing',
+    [ErrorCode.TYPE_MISMATCH]: 'Flag is not of expected type',
+};
 class OFREPWebProvider {
     constructor(options, logger) {
         var _a;
@@ -26,6 +66,7 @@ class OFREPWebProvider {
         this.runsOn = 'client';
         this.events = new OpenFeatureEventEmitter();
         this._flagCache = {};
+        this._flagSetMetadataCache = {};
         this._options = options;
         this._logger = logger;
         this._etag = null;
@@ -47,7 +88,7 @@ class OFREPWebProvider {
             var _a;
             try {
                 this._context = context;
-                yield this._evaluateFlags(context);
+                yield this._fetchFlags(context);
                 if (this._pollingInterval > 0) {
                     this.startPolling();
                 }
@@ -55,7 +96,7 @@ class OFREPWebProvider {
             }
             catch (error) {
                 if (error instanceof OFREPApiUnauthorizedError || error instanceof OFREPForbiddenError) {
-                    throw new ProviderFatalError('Initialization failed', error);
+                    throw new ProviderFatalError('Initialization failed', { cause: error });
                 }
                 throw error;
             }
@@ -64,18 +105,17 @@ class OFREPWebProvider {
     /* eslint-disable @typescript-eslint/no-unused-vars*/
     /* to make overrides easier we keep these unused vars */
     resolveBooleanEvaluation(flagKey, defaultValue, context) {
-        return this.evaluate(flagKey, 'boolean');
+        return this._resolve(flagKey, 'boolean', defaultValue);
     }
     resolveStringEvaluation(flagKey, defaultValue, context) {
-        return this.evaluate(flagKey, 'string');
+        return this._resolve(flagKey, 'string', defaultValue);
     }
     resolveNumberEvaluation(flagKey, defaultValue, context) {
-        return this.evaluate(flagKey, 'number');
+        return this._resolve(flagKey, 'number', defaultValue);
     }
     resolveObjectEvaluation(flagKey, defaultValue, context) {
-        return this.evaluate(flagKey, 'object');
+        return this._resolve(flagKey, 'object', defaultValue);
     }
-    /* eslint-enable @typescript-eslint/no-unused-vars */
     /**
      * onContextChange is called when the context changes, it will re-evaluate the flags with the new context
      * and update the cache.
@@ -92,7 +132,7 @@ class OFREPWebProvider {
                     // we do nothing because we should not call the endpoint
                     return;
                 }
-                yield this._evaluateFlags(newContext);
+                yield this._fetchFlags(newContext);
             }
             catch (error) {
                 if (error instanceof OFREPApiTooManyRequestsError) {
@@ -118,7 +158,7 @@ class OFREPWebProvider {
         return Promise.resolve();
     }
     /**
-     * _evaluateFlags is a function that will call the bulk evaluate flags endpoint to get the flags values.
+     * _fetchFlags is a function that will call the bulk evaluate flags endpoint to get the flags values.
      * @param context - the context to use for the evaluation
      * @private
      * @returns EvaluationStatus if the evaluation the API returned a 304, 200.
@@ -127,9 +167,9 @@ class OFREPWebProvider {
      * @throws ParseError if the API returned a 400 with the error code ParseError
      * @throws GeneralError if the API returned a 400 with an unknown error code
      */
-    _evaluateFlags(context) {
+    _fetchFlags(context) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
+            var _a;
             try {
                 const evalReq = {
                     context,
@@ -140,31 +180,38 @@ class OFREPWebProvider {
                     return { status: BulkEvaluationStatus.SUCCESS_NO_CHANGES, flags: [] };
                 }
                 if (response.httpStatus !== 200) {
-                    handleEvaluationError(response);
+                    throw new GeneralError(`Failed OFREP bulk evaluation request, status: ${response.httpStatus}`);
                 }
                 const bulkSuccessResp = response.value;
                 const newCache = {};
-                (_a = bulkSuccessResp.flags) === null || _a === void 0 ? void 0 : _a.forEach((evalResp) => {
-                    if (isEvaluationFailureResponse(evalResp)) {
-                        newCache[evalResp.key] = {
-                            errorCode: evalResp.errorCode,
-                            errorDetails: evalResp.errorDetails,
-                            reason: StandardResolutionReasons.ERROR,
-                        };
-                    }
-                    if (isEvaluationSuccessResponse(evalResp) && evalResp.key) {
-                        newCache[evalResp.key] = {
-                            value: evalResp.value,
-                            flagMetadata: evalResp.metadata,
-                            reason: evalResp.reason,
-                            variant: evalResp.variant,
-                        };
-                    }
-                });
-                const listUpdatedFlags = this._getListUpdatedFlags(this._flagCache, newCache);
-                this._flagCache = newCache;
-                this._etag = (_b = response.httpResponse) === null || _b === void 0 ? void 0 : _b.headers.get('etag');
-                return { status: BulkEvaluationStatus.SUCCESS_WITH_CHANGES, flags: listUpdatedFlags };
+                if ('flags' in bulkSuccessResp && Array.isArray(bulkSuccessResp.flags)) {
+                    bulkSuccessResp.flags.forEach((evalResp) => {
+                        if (isEvaluationFailureResponse(evalResp)) {
+                            newCache[evalResp.key] = {
+                                reason: StandardResolutionReasons.ERROR,
+                                flagMetadata: evalResp.metadata,
+                                errorCode: evalResp.errorCode,
+                                errorDetails: evalResp.errorDetails,
+                            };
+                        }
+                        if (isEvaluationSuccessResponse(evalResp) && evalResp.key) {
+                            newCache[evalResp.key] = {
+                                value: evalResp.value,
+                                variant: evalResp.variant,
+                                reason: evalResp.reason,
+                                flagMetadata: evalResp.metadata,
+                            };
+                        }
+                    });
+                    const listUpdatedFlags = this._getListUpdatedFlags(this._flagCache, newCache);
+                    this._flagCache = newCache;
+                    this._etag = (_a = response.httpResponse) === null || _a === void 0 ? void 0 : _a.headers.get('etag');
+                    this._flagSetMetadataCache = typeof bulkSuccessResp.metadata === 'object' ? bulkSuccessResp.metadata : {};
+                    return { status: BulkEvaluationStatus.SUCCESS_WITH_CHANGES, flags: listUpdatedFlags };
+                }
+                else {
+                    throw new Error('No flags in OFREP bulk evaluation response');
+                }
             }
             catch (error) {
                 if (error instanceof OFREPApiTooManyRequestsError && error.retryAfterDate !== null) {
@@ -200,33 +247,34 @@ class OFREPWebProvider {
         return changedKeys;
     }
     /**
-     * Evaluate is a function retrieving the value from a flag in the cache.
+     * _resolve is a function retrieving the value from a flag in the cache.
      * @param flagKey - name of the flag to retrieve
      * @param type - type of the flag
+     * @param defaultValue - default value
      * @private
      */
-    evaluate(flagKey, type) {
+    _resolve(flagKey, type, defaultValue) {
         const resolved = this._flagCache[flagKey];
         if (!resolved) {
-            throw new FlagNotFoundError(`flag key ${flagKey} not found in cache`);
+            return {
+                value: defaultValue,
+                flagMetadata: this._flagSetMetadataCache,
+                reason: StandardResolutionReasons.ERROR,
+                errorCode: ErrorCode.FLAG_NOT_FOUND,
+                errorMessage: ErrorMessageMap[ErrorCode.FLAG_NOT_FOUND],
+            };
         }
         if (isResolutionError(resolved)) {
-            switch (resolved.errorCode) {
-                case EvaluationFailureErrorCode.FlagNotFound:
-                    throw new FlagNotFoundError(`flag key ${flagKey} not found: ${resolved.errorDetails}`);
-                case EvaluationFailureErrorCode.TargetingKeyMissing:
-                    throw new TargetingKeyMissingError(`targeting key missing for flag key ${flagKey}: ${resolved.errorDetails}`);
-                case EvaluationFailureErrorCode.InvalidContext:
-                    throw new InvalidContextError(`invalid context for flag key ${flagKey}: ${resolved.errorDetails}`);
-                case EvaluationFailureErrorCode.ParseError:
-                    throw new ParseError(`parse error for flag key ${flagKey}: ${resolved.errorDetails}`);
-                case EvaluationFailureErrorCode.General:
-                default:
-                    throw new GeneralError(`general error during flag evaluation for flag key ${flagKey}: ${resolved.errorDetails}`);
-            }
+            return Object.assign(Object.assign({}, resolved), { value: defaultValue, errorMessage: ErrorMessageMap[resolved.errorCode] });
         }
         if (typeof resolved.value !== type) {
-            throw new TypeMismatchError(`flag key ${flagKey} is not of type ${type}`);
+            return {
+                value: defaultValue,
+                flagMetadata: resolved.flagMetadata,
+                reason: StandardResolutionReasons.ERROR,
+                errorCode: ErrorCode.TYPE_MISMATCH,
+                errorMessage: ErrorMessageMap[ErrorCode.TYPE_MISMATCH],
+            };
         }
         return {
             variant: resolved.variant,
@@ -249,7 +297,7 @@ class OFREPWebProvider {
                 if (this._retryPollingAfter !== undefined && this._retryPollingAfter > now) {
                     return;
                 }
-                const res = yield this._evaluateFlags(this._context);
+                const res = yield this._fetchFlags(this._context);
                 if (res.status === BulkEvaluationStatus.SUCCESS_WITH_CHANGES) {
                     (_a = this.events) === null || _a === void 0 ? void 0 : _a.emit(ClientProviderEvents.ConfigurationChanged, {
                         message: 'Flags updated',

package/package.json

@@ -1,10 +1,7 @@
 {
   "name": "@openfeature/ofrep-web-provider",
-  "version": "0.3.1",
-  "dependencies": {
-    "tslib": "^2.3.0",
-    "@openfeature/ofrep-core": "0.2.0"
-  },
+  "version": "0.3.3",
+  "license": "Apache-2.0",
   "main": "./index.cjs.js",
   "typings": "./src/index.d.ts",
   "scripts": {
@@ -12,15 +9,20 @@
     "current-version": "echo $npm_package_version"
   },
   "peerDependencies": {
-    "@openfeature/web-sdk": ">=0.4.0"
+    "@openfeature/web-sdk": "^1.4.0"
+  },
+  "dependencies": {
+    "@openfeature/ofrep-core": "^1.0.0"
   },
   "exports": {
     "./package.json": "./package.json",
     ".": {
       "module": "./index.esm.js",
+      "types": "./index.esm.d.ts",
       "import": "./index.cjs.mjs",
       "default": "./index.cjs.js"
     }
   },
-  "module": "./index.esm.js"
-}
+  "module": "./index.esm.js",
+  "types": "./index.esm.d.ts"
+}

package/src/lib/model/in-memory-cache.d.ts

@@ -1,8 +1,12 @@
-import { FlagValue, ResolutionDetails } from '@openfeature/web-sdk';
-import { ResolutionError } from './resolution-error';
+import type { FlagMetadata, FlagValue, ResolutionDetails } from '@openfeature/web-sdk';
+import type { ResolutionError } from './resolution-error';
 /**
- * FlagCache is a type representing the internal cache of the flags.
+ * Cache of flag values from bulk evaluation.
  */
 export type FlagCache = {
     [key: string]: ResolutionDetails<FlagValue> | ResolutionError;
 };
+/**
+ * Cache of metadata from bulk evaluation.
+ */
+export type MetadataCache = FlagMetadata;

package/src/lib/model/ofrep-web-provider-options.d.ts

@@ -1,4 +1,4 @@
-import { OFREPProviderBaseOptions } from '@openfeature/ofrep-core';
+import type { OFREPProviderBaseOptions } from '@openfeature/ofrep-core';
 export type OFREPWebProviderOptions = OFREPProviderBaseOptions & {
     /**
      * pollInterval is the time in milliseconds to wait between we call the OFREP

package/src/lib/model/resolution-error.d.ts

@@ -1,8 +1,7 @@
-import { ResolutionReason } from '@openfeature/web-sdk';
-import { EvaluationFailureErrorCode } from '@openfeature/ofrep-core';
+import type { ErrorCode, ResolutionReason } from '@openfeature/web-sdk';
 export type ResolutionError = {
     reason: ResolutionReason;
-    errorCode: EvaluationFailureErrorCode;
+    errorCode: ErrorCode;
     errorDetails?: string;
 };
 export declare function isResolutionError(response: unknown): response is ResolutionError;

package/src/lib/ofrep-web-provider.d.ts

@@ -1,6 +1,7 @@
-import { EvaluationContext, Hook, JsonValue, Logger, OpenFeatureEventEmitter, Provider, ResolutionDetails } from '@openfeature/web-sdk';
-import { FlagCache } from './model/in-memory-cache';
-import { OFREPWebProviderOptions } from './model/ofrep-web-provider-options';
+import type { EvaluationContext, Hook, JsonValue, Logger, Provider, ResolutionDetails } from '@openfeature/web-sdk';
+import { OpenFeatureEventEmitter } from '@openfeature/web-sdk';
+import type { FlagCache } from './model/in-memory-cache';
+import type { OFREPWebProviderOptions } from './model/ofrep-web-provider-options';
 export declare class OFREPWebProvider implements Provider {
     DEFAULT_POLL_INTERVAL: number;
     readonly metadata: {
@@ -16,6 +17,7 @@ export declare class OFREPWebProvider implements Provider {
     private _pollingInterval;
     private _retryPollingAfter;
     private _flagCache;
+    private _flagSetMetadataCache;
     private _context;
     private _pollingIntervalId?;
     constructor(options: OFREPWebProviderOptions, logger?: Logger);
@@ -44,7 +46,7 @@ export declare class OFREPWebProvider implements Provider {
      */
     onClose?(): Promise<void>;
     /**
-     * _evaluateFlags is a function that will call the bulk evaluate flags endpoint to get the flags values.
+     * _fetchFlags is a function that will call the bulk evaluate flags endpoint to get the flags values.
      * @param context - the context to use for the evaluation
      * @private
      * @returns EvaluationStatus if the evaluation the API returned a 304, 200.
@@ -53,7 +55,7 @@ export declare class OFREPWebProvider implements Provider {
      * @throws ParseError if the API returned a 400 with the error code ParseError
      * @throws GeneralError if the API returned a 400 with an unknown error code
      */
-    private _evaluateFlags;
+    private _fetchFlags;
     /**
      * _getListUpdatedFlags is a function that will compare the old cache with the new cache and
      * return the list of flags that have been updated / deleted / created.
@@ -63,12 +65,13 @@ export declare class OFREPWebProvider implements Provider {
      */
     private _getListUpdatedFlags;
     /**
-     * Evaluate is a function retrieving the value from a flag in the cache.
+     * _resolve is a function retrieving the value from a flag in the cache.
      * @param flagKey - name of the flag to retrieve
      * @param type - type of the flag
+     * @param defaultValue - default value
      * @private
      */
-    private evaluate;
+    private _resolve;
     /**
      * Start polling for flag updates, it will call the bulk update function every pollInterval
      * @private