@openfeature/flagd-provider 0.9.0 → 0.10.0

package/index.esm.js

@@ -1,10 +1,10 @@
 import { GeneralError, FlagNotFoundError, TypeMismatchError, ParseError, StandardResolutionReasons, ProviderStatus, OpenFeatureEventEmitter, ProviderEvents } from '@openfeature/server-sdk';
 import { makeGenericClientConstructor, status, credentials } from '@grpc/grpc-js';
+import { ConnectivityState } from '@grpc/grpc-js/build/src/connectivity-state';
 import { LRUCache } from 'lru-cache';
 import { promisify } from 'util';
+import { FlagdCore } from '@openfeature/flagd-core';
 
-const BASE_EVENT_STREAM_RETRY_BACKOFF_MS = 1000;
-const DEFAULT_MAX_EVENT_STREAM_RETRIES = 5;
 const EVENT_CONFIGURATION_CHANGE = 'configuration_change';
 const EVENT_PROVIDER_READY = 'provider_ready';
 const DEFAULT_MAX_CACHE_SIZE = 1000;
@@ -13,9 +13,10 @@ const DEFAULT_CONFIG = {
     host: 'localhost',
     port: 8013,
     tls: false,
+    resolverType: 'rpc',
+    selector: '',
     cache: 'lru',
     maxCacheSize: DEFAULT_MAX_CACHE_SIZE,
-    maxEventStreamRetries: DEFAULT_MAX_EVENT_STREAM_RETRIES,
 };
 var ENV_VAR;
 (function (ENV_VAR) {
@@ -25,11 +26,12 @@ var ENV_VAR;
     ENV_VAR["FLAGD_SOCKET_PATH"] = "FLAGD_SOCKET_PATH";
     ENV_VAR["FLAGD_CACHE"] = "FLAGD_CACHE";
     ENV_VAR["FLAGD_MAX_CACHE_SIZE"] = "FLAGD_MAX_CACHE_SIZE";
-    ENV_VAR["FLAGD_MAX_EVENT_STREAM_RETRIES"] = "FLAGD_MAX_EVENT_STREAM_RETRIES";
+    ENV_VAR["FLAGD_SOURCE_SELECTOR"] = "FLAGD_SOURCE_SELECTOR";
+    ENV_VAR["FLAGD_RESOLVER"] = "FLAGD_RESOLVER";
 })(ENV_VAR || (ENV_VAR = {}));
 const getEnvVarConfig = () => {
     var _a;
-    return (Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (process.env[ENV_VAR.FLAGD_HOST] && {
+    return (Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (process.env[ENV_VAR.FLAGD_HOST] && {
         host: process.env[ENV_VAR.FLAGD_HOST],
     })), (Number(process.env[ENV_VAR.FLAGD_PORT]) && {
         port: Number(process.env[ENV_VAR.FLAGD_PORT]),
@@ -41,8 +43,10 @@ const getEnvVarConfig = () => {
         cache: process.env[ENV_VAR.FLAGD_CACHE],
     })), (process.env[ENV_VAR.FLAGD_MAX_CACHE_SIZE] && {
         maxCacheSize: Number(process.env[ENV_VAR.FLAGD_MAX_CACHE_SIZE]),
-    })), (process.env[ENV_VAR.FLAGD_MAX_EVENT_STREAM_RETRIES] && {
-        maxEventStreamRetries: Number(process.env[ENV_VAR.FLAGD_MAX_EVENT_STREAM_RETRIES]),
+    })), (process.env[ENV_VAR.FLAGD_SOURCE_SELECTOR] && {
+        selector: process.env[ENV_VAR.FLAGD_SOURCE_SELECTOR],
+    })), ((process.env[ENV_VAR.FLAGD_RESOLVER] === 'rpc' || process.env[ENV_VAR.FLAGD_RESOLVER] === 'in-process') && {
+        resolverType: process.env[ENV_VAR.FLAGD_RESOLVER],
     })));
 };
 function getConfig(options = {}) {
@@ -4074,7 +4078,7 @@ var minimal = indexMinimal;
  * `NullValue` is a singleton enumeration to represent the null value for the
  * `Value` type union.
  *
- *  The JSON representation for `NullValue` is JSON `null`.
+ * The JSON representation for `NullValue` is JSON `null`.
  */
 var NullValue;
 (function (NullValue) {
@@ -4235,7 +4239,7 @@ const Struct_FieldsEntry = {
         return message;
     },
     fromJSON(object) {
-        return { key: isSet$1(object.key) ? String(object.key) : "", value: isSet$1(object === null || object === void 0 ? void 0 : object.value) ? object.value : undefined };
+        return { key: isSet$2(object.key) ? String(object.key) : "", value: isSet$2(object === null || object === void 0 ? void 0 : object.value) ? object.value : undefined };
     },
     toJSON(message) {
         const obj = {};
@@ -4343,10 +4347,10 @@ const Value = {
     },
     fromJSON(object) {
         return {
-            nullValue: isSet$1(object.nullValue) ? nullValueFromJSON(object.nullValue) : undefined,
-            numberValue: isSet$1(object.numberValue) ? Number(object.numberValue) : undefined,
-            stringValue: isSet$1(object.stringValue) ? String(object.stringValue) : undefined,
-            boolValue: isSet$1(object.boolValue) ? Boolean(object.boolValue) : undefined,
+            nullValue: isSet$2(object.nullValue) ? nullValueFromJSON(object.nullValue) : undefined,
+            numberValue: isSet$2(object.numberValue) ? Number(object.numberValue) : undefined,
+            stringValue: isSet$2(object.stringValue) ? String(object.stringValue) : undefined,
+            boolValue: isSet$2(object.boolValue) ? Boolean(object.boolValue) : undefined,
             structValue: isObject$1(object.structValue) ? object.structValue : undefined,
             listValue: Array.isArray(object.listValue) ? [...object.listValue] : undefined,
         };
@@ -4502,7 +4506,7 @@ const ListValue = {
 function isObject$1(value) {
     return typeof value === "object" && value !== null;
 }
-function isSet$1(value) {
+function isSet$2(value) {
     return value !== null && value !== undefined;
 }
 
@@ -4672,8 +4676,8 @@ const ResolveAllResponse_FlagsEntry = {
     },
     fromJSON(object) {
         return {
-            key: isSet(object.key) ? String(object.key) : "",
-            value: isSet(object.value) ? AnyFlag.fromJSON(object.value) : undefined,
+            key: isSet$1(object.key) ? String(object.key) : "",
+            value: isSet$1(object.value) ? AnyFlag.fromJSON(object.value) : undefined,
         };
     },
     toJSON(message) {
@@ -4784,11 +4788,11 @@ const AnyFlag = {
     },
     fromJSON(object) {
         return {
-            reason: isSet(object.reason) ? String(object.reason) : "",
-            variant: isSet(object.variant) ? String(object.variant) : "",
-            boolValue: isSet(object.boolValue) ? Boolean(object.boolValue) : undefined,
-            stringValue: isSet(object.stringValue) ? String(object.stringValue) : undefined,
-            doubleValue: isSet(object.doubleValue) ? Number(object.doubleValue) : undefined,
+            reason: isSet$1(object.reason) ? String(object.reason) : "",
+            variant: isSet$1(object.variant) ? String(object.variant) : "",
+            boolValue: isSet$1(object.boolValue) ? Boolean(object.boolValue) : undefined,
+            stringValue: isSet$1(object.stringValue) ? String(object.stringValue) : undefined,
+            doubleValue: isSet$1(object.doubleValue) ? Number(object.doubleValue) : undefined,
             objectValue: isObject(object.objectValue) ? object.objectValue : undefined,
         };
     },
@@ -4871,7 +4875,7 @@ const ResolveBooleanRequest = {
     },
     fromJSON(object) {
         return {
-            flagKey: isSet(object.flagKey) ? String(object.flagKey) : "",
+            flagKey: isSet$1(object.flagKey) ? String(object.flagKey) : "",
             context: isObject(object.context) ? object.context : undefined,
         };
     },
@@ -4956,9 +4960,9 @@ const ResolveBooleanResponse = {
     },
     fromJSON(object) {
         return {
-            value: isSet(object.value) ? Boolean(object.value) : false,
-            reason: isSet(object.reason) ? String(object.reason) : "",
-            variant: isSet(object.variant) ? String(object.variant) : "",
+            value: isSet$1(object.value) ? Boolean(object.value) : false,
+            reason: isSet$1(object.reason) ? String(object.reason) : "",
+            variant: isSet$1(object.variant) ? String(object.variant) : "",
             metadata: isObject(object.metadata) ? object.metadata : undefined,
         };
     },
@@ -5033,7 +5037,7 @@ const ResolveStringRequest = {
     },
     fromJSON(object) {
         return {
-            flagKey: isSet(object.flagKey) ? String(object.flagKey) : "",
+            flagKey: isSet$1(object.flagKey) ? String(object.flagKey) : "",
             context: isObject(object.context) ? object.context : undefined,
         };
     },
@@ -5118,9 +5122,9 @@ const ResolveStringResponse = {
     },
     fromJSON(object) {
         return {
-            value: isSet(object.value) ? String(object.value) : "",
-            reason: isSet(object.reason) ? String(object.reason) : "",
-            variant: isSet(object.variant) ? String(object.variant) : "",
+            value: isSet$1(object.value) ? String(object.value) : "",
+            reason: isSet$1(object.reason) ? String(object.reason) : "",
+            variant: isSet$1(object.variant) ? String(object.variant) : "",
             metadata: isObject(object.metadata) ? object.metadata : undefined,
         };
     },
@@ -5195,7 +5199,7 @@ const ResolveFloatRequest = {
     },
     fromJSON(object) {
         return {
-            flagKey: isSet(object.flagKey) ? String(object.flagKey) : "",
+            flagKey: isSet$1(object.flagKey) ? String(object.flagKey) : "",
             context: isObject(object.context) ? object.context : undefined,
         };
     },
@@ -5280,9 +5284,9 @@ const ResolveFloatResponse = {
     },
     fromJSON(object) {
         return {
-            value: isSet(object.value) ? Number(object.value) : 0,
-            reason: isSet(object.reason) ? String(object.reason) : "",
-            variant: isSet(object.variant) ? String(object.variant) : "",
+            value: isSet$1(object.value) ? Number(object.value) : 0,
+            reason: isSet$1(object.reason) ? String(object.reason) : "",
+            variant: isSet$1(object.variant) ? String(object.variant) : "",
             metadata: isObject(object.metadata) ? object.metadata : undefined,
         };
     },
@@ -5357,7 +5361,7 @@ const ResolveIntRequest = {
     },
     fromJSON(object) {
         return {
-            flagKey: isSet(object.flagKey) ? String(object.flagKey) : "",
+            flagKey: isSet$1(object.flagKey) ? String(object.flagKey) : "",
             context: isObject(object.context) ? object.context : undefined,
         };
     },
@@ -5442,9 +5446,9 @@ const ResolveIntResponse = {
     },
     fromJSON(object) {
         return {
-            value: isSet(object.value) ? String(object.value) : "0",
-            reason: isSet(object.reason) ? String(object.reason) : "",
-            variant: isSet(object.variant) ? String(object.variant) : "",
+            value: isSet$1(object.value) ? String(object.value) : "0",
+            reason: isSet$1(object.reason) ? String(object.reason) : "",
+            variant: isSet$1(object.variant) ? String(object.variant) : "",
             metadata: isObject(object.metadata) ? object.metadata : undefined,
         };
     },
@@ -5519,7 +5523,7 @@ const ResolveObjectRequest = {
     },
     fromJSON(object) {
         return {
-            flagKey: isSet(object.flagKey) ? String(object.flagKey) : "",
+            flagKey: isSet$1(object.flagKey) ? String(object.flagKey) : "",
             context: isObject(object.context) ? object.context : undefined,
         };
     },
@@ -5605,8 +5609,8 @@ const ResolveObjectResponse = {
     fromJSON(object) {
         return {
             value: isObject(object.value) ? object.value : undefined,
-            reason: isSet(object.reason) ? String(object.reason) : "",
-            variant: isSet(object.variant) ? String(object.variant) : "",
+            reason: isSet$1(object.reason) ? String(object.reason) : "",
+            variant: isSet$1(object.variant) ? String(object.variant) : "",
             metadata: isObject(object.metadata) ? object.metadata : undefined,
         };
     },
@@ -5681,7 +5685,7 @@ const EventStreamResponse = {
     },
     fromJSON(object) {
         return {
-            type: isSet(object.type) ? String(object.type) : "",
+            type: isSet$1(object.type) ? String(object.type) : "",
             data: isObject(object.data) ? object.data : undefined,
         };
     },
@@ -5817,23 +5821,19 @@ if (minimal.util.Long !== long) {
 function isObject(value) {
     return typeof value === "object" && value !== null;
 }
-function isSet(value) {
+function isSet$1(value) {
     return value !== null && value !== undefined;
 }
 
 class GRPCService {
     get _cacheActive() {
         // the cache is "active" (able to be used) if the config enabled it, AND the gRPC stream is live
-        return this._cacheEnabled && this._streamAlive;
+        return this._cacheEnabled && this._client.getChannel().getConnectivityState(false) === ConnectivityState.READY;
     }
     constructor(config, client, logger) {
-        var _a;
         this.logger = logger;
         this._cacheEnabled = false;
-        this._streamAlive = false;
-        this._streamConnectAttempt = 0;
-        this._stream = undefined;
-        this._streamConnectBackoff = BASE_EVENT_STREAM_RETRY_BACKOFF_MS;
+        this._eventStream = undefined;
         this.onRejected = (err) => {
             // map the errors
             switch (err === null || err === void 0 ? void 0 : err.code) {
@@ -5850,7 +5850,6 @@ class GRPCService {
             }
         };
         const { host, port, tls, socketPath } = config;
-        this._maxEventStreamRetries = (_a = config.maxEventStreamRetries) !== null && _a !== void 0 ? _a : DEFAULT_MAX_EVENT_STREAM_RETRIES;
         this._client = client
             ? client
             : new ServiceClient(socketPath ? `unix://${socketPath}` : `${host}:${port}`, tls ? credentials.createSsl() : credentials.createInsecure());
@@ -5859,73 +5858,62 @@ class GRPCService {
             this._cache = new LRUCache({ maxSize: config.maxCacheSize || DEFAULT_MAX_CACHE_SIZE, sizeCalculation: () => 1 });
         }
     }
-    connect(connectCallback, changedCallback, disconnectCallback) {
-        return this.connectStream(connectCallback, changedCallback, disconnectCallback);
+    connect(reconnectCallback, changedCallback, disconnectCallback) {
+        return new Promise((resolve, reject) => this.listen(reconnectCallback, changedCallback, disconnectCallback, resolve, reject));
     }
     disconnect() {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             // cancel the stream and close the connection
-            (_a = this._stream) === null || _a === void 0 ? void 0 : _a.cancel();
+            (_a = this._eventStream) === null || _a === void 0 ? void 0 : _a.cancel();
             this._client.close();
         });
     }
-    resolveBoolean(flagKey, context, logger) {
+    resolveBoolean(flagKey, _, context, logger) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.resolve(this._client.resolveBoolean, flagKey, context, logger);
         });
     }
-    resolveString(flagKey, context, logger) {
+    resolveString(flagKey, _, context, logger) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.resolve(this._client.resolveString, flagKey, context, logger);
         });
     }
-    resolveNumber(flagKey, context, logger) {
+    resolveNumber(flagKey, _, context, logger) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.resolve(this._client.resolveFloat, flagKey, context, logger);
         });
     }
-    resolveObject(flagKey, context, logger) {
+    resolveObject(flagKey, _, context, logger) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.resolve(this._client.resolveObject, flagKey, context, logger);
         });
     }
-    connectStream(connectCallback, changedCallback, disconnectCallback) {
-        return new Promise((resolve, reject) => {
+    listen(reconnectCallback, changedCallback, disconnectCallback, resolveConnect, rejectConnect) {
+        var _a;
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(`${FlagdProvider.name}: connecting stream...`);
+        const stream = this._client.eventStream({}, {});
+        stream.on('error', (err) => {
+            rejectConnect === null || rejectConnect === void 0 ? void 0 : rejectConnect(err);
+            this.handleError(reconnectCallback, changedCallback, disconnectCallback);
+        });
+        stream.on('data', (message) => {
             var _a;
-            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(`${FlagdProvider.name}: connecting stream, attempt ${this._streamConnectAttempt}...`);
-            const stream = this._client.eventStream({}, {});
-            stream.on('error', (err) => {
-                var _a;
-                if ((err === null || err === void 0 ? void 0 : err.code) === status.CANCELLED) {
-                    (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(`${FlagdProvider.name}: stream cancelled, will not be re-established`);
+            if (message.type === EVENT_PROVIDER_READY) {
+                (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(`${FlagdProvider.name}: streaming connection established with flagd`);
+                // if resolveConnect is undefined, this is a reconnection; we only want to fire the reconnect callback in that case
+                if (resolveConnect) {
+                    resolveConnect();
                 }
                 else {
-                    this.handleError(reject, connectCallback, changedCallback, disconnectCallback);
-                }
-            });
-            stream.on('close', () => {
-                this.handleClose();
-            });
-            stream.on('data', (message) => {
-                if (message.type === EVENT_PROVIDER_READY) {
-                    this.handleProviderReady(resolve, connectCallback);
-                }
-                else if (message.type === EVENT_CONFIGURATION_CHANGE) {
-                    this.handleFlagsChanged(message, changedCallback);
+                    reconnectCallback();
                 }
-            });
-            this._stream = stream;
+            }
+            else if (message.type === EVENT_CONFIGURATION_CHANGE) {
+                this.handleFlagsChanged(message, changedCallback);
+            }
         });
-    }
-    handleProviderReady(resolve, connectCallback) {
-        var _a;
-        connectCallback();
-        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.info(`${FlagdProvider.name}: streaming connection established with flagd`);
-        this._streamAlive = true;
-        this._streamConnectAttempt = 0;
-        this._streamConnectBackoff = BASE_EVENT_STREAM_RETRY_BACKOFF_MS;
-        resolve();
+        this._eventStream = stream;
     }
     handleFlagsChanged(message, changedCallback) {
         var _a;
@@ -5946,34 +5934,18 @@ class GRPCService {
             }
         }
     }
-    handleError(reject, connectCallback, changedCallback, disconnectCallback) {
-        var _a, _b, _c;
-        disconnectCallback();
-        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.error(`${FlagdProvider.name}: streaming connection error, will attempt reconnect...`);
-        (_b = this._cache) === null || _b === void 0 ? void 0 : _b.clear();
-        this._streamAlive = false;
-        // if we haven't reached max attempt, reconnect after backoff
-        if (this._streamConnectAttempt <= this._maxEventStreamRetries) {
-            this._streamConnectAttempt++;
-            setTimeout(() => {
-                this._streamConnectBackoff = this._streamConnectBackoff * 2;
-                this.connectStream(connectCallback, changedCallback, disconnectCallback).catch(() => {
-                    // empty catch to avoid unhandled promise rejection
-                });
-            }, this._streamConnectBackoff);
-        }
-        else {
-            // after max attempts, give up
-            const errorMessage = `${FlagdProvider.name}: max stream connect attempts (${this._maxEventStreamRetries} reached)`;
-            (_c = this.logger) === null || _c === void 0 ? void 0 : _c.error(errorMessage);
-            reject(new Error(errorMessage));
-        }
+    reconnect(reconnectCallback, changedCallback, disconnectCallback) {
+        const channel = this._client.getChannel();
+        channel.watchConnectivityState(channel.getConnectivityState(true), Infinity, () => {
+            this.listen(reconnectCallback, changedCallback, disconnectCallback);
+        });
     }
-    handleClose() {
+    handleError(reconnectCallback, changedCallback, disconnectCallback) {
         var _a, _b;
-        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.info(`${FlagdProvider.name}: streaming connection closed`);
+        disconnectCallback();
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.error(`${FlagdProvider.name}: streaming connection error, will attempt reconnect...`);
         (_b = this._cache) === null || _b === void 0 ? void 0 : _b.clear();
-        this._streamAlive = false;
+        this.reconnect(reconnectCallback, changedCallback, disconnectCallback);
     }
     resolve(promise, flagKey, context, logger) {
         var _a, _b;
@@ -6005,6 +5977,444 @@ class GRPCService {
     }
 }
 
+/* eslint-disable */
+/**
+ * Flag definition sync API
+ *
+ * This proto defines a simple API to synchronize a feature flag definition.
+ * It supports establishing a stream for getting notifications about changes in a flag definition.
+ */
+/**
+ * SyncState conveys the state of the payload. These states are related to flagd isync.go type definitions but
+ * contains extras to optimize grpc use case. Refer - https://github.com/open-feature/flagd/blob/main/pkg/sync/isync.go
+ */
+var SyncState;
+(function (SyncState) {
+    /** SYNC_STATE_UNSPECIFIED - Value is ignored by the listening flagd */
+    SyncState[SyncState["SYNC_STATE_UNSPECIFIED"] = 0] = "SYNC_STATE_UNSPECIFIED";
+    /**
+     * SYNC_STATE_ALL - All the flags matching the request. This is the default response and other states can be ignored
+     * by the implementation. Flagd internally replaces all existing flags for this response state.
+     */
+    SyncState[SyncState["SYNC_STATE_ALL"] = 1] = "SYNC_STATE_ALL";
+    /** SYNC_STATE_ADD - Convey an addition of a flag. Flagd internally handles this by combining new flags with existing ones */
+    SyncState[SyncState["SYNC_STATE_ADD"] = 2] = "SYNC_STATE_ADD";
+    /**
+     * SYNC_STATE_UPDATE - Convey an update of a flag. Flagd internally attempts to update if the updated flag already exist OR if it does not,
+     * it will get added
+     */
+    SyncState[SyncState["SYNC_STATE_UPDATE"] = 3] = "SYNC_STATE_UPDATE";
+    /** SYNC_STATE_DELETE - Convey a deletion of a flag. Flagd internally removes the flag */
+    SyncState[SyncState["SYNC_STATE_DELETE"] = 4] = "SYNC_STATE_DELETE";
+    /** SYNC_STATE_PING - Optional server ping to check client connectivity. Handling is ignored by flagd and is to merely support live check */
+    SyncState[SyncState["SYNC_STATE_PING"] = 5] = "SYNC_STATE_PING";
+    SyncState[SyncState["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(SyncState || (SyncState = {}));
+function syncStateFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "SYNC_STATE_UNSPECIFIED":
+            return SyncState.SYNC_STATE_UNSPECIFIED;
+        case 1:
+        case "SYNC_STATE_ALL":
+            return SyncState.SYNC_STATE_ALL;
+        case 2:
+        case "SYNC_STATE_ADD":
+            return SyncState.SYNC_STATE_ADD;
+        case 3:
+        case "SYNC_STATE_UPDATE":
+            return SyncState.SYNC_STATE_UPDATE;
+        case 4:
+        case "SYNC_STATE_DELETE":
+            return SyncState.SYNC_STATE_DELETE;
+        case 5:
+        case "SYNC_STATE_PING":
+            return SyncState.SYNC_STATE_PING;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return SyncState.UNRECOGNIZED;
+    }
+}
+function syncStateToJSON(object) {
+    switch (object) {
+        case SyncState.SYNC_STATE_UNSPECIFIED:
+            return "SYNC_STATE_UNSPECIFIED";
+        case SyncState.SYNC_STATE_ALL:
+            return "SYNC_STATE_ALL";
+        case SyncState.SYNC_STATE_ADD:
+            return "SYNC_STATE_ADD";
+        case SyncState.SYNC_STATE_UPDATE:
+            return "SYNC_STATE_UPDATE";
+        case SyncState.SYNC_STATE_DELETE:
+            return "SYNC_STATE_DELETE";
+        case SyncState.SYNC_STATE_PING:
+            return "SYNC_STATE_PING";
+        case SyncState.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseSyncFlagsRequest() {
+    return { providerId: "", selector: "" };
+}
+const SyncFlagsRequest = {
+    encode(message, writer = minimal.Writer.create()) {
+        if (message.providerId !== "") {
+            writer.uint32(10).string(message.providerId);
+        }
+        if (message.selector !== "") {
+            writer.uint32(18).string(message.selector);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSyncFlagsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.providerId = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.selector = reader.string();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            providerId: isSet(object.providerId) ? String(object.providerId) : "",
+            selector: isSet(object.selector) ? String(object.selector) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.providerId !== "") {
+            obj.providerId = message.providerId;
+        }
+        if (message.selector !== "") {
+            obj.selector = message.selector;
+        }
+        return obj;
+    },
+    create(base) {
+        return SyncFlagsRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b;
+        const message = createBaseSyncFlagsRequest();
+        message.providerId = (_a = object.providerId) !== null && _a !== void 0 ? _a : "";
+        message.selector = (_b = object.selector) !== null && _b !== void 0 ? _b : "";
+        return message;
+    },
+};
+function createBaseSyncFlagsResponse() {
+    return { flagConfiguration: "", state: 0 };
+}
+const SyncFlagsResponse = {
+    encode(message, writer = minimal.Writer.create()) {
+        if (message.flagConfiguration !== "") {
+            writer.uint32(10).string(message.flagConfiguration);
+        }
+        if (message.state !== 0) {
+            writer.uint32(16).int32(message.state);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSyncFlagsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.flagConfiguration = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.state = reader.int32();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            flagConfiguration: isSet(object.flagConfiguration) ? String(object.flagConfiguration) : "",
+            state: isSet(object.state) ? syncStateFromJSON(object.state) : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.flagConfiguration !== "") {
+            obj.flagConfiguration = message.flagConfiguration;
+        }
+        if (message.state !== 0) {
+            obj.state = syncStateToJSON(message.state);
+        }
+        return obj;
+    },
+    create(base) {
+        return SyncFlagsResponse.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b;
+        const message = createBaseSyncFlagsResponse();
+        message.flagConfiguration = (_a = object.flagConfiguration) !== null && _a !== void 0 ? _a : "";
+        message.state = (_b = object.state) !== null && _b !== void 0 ? _b : 0;
+        return message;
+    },
+};
+function createBaseFetchAllFlagsRequest() {
+    return { providerId: "", selector: "" };
+}
+const FetchAllFlagsRequest = {
+    encode(message, writer = minimal.Writer.create()) {
+        if (message.providerId !== "") {
+            writer.uint32(10).string(message.providerId);
+        }
+        if (message.selector !== "") {
+            writer.uint32(18).string(message.selector);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseFetchAllFlagsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.providerId = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.selector = reader.string();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            providerId: isSet(object.providerId) ? String(object.providerId) : "",
+            selector: isSet(object.selector) ? String(object.selector) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.providerId !== "") {
+            obj.providerId = message.providerId;
+        }
+        if (message.selector !== "") {
+            obj.selector = message.selector;
+        }
+        return obj;
+    },
+    create(base) {
+        return FetchAllFlagsRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b;
+        const message = createBaseFetchAllFlagsRequest();
+        message.providerId = (_a = object.providerId) !== null && _a !== void 0 ? _a : "";
+        message.selector = (_b = object.selector) !== null && _b !== void 0 ? _b : "";
+        return message;
+    },
+};
+function createBaseFetchAllFlagsResponse() {
+    return { flagConfiguration: "" };
+}
+const FetchAllFlagsResponse = {
+    encode(message, writer = minimal.Writer.create()) {
+        if (message.flagConfiguration !== "") {
+            writer.uint32(10).string(message.flagConfiguration);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseFetchAllFlagsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.flagConfiguration = reader.string();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return { flagConfiguration: isSet(object.flagConfiguration) ? String(object.flagConfiguration) : "" };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.flagConfiguration !== "") {
+            obj.flagConfiguration = message.flagConfiguration;
+        }
+        return obj;
+    },
+    create(base) {
+        return FetchAllFlagsResponse.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a;
+        const message = createBaseFetchAllFlagsResponse();
+        message.flagConfiguration = (_a = object.flagConfiguration) !== null && _a !== void 0 ? _a : "";
+        return message;
+    },
+};
+const FlagSyncServiceService = {
+    syncFlags: {
+        path: "/sync.v1.FlagSyncService/SyncFlags",
+        requestStream: false,
+        responseStream: true,
+        requestSerialize: (value) => Buffer.from(SyncFlagsRequest.encode(value).finish()),
+        requestDeserialize: (value) => SyncFlagsRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(SyncFlagsResponse.encode(value).finish()),
+        responseDeserialize: (value) => SyncFlagsResponse.decode(value),
+    },
+    fetchAllFlags: {
+        path: "/sync.v1.FlagSyncService/FetchAllFlags",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(FetchAllFlagsRequest.encode(value).finish()),
+        requestDeserialize: (value) => FetchAllFlagsRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(FetchAllFlagsResponse.encode(value).finish()),
+        responseDeserialize: (value) => FetchAllFlagsResponse.decode(value),
+    },
+};
+const FlagSyncServiceClient = makeGenericClientConstructor(FlagSyncServiceService, "sync.v1.FlagSyncService");
+function isSet(value) {
+    return value !== null && value !== undefined;
+}
+
+/**
+ * Implements the gRPC sync contract to fetch flag data.
+ */
+class GrpcFetch {
+    constructor(config, syncServiceClient, logger) {
+        const { host, port, tls, socketPath, selector } = config;
+        this._syncClient = syncServiceClient
+            ? syncServiceClient
+            : new FlagSyncServiceClient(socketPath ? `unix://${socketPath}` : `${host}:${port}`, tls ? credentials.createSsl() : credentials.createInsecure());
+        this._logger = logger;
+        this._request = { providerId: '', selector: selector ? selector : '' };
+    }
+    connect(dataFillCallback, reconnectCallback, changedCallback, disconnectCallback) {
+        // note that we never reject the promise as sync is a long-running operation
+        return new Promise((resolve, reject) => this.listen(dataFillCallback, reconnectCallback, changedCallback, disconnectCallback, resolve, reject));
+    }
+    disconnect() {
+        var _a, _b;
+        (_a = this._logger) === null || _a === void 0 ? void 0 : _a.debug('Disconnecting gRPC sync connection');
+        (_b = this._syncStream) === null || _b === void 0 ? void 0 : _b.destroy();
+        this._syncClient.close();
+    }
+    listen(dataFillCallback, reconnectCallback, changedCallback, disconnectCallback, resolveConnect, rejectConnect) {
+        this._syncStream = this._syncClient.syncFlags(this._request);
+        this._syncStream.on('data', (data) => {
+            var _a;
+            (_a = this._logger) === null || _a === void 0 ? void 0 : _a.debug('Received sync payload');
+            dataFillCallback(data.flagConfiguration);
+            changedCallback([]); // flags changed list not supported
+            // if resolveConnect is undefined, this is a reconnection; we only want to fire the reconnect callback in that case
+            if (resolveConnect) {
+                resolveConnect();
+            }
+            else {
+                reconnectCallback();
+            }
+        });
+        this._syncStream.on('error', (err) => {
+            var _a;
+            (_a = this._logger) === null || _a === void 0 ? void 0 : _a.error('Connection error, attempting to reconnect', err);
+            disconnectCallback();
+            rejectConnect === null || rejectConnect === void 0 ? void 0 : rejectConnect(new GeneralError('Failed to connect stream'));
+            this.reconnect(dataFillCallback, reconnectCallback, changedCallback, disconnectCallback);
+        });
+    }
+    reconnect(dataFillCallback, reconnectCallback, changedCallback, disconnectCallback) {
+        const channel = this._syncClient.getChannel();
+        channel.watchConnectivityState(channel.getConnectivityState(true), Infinity, () => {
+            this.listen(dataFillCallback, reconnectCallback, changedCallback, disconnectCallback);
+        });
+    }
+}
+
+class InProcessService {
+    constructor(config, dataFetcher, logger) {
+        this._flagdCore = new FlagdCore();
+        this._dataFetcher = dataFetcher ? dataFetcher : new GrpcFetch(config, undefined, logger);
+    }
+    connect(reconnectCallback, changedCallback, disconnectCallback) {
+        return this._dataFetcher.connect(this.fill.bind(this), reconnectCallback, changedCallback, disconnectCallback);
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._dataFetcher.disconnect();
+        });
+    }
+    resolveBoolean(flagKey, defaultValue, context, logger) {
+        return Promise.resolve(this._flagdCore.resolveBooleanEvaluation(flagKey, defaultValue, context, logger));
+    }
+    resolveNumber(flagKey, defaultValue, context, logger) {
+        return Promise.resolve(this._flagdCore.resolveNumberEvaluation(flagKey, defaultValue, context, logger));
+    }
+    resolveString(flagKey, defaultValue, context, logger) {
+        return Promise.resolve(this._flagdCore.resolveStringEvaluation(flagKey, defaultValue, context, logger));
+    }
+    resolveObject(flagKey, defaultValue, context, logger) {
+        return Promise.resolve(this._flagdCore.resolveObjectEvaluation(flagKey, defaultValue, context, logger));
+    }
+    fill(flags) {
+        this._flagdCore.setConfigurations(flags);
+    }
+}
+
 class FlagdProvider {
     get status() {
         return this._status;
@@ -6032,11 +6442,16 @@ class FlagdProvider {
             logger.error(err === null || err === void 0 ? void 0 : err.stack);
             throw err;
         };
-        this._service = service ? service : new GRPCService(getConfig(options), undefined, logger);
+        const config = getConfig(options);
+        this._service = service
+            ? service
+            : config.resolverType === 'in-process'
+                ? new InProcessService(config, undefined, logger)
+                : new GRPCService(config, undefined, logger);
     }
     initialize() {
         return this._service
-            .connect(this.setReady.bind(this), this.emitChanged.bind(this), this.setError.bind(this))
+            .connect(this.handleReconnect.bind(this), this.handleChanged.bind(this), this.handleError.bind(this))
             .then(() => {
             var _a;
             (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(`${this.metadata.name}: ready`);
@@ -6054,33 +6469,35 @@ class FlagdProvider {
         (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(`${this.metadata.name}: shutting down`);
         return this._service.disconnect();
     }
-    resolveBooleanEvaluation(flagKey, _, transformedContext, logger) {
+    resolveBooleanEvaluation(flagKey, defaultValue, transformedContext, logger) {
         return this._service
-            .resolveBoolean(flagKey, transformedContext, logger)
+            .resolveBoolean(flagKey, defaultValue, transformedContext, logger)
             .catch((err) => this.logRejected(err, flagKey, logger));
     }
-    resolveStringEvaluation(flagKey, _, transformedContext, logger) {
+    resolveStringEvaluation(flagKey, defaultValue, transformedContext, logger) {
         return this._service
-            .resolveString(flagKey, transformedContext, logger)
+            .resolveString(flagKey, defaultValue, transformedContext, logger)
             .catch((err) => this.logRejected(err, flagKey, logger));
     }
-    resolveNumberEvaluation(flagKey, _, transformedContext, logger) {
+    resolveNumberEvaluation(flagKey, defaultValue, transformedContext, logger) {
         return this._service
-            .resolveNumber(flagKey, transformedContext, logger)
+            .resolveNumber(flagKey, defaultValue, transformedContext, logger)
             .catch((err) => this.logRejected(err, flagKey, logger));
     }
-    resolveObjectEvaluation(flagKey, _, transformedContext, logger) {
+    resolveObjectEvaluation(flagKey, defaultValue, transformedContext, logger) {
         return this._service
-            .resolveObject(flagKey, transformedContext, logger)
+            .resolveObject(flagKey, defaultValue, transformedContext, logger)
             .catch((err) => this.logRejected(err, flagKey, logger));
     }
-    setReady() {
+    handleReconnect() {
         this._status = ProviderStatus.READY;
+        this._events.emit(ProviderEvents.Ready);
     }
-    setError() {
+    handleError() {
         this._status = ProviderStatus.ERROR;
+        this._events.emit(ProviderEvents.Error);
     }
-    emitChanged(flagsChanged) {
+    handleChanged(flagsChanged) {
         this._events.emit(ProviderEvents.ConfigurationChanged, { flagsChanged });
     }
 }