@firebase/data-connect 0.1.0 → 0.1.1

package/dist/index.node.cjs.js

@@ -2,7 +2,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var tslib = require('tslib');
 var util = require('@firebase/util');
 var logger$1 = require('@firebase/logger');
 var app = require('@firebase/app');
@@ -24,7 +23,7 @@ var component = require('@firebase/component');
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var Code = {
+const Code = {
     OTHER: 'other',
     ALREADY_INITIALIZED: 'already-initialized',
     NOT_INITIALIZED: 'not-initialized',
@@ -34,10 +33,9 @@ var Code = {
     UNAUTHORIZED: 'unauthorized'
 };
 /** An error returned by a DataConnect operation. */
-var DataConnectError = /** @class */ (function (_super) {
-    tslib.__extends(DataConnectError, _super);
+class DataConnectError extends util.FirebaseError {
     /** @hideconstructor */
-    function DataConnectError(
+    constructor(
     /**
      * The backend error code associated with this error.
      */
@@ -46,17 +44,15 @@ var DataConnectError = /** @class */ (function (_super) {
      * A custom error description.
      */
     message) {
-        var _this = _super.call(this, code, message) || this;
-        _this.code = code;
-        _this.message = message;
+        super(code, message);
+        this.code = code;
+        this.message = message;
         // HACK: We write a toString property directly because Error is not a real
         // class and so inheritance does not work correctly. We could alternatively
         // do the same "back-door inheritance" trick that FirebaseError does.
-        _this.toString = function () { return "".concat(_this.name, ": [code=").concat(_this.code, "]: ").concat(_this.message); };
-        return _this;
+        this.toString = () => `${this.name}: [code=${this.code}]: ${this.message}`;
     }
-    return DataConnectError;
-}(util.FirebaseError));
+}
 
 /**
  * @license
@@ -75,7 +71,7 @@ var DataConnectError = /** @class */ (function (_super) {
  * limitations under the License.
  */
 /** The semver (www.semver.org) version of the SDK. */
-var SDK_VERSION = '';
+let SDK_VERSION = '';
 /**
  * SDK_VERSION should be set before any database instance is created
  * @internal
@@ -100,15 +96,15 @@ function setSDKVersion(version) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var logger = new logger$1.Logger('@firebase/data-connect');
+const logger = new logger$1.Logger('@firebase/data-connect');
 function setLogLevel(logLevel) {
     logger.setLogLevel(logLevel);
 }
 function logDebug(msg) {
-    logger.debug("DataConnect (".concat(SDK_VERSION, "): ").concat(msg));
+    logger.debug(`DataConnect (${SDK_VERSION}): ${msg}`);
 }
 function logError(msg) {
-    logger.error("DataConnect (".concat(SDK_VERSION, "): ").concat(msg));
+    logger.error(`DataConnect (${SDK_VERSION}): ${msg}`);
 }
 
 /**
@@ -127,24 +123,22 @@ function logError(msg) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var connectFetch = globalThis.fetch;
+let connectFetch = globalThis.fetch;
 function initializeFetch(fetchImpl) {
     connectFetch = fetchImpl;
 }
 function getGoogApiClientValue(_isUsingGen) {
-    var str = 'gl-js/ fire/' + SDK_VERSION;
+    let str = 'gl-js/ fire/' + SDK_VERSION;
     if (_isUsingGen) {
-        str += ' web/gen';
+        str += ' js/gen';
     }
     return str;
 }
-function dcFetch(url, body, _a, appId, accessToken, appCheckToken, _isUsingGen) {
-    var _this = this;
-    var signal = _a.signal;
+function dcFetch(url, body, { signal }, appId, accessToken, appCheckToken, _isUsingGen) {
     if (!connectFetch) {
         throw new DataConnectError(Code.OTHER, 'No Fetch Implementation detected!');
     }
-    var headers = {
+    const headers = {
         'Content-Type': 'application/json',
         'X-Goog-Api-Client': getGoogApiClientValue(_isUsingGen)
     };
@@ -157,49 +151,38 @@ function dcFetch(url, body, _a, appId, accessToken, appCheckToken, _isUsingGen)
     if (appCheckToken) {
         headers['X-Firebase-AppCheck'] = appCheckToken;
     }
-    var bodyStr = JSON.stringify(body);
-    logDebug("Making request out to ".concat(url, " with body: ").concat(bodyStr));
+    const bodyStr = JSON.stringify(body);
+    logDebug(`Making request out to ${url} with body: ${bodyStr}`);
     return connectFetch(url, {
         body: bodyStr,
         method: 'POST',
-        headers: headers,
-        signal: signal
+        headers,
+        signal
     })
-        .catch(function (err) {
+        .catch(err => {
         throw new DataConnectError(Code.OTHER, 'Failed to fetch: ' + JSON.stringify(err));
     })
-        .then(function (response) { return tslib.__awaiter(_this, void 0, void 0, function () {
-        var jsonResponse, e_1, message;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    jsonResponse = null;
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, response.json()];
-                case 2:
-                    jsonResponse = _a.sent();
-                    return [3 /*break*/, 4];
-                case 3:
-                    e_1 = _a.sent();
-                    throw new DataConnectError(Code.OTHER, JSON.stringify(e_1));
-                case 4:
-                    message = getMessage(jsonResponse);
-                    if (response.status >= 400) {
-                        logError('Error while performing request: ' + JSON.stringify(jsonResponse));
-                        if (response.status === 401) {
-                            throw new DataConnectError(Code.UNAUTHORIZED, message);
-                        }
-                        throw new DataConnectError(Code.OTHER, message);
-                    }
-                    return [2 /*return*/, jsonResponse];
+        .then(async (response) => {
+        let jsonResponse = null;
+        try {
+            jsonResponse = await response.json();
+        }
+        catch (e) {
+            throw new DataConnectError(Code.OTHER, JSON.stringify(e));
+        }
+        const message = getMessage(jsonResponse);
+        if (response.status >= 400) {
+            logError('Error while performing request: ' + JSON.stringify(jsonResponse));
+            if (response.status === 401) {
+                throw new DataConnectError(Code.UNAUTHORIZED, message);
             }
-        });
-    }); })
-        .then(function (res) {
+            throw new DataConnectError(Code.OTHER, message);
+        }
+        return jsonResponse;
+    })
+        .then(res => {
         if (res.errors && res.errors.length) {
-            var stringified = JSON.stringify(res.errors);
+            const stringified = JSON.stringify(res.errors);
             logError('DataConnect error while performing request: ' + stringified);
             throw new DataConnectError(Code.OTHER, stringified);
         }
@@ -213,8 +196,8 @@ function getMessage(obj) {
     return JSON.stringify(obj);
 }
 
-var name = "@firebase/data-connect";
-var version = "0.1.0";
+const name = "@firebase/data-connect";
+const version = "0.1.1";
 
 /**
  * @license
@@ -236,27 +219,25 @@ var version = "0.1.0";
  * @internal
  * Abstraction around AppCheck's token fetching capabilities.
  */
-var AppCheckTokenProvider = /** @class */ (function () {
-    function AppCheckTokenProvider(appName_, appCheckProvider) {
-        var _this = this;
+class AppCheckTokenProvider {
+    constructor(appName_, appCheckProvider) {
         this.appName_ = appName_;
         this.appCheckProvider = appCheckProvider;
         this.appCheck = appCheckProvider === null || appCheckProvider === void 0 ? void 0 : appCheckProvider.getImmediate({ optional: true });
         if (!this.appCheck) {
-            void (appCheckProvider === null || appCheckProvider === void 0 ? void 0 : appCheckProvider.get().then(function (appCheck) { return (_this.appCheck = appCheck); }).catch());
+            void (appCheckProvider === null || appCheckProvider === void 0 ? void 0 : appCheckProvider.get().then(appCheck => (this.appCheck = appCheck)).catch());
         }
     }
-    AppCheckTokenProvider.prototype.getToken = function (forceRefresh) {
-        var _this = this;
+    getToken(forceRefresh) {
         if (!this.appCheck) {
-            return new Promise(function (resolve, reject) {
+            return new Promise((resolve, reject) => {
                 // Support delayed initialization of FirebaseAppCheck. This allows our
                 // customers to initialize the RTDB SDK before initializing Firebase
                 // AppCheck and ensures that all requests are authenticated if a token
                 // becomes available before the timoeout below expires.
-                setTimeout(function () {
-                    if (_this.appCheck) {
-                        _this.getToken(forceRefresh).then(resolve, reject);
+                setTimeout(() => {
+                    if (this.appCheck) {
+                        this.getToken(forceRefresh).then(resolve, reject);
                     }
                     else {
                         resolve(null);
@@ -265,13 +246,12 @@ var AppCheckTokenProvider = /** @class */ (function () {
             });
         }
         return this.appCheck.getToken(forceRefresh);
-    };
-    AppCheckTokenProvider.prototype.addTokenChangeListener = function (listener) {
+    }
+    addTokenChangeListener(listener) {
         var _a;
-        void ((_a = this.appCheckProvider) === null || _a === void 0 ? void 0 : _a.get().then(function (appCheck) { return appCheck.addTokenListener(listener); }));
-    };
-    return AppCheckTokenProvider;
-}());
+        void ((_a = this.appCheckProvider) === null || _a === void 0 ? void 0 : _a.get().then(appCheck => appCheck.addTokenListener(listener)));
+    }
+}
 
 /**
  * @license
@@ -290,24 +270,22 @@ var AppCheckTokenProvider = /** @class */ (function () {
  * limitations under the License.
  */
 // @internal
-var FirebaseAuthProvider = /** @class */ (function () {
-    function FirebaseAuthProvider(_appName, _options, _authProvider) {
-        var _this = this;
+class FirebaseAuthProvider {
+    constructor(_appName, _options, _authProvider) {
         this._appName = _appName;
         this._options = _options;
         this._authProvider = _authProvider;
         this._auth = _authProvider.getImmediate({ optional: true });
         if (!this._auth) {
-            _authProvider.onInit(function (auth) { return (_this._auth = auth); });
+            _authProvider.onInit(auth => (this._auth = auth));
         }
     }
-    FirebaseAuthProvider.prototype.getToken = function (forceRefresh) {
-        var _this = this;
+    getToken(forceRefresh) {
         if (!this._auth) {
-            return new Promise(function (resolve, reject) {
-                setTimeout(function () {
-                    if (_this._auth) {
-                        _this.getToken(forceRefresh).then(resolve, reject);
+            return new Promise((resolve, reject) => {
+                setTimeout(() => {
+                    if (this._auth) {
+                        this.getToken(forceRefresh).then(resolve, reject);
                     }
                     else {
                         resolve(null);
@@ -315,7 +293,7 @@ var FirebaseAuthProvider = /** @class */ (function () {
                 }, 0);
             });
         }
-        return this._auth.getToken(forceRefresh).catch(function (error) {
+        return this._auth.getToken(forceRefresh).catch(error => {
             if (error && error.code === 'auth/token-not-initialized') {
                 logDebug('Got auth/token-not-initialized error.  Treating as null token.');
                 return null;
@@ -326,19 +304,18 @@ var FirebaseAuthProvider = /** @class */ (function () {
                 return Promise.reject(error);
             }
         });
-    };
-    FirebaseAuthProvider.prototype.addTokenChangeListener = function (listener) {
+    }
+    addTokenChangeListener(listener) {
         var _a;
         (_a = this._auth) === null || _a === void 0 ? void 0 : _a.addAuthTokenListener(listener);
-    };
-    FirebaseAuthProvider.prototype.removeTokenChangeListener = function (listener) {
+    }
+    removeTokenChangeListener(listener) {
         this._authProvider
             .get()
-            .then(function (auth) { return auth.removeAuthTokenListener(listener); })
-            .catch(function (err) { return logError(err); });
-    };
-    return FirebaseAuthProvider;
-}());
+            .then(auth => auth.removeAuthTokenListener(listener))
+            .catch(err => logError(err));
+    }
+}
 
 /**
  * @license
@@ -356,10 +333,10 @@ var FirebaseAuthProvider = /** @class */ (function () {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var QUERY_STR = 'query';
-var MUTATION_STR = 'mutation';
-var SOURCE_SERVER = 'SERVER';
-var SOURCE_CACHE = 'CACHE';
+const QUERY_STR = 'query';
+const MUTATION_STR = 'mutation';
+const SOURCE_SERVER = 'SERVER';
+const SOURCE_CACHE = 'CACHE';
 
 /**
  * @license
@@ -377,11 +354,11 @@ var SOURCE_CACHE = 'CACHE';
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var encoderImpl;
+let encoderImpl;
 function setEncoder(encoder) {
     encoderImpl = encoder;
 }
-setEncoder(function (o) { return JSON.stringify(o); });
+setEncoder(o => JSON.stringify(o));
 
 /**
  * @license
@@ -424,31 +401,31 @@ function setIfNotExists(map, key, val) {
 function getRefSerializer(queryRef, data, source) {
     return function toJSON() {
         return {
-            data: data,
+            data,
             refInfo: {
                 name: queryRef.name,
                 variables: queryRef.variables,
-                connectorConfig: tslib.__assign({ projectId: queryRef.dataConnect.app.options.projectId }, queryRef.dataConnect.getSettings())
+                connectorConfig: Object.assign({ projectId: queryRef.dataConnect.app.options.projectId }, queryRef.dataConnect.getSettings())
             },
             fetchTime: Date.now().toLocaleString(),
-            source: source
+            source
         };
     };
 }
-var QueryManager = /** @class */ (function () {
-    function QueryManager(transport) {
+class QueryManager {
+    constructor(transport) {
         this.transport = transport;
         this._queries = new Map();
     }
-    QueryManager.prototype.track = function (queryName, variables, initialCache) {
-        var ref = {
+    track(queryName, variables, initialCache) {
+        const ref = {
             name: queryName,
-            variables: variables,
+            variables,
             refType: QUERY_STR
         };
-        var key = encoderImpl(ref);
-        var newTrackedQuery = {
-            ref: ref,
+        const key = encoderImpl(ref);
+        const newTrackedQuery = {
+            ref,
             subscriptions: [],
             currentCache: initialCache || null,
             lastError: null
@@ -456,22 +433,21 @@ var QueryManager = /** @class */ (function () {
         // @ts-ignore
         setIfNotExists(this._queries, key, newTrackedQuery);
         return this._queries.get(key);
-    };
-    QueryManager.prototype.addSubscription = function (queryRef, onResultCallback, onErrorCallback, initialCache) {
-        var _this = this;
-        var key = encoderImpl({
+    }
+    addSubscription(queryRef, onResultCallback, onErrorCallback, initialCache) {
+        const key = encoderImpl({
             name: queryRef.name,
             variables: queryRef.variables,
             refType: QUERY_STR
         });
-        var trackedQuery = this._queries.get(key);
-        var subscription = {
+        const trackedQuery = this._queries.get(key);
+        const subscription = {
             userCallback: onResultCallback,
             errCallback: onErrorCallback
         };
-        var unsubscribe = function () {
-            var trackedQuery = _this._queries.get(key);
-            trackedQuery.subscriptions = trackedQuery.subscriptions.filter(function (sub) { return sub !== subscription; });
+        const unsubscribe = () => {
+            const trackedQuery = this._queries.get(key);
+            trackedQuery.subscriptions = trackedQuery.subscriptions.filter(sub => sub !== subscription);
         };
         if (initialCache && trackedQuery.currentCache !== initialCache) {
             logDebug('Initial cache found. Comparing dates.');
@@ -482,7 +458,7 @@ var QueryManager = /** @class */ (function () {
             }
         }
         if (trackedQuery.currentCache !== null) {
-            var cachedData = trackedQuery.currentCache.data;
+            const cachedData = trackedQuery.currentCache.data;
             onResultCallback({
                 data: cachedData,
                 source: SOURCE_CACHE,
@@ -497,39 +473,42 @@ var QueryManager = /** @class */ (function () {
         trackedQuery.subscriptions.push({
             userCallback: onResultCallback,
             errCallback: onErrorCallback,
-            unsubscribe: unsubscribe
+            unsubscribe
         });
         if (!trackedQuery.currentCache) {
-            logDebug("No cache available for query ".concat(queryRef.name, " with variables ").concat(JSON.stringify(queryRef.variables), ". Calling executeQuery."));
-            var promise = this.executeQuery(queryRef);
+            logDebug(`No cache available for query ${queryRef.name} with variables ${JSON.stringify(queryRef.variables)}. Calling executeQuery.`);
+            const promise = this.executeQuery(queryRef);
             // We want to ignore the error and let subscriptions handle it
-            promise.then(undefined, function (err) { });
+            promise.then(undefined, err => { });
         }
         return unsubscribe;
-    };
-    QueryManager.prototype.executeQuery = function (queryRef) {
-        var key = encoderImpl({
+    }
+    executeQuery(queryRef) {
+        if (queryRef.refType !== QUERY_STR) {
+            throw new DataConnectError(Code.INVALID_ARGUMENT, `ExecuteQuery can only execute query operation`);
+        }
+        const key = encoderImpl({
             name: queryRef.name,
             variables: queryRef.variables,
             refType: QUERY_STR
         });
-        var trackedQuery = this._queries.get(key);
-        var result = this.transport.invokeQuery(queryRef.name, queryRef.variables);
-        var newR = result.then(function (res) {
-            var fetchTime = new Date().toString();
-            var result = tslib.__assign(tslib.__assign({}, res), { source: SOURCE_SERVER, ref: queryRef, toJSON: getRefSerializer(queryRef, res.data, SOURCE_SERVER), fetchTime: fetchTime });
-            trackedQuery.subscriptions.forEach(function (subscription) {
+        const trackedQuery = this._queries.get(key);
+        const result = this.transport.invokeQuery(queryRef.name, queryRef.variables);
+        const newR = result.then(res => {
+            const fetchTime = new Date().toString();
+            const result = Object.assign(Object.assign({}, res), { source: SOURCE_SERVER, ref: queryRef, toJSON: getRefSerializer(queryRef, res.data, SOURCE_SERVER), fetchTime });
+            trackedQuery.subscriptions.forEach(subscription => {
                 subscription.userCallback(result);
             });
             trackedQuery.currentCache = {
                 data: res.data,
                 source: SOURCE_CACHE,
-                fetchTime: fetchTime
+                fetchTime
             };
             return result;
-        }, function (err) {
+        }, err => {
             trackedQuery.lastError = err;
-            trackedQuery.subscriptions.forEach(function (subscription) {
+            trackedQuery.subscriptions.forEach(subscription => {
                 if (subscription.errCallback) {
                     subscription.errCallback(err);
                 }
@@ -537,15 +516,14 @@ var QueryManager = /** @class */ (function () {
             throw err;
         });
         return newR;
-    };
-    QueryManager.prototype.enableEmulator = function (host, port) {
+    }
+    enableEmulator(host, port) {
         this.transport.useEmulator(host, port);
-    };
-    return QueryManager;
-}());
+    }
+}
 function compareDates(str1, str2) {
-    var date1 = new Date(str1);
-    var date2 = new Date(str2);
+    const date1 = new Date(str1);
+    const date2 = new Date(str2);
     return date1.getTime() < date2.getTime();
 }
 
@@ -566,25 +544,25 @@ function compareDates(str1, str2) {
  * limitations under the License.
  */
 function urlBuilder(projectConfig, transportOptions) {
-    var connector = projectConfig.connector, location = projectConfig.location, project = projectConfig.projectId, service = projectConfig.service;
-    var host = transportOptions.host, sslEnabled = transportOptions.sslEnabled, port = transportOptions.port;
-    var protocol = sslEnabled ? 'https' : 'http';
-    var realHost = host || "firebasedataconnect.googleapis.com";
-    var baseUrl = "".concat(protocol, "://").concat(realHost);
+    const { connector, location, projectId: project, service } = projectConfig;
+    const { host, sslEnabled, port } = transportOptions;
+    const protocol = sslEnabled ? 'https' : 'http';
+    const realHost = host || `firebasedataconnect.googleapis.com`;
+    let baseUrl = `${protocol}://${realHost}`;
     if (typeof port === 'number') {
-        baseUrl += ":".concat(port);
+        baseUrl += `:${port}`;
     }
     else if (typeof port !== 'undefined') {
         logError('Port type is of an invalid type');
         throw new DataConnectError(Code.INVALID_ARGUMENT, 'Incorrect type for port passed in!');
     }
-    return "".concat(baseUrl, "/v1beta/projects/").concat(project, "/locations/").concat(location, "/services/").concat(service, "/connectors/").concat(connector);
+    return `${baseUrl}/v1beta/projects/${project}/locations/${location}/services/${service}/connectors/${connector}`;
 }
 function addToken(url, apiKey) {
     if (!apiKey) {
         return url;
     }
-    var newUrl = new URL(url);
+    const newUrl = new URL(url);
     newUrl.searchParams.append('key', apiKey);
     return newUrl.toString();
 }
@@ -605,10 +583,8 @@ function addToken(url, apiKey) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var RESTTransport = /** @class */ (function () {
-    function RESTTransport(options, apiKey, appId, authProvider, appCheckProvider, transportOptions, _isUsingGen) {
-        if (_isUsingGen === void 0) { _isUsingGen = false; }
-        var _this = this;
+class RESTTransport {
+    constructor(options, apiKey, appId, authProvider, appCheckProvider, transportOptions, _isUsingGen = false) {
         var _a, _b;
         this.apiKey = apiKey;
         this.appId = appId;
@@ -624,36 +600,34 @@ var RESTTransport = /** @class */ (function () {
         this._appCheckToken = null;
         this._lastToken = null;
         // TODO(mtewani): Update U to include shape of body defined in line 13.
-        this.invokeQuery = function (queryName, body) {
-            var abortController = new AbortController();
+        this.invokeQuery = (queryName, body) => {
+            const abortController = new AbortController();
             // TODO(mtewani): Update to proper value
-            var withAuth = _this.withRetry(function () {
-                return dcFetch(addToken("".concat(_this.endpointUrl, ":executeQuery"), _this.apiKey), {
-                    name: "projects/".concat(_this._project, "/locations/").concat(_this._location, "/services/").concat(_this._serviceName, "/connectors/").concat(_this._connectorName),
-                    operationName: queryName,
-                    variables: body
-                }, // TODO(mtewani): This is a patch, fix this.
-                abortController, _this.appId, _this._accessToken, _this._appCheckToken, _this._isUsingGen);
-            });
+            const withAuth = this.withRetry(() => dcFetch(addToken(`${this.endpointUrl}:executeQuery`, this.apiKey), {
+                name: `projects/${this._project}/locations/${this._location}/services/${this._serviceName}/connectors/${this._connectorName}`,
+                operationName: queryName,
+                variables: body
+            }, // TODO(mtewani): This is a patch, fix this.
+            abortController, this.appId, this._accessToken, this._appCheckToken, this._isUsingGen));
             return {
                 then: withAuth.then.bind(withAuth),
                 catch: withAuth.catch.bind(withAuth)
             };
         };
-        this.invokeMutation = function (mutationName, body) {
-            var abortController = new AbortController();
-            var taskResult = _this.withRetry(function () {
-                return dcFetch(addToken("".concat(_this.endpointUrl, ":executeMutation"), _this.apiKey), {
-                    name: "projects/".concat(_this._project, "/locations/").concat(_this._location, "/services/").concat(_this._serviceName, "/connectors/").concat(_this._connectorName),
+        this.invokeMutation = (mutationName, body) => {
+            const abortController = new AbortController();
+            const taskResult = this.withRetry(() => {
+                return dcFetch(addToken(`${this.endpointUrl}:executeMutation`, this.apiKey), {
+                    name: `projects/${this._project}/locations/${this._location}/services/${this._serviceName}/connectors/${this._connectorName}`,
                     operationName: mutationName,
                     variables: body
-                }, abortController, _this.appId, _this._accessToken, _this._appCheckToken, _this._isUsingGen);
+                }, abortController, this.appId, this._accessToken, this._appCheckToken, this._isUsingGen);
             });
             return {
                 then: taskResult.then.bind(taskResult),
                 // catch: taskResult.catch.bind(taskResult),
                 // finally: taskResult.finally.bind(taskResult),
-                cancel: function () { return abortController.abort(); }
+                cancel: () => abortController.abort()
             };
         };
         if (transportOptions) {
@@ -665,7 +639,7 @@ var RESTTransport = /** @class */ (function () {
             }
             this._host = transportOptions.host;
         }
-        var location = options.location, project = options.projectId, connector = options.connector, service = options.service;
+        const { location, projectId: project, connector, service } = options;
         if (location) {
             this._location = location;
         }
@@ -677,29 +651,25 @@ var RESTTransport = /** @class */ (function () {
             throw new DataConnectError(Code.INVALID_ARGUMENT, 'Connector Name required!');
         }
         this._connectorName = connector;
-        (_a = this.authProvider) === null || _a === void 0 ? void 0 : _a.addTokenChangeListener(function (token) {
-            logDebug("New Token Available: ".concat(token));
-            _this._accessToken = token;
+        (_a = this.authProvider) === null || _a === void 0 ? void 0 : _a.addTokenChangeListener(token => {
+            logDebug(`New Token Available: ${token}`);
+            this._accessToken = token;
         });
-        (_b = this.appCheckProvider) === null || _b === void 0 ? void 0 : _b.addTokenChangeListener(function (result) {
-            var token = result.token;
-            logDebug("New App Check Token Available: ".concat(token));
-            _this._appCheckToken = token;
+        (_b = this.appCheckProvider) === null || _b === void 0 ? void 0 : _b.addTokenChangeListener(result => {
+            const { token } = result;
+            logDebug(`New App Check Token Available: ${token}`);
+            this._appCheckToken = token;
         });
     }
-    Object.defineProperty(RESTTransport.prototype, "endpointUrl", {
-        get: function () {
-            return urlBuilder({
-                connector: this._connectorName,
-                location: this._location,
-                projectId: this._project,
-                service: this._serviceName
-            }, { host: this._host, sslEnabled: this._secure, port: this._port });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    RESTTransport.prototype.useEmulator = function (host, port, isSecure) {
+    get endpointUrl() {
+        return urlBuilder({
+            connector: this._connectorName,
+            location: this._location,
+            projectId: this._project,
+            service: this._serviceName
+        }, { host: this._host, sslEnabled: this._secure, port: this._port });
+    }
+    useEmulator(host, port, isSecure) {
         this._host = host;
         if (typeof port === 'number') {
             this._port = port;
@@ -707,76 +677,57 @@ var RESTTransport = /** @class */ (function () {
         if (typeof isSecure !== 'undefined') {
             this._secure = isSecure;
         }
-    };
-    RESTTransport.prototype.onTokenChanged = function (newToken) {
+    }
+    onTokenChanged(newToken) {
         this._accessToken = newToken;
-    };
-    RESTTransport.prototype.getWithAuth = function (forceToken) {
+    }
+    async getWithAuth(forceToken = false) {
         var _a;
-        if (forceToken === void 0) { forceToken = false; }
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            var starterPromise, _b;
-            var _this = this;
-            return tslib.__generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        starterPromise = new Promise(function (resolve) {
-                            return resolve(_this._accessToken);
-                        });
-                        if (!this.appCheckProvider) return [3 /*break*/, 2];
-                        _b = this;
-                        return [4 /*yield*/, this.appCheckProvider.getToken()];
-                    case 1:
-                        _b._appCheckToken = (_a = (_c.sent())) === null || _a === void 0 ? void 0 : _a.token;
-                        _c.label = 2;
-                    case 2:
-                        if (this.authProvider) {
-                            starterPromise = this.authProvider
-                                .getToken(/*forceToken=*/ forceToken)
-                                .then(function (data) {
-                                if (!data) {
-                                    return null;
-                                }
-                                _this._accessToken = data.accessToken;
-                                return _this._accessToken;
-                            });
-                        }
-                        else {
-                            starterPromise = new Promise(function (resolve) { return resolve(''); });
-                        }
-                        return [2 /*return*/, starterPromise];
+        let starterPromise = new Promise(resolve => resolve(this._accessToken));
+        if (this.appCheckProvider) {
+            this._appCheckToken = (_a = (await this.appCheckProvider.getToken())) === null || _a === void 0 ? void 0 : _a.token;
+        }
+        if (this.authProvider) {
+            starterPromise = this.authProvider
+                .getToken(/*forceToken=*/ forceToken)
+                .then(data => {
+                if (!data) {
+                    return null;
                 }
+                this._accessToken = data.accessToken;
+                return this._accessToken;
             });
-        });
-    };
-    RESTTransport.prototype._setLastToken = function (lastToken) {
+        }
+        else {
+            starterPromise = new Promise(resolve => resolve(''));
+        }
+        return starterPromise;
+    }
+    _setLastToken(lastToken) {
         this._lastToken = lastToken;
-    };
-    RESTTransport.prototype.withRetry = function (promiseFactory, retry) {
-        var _this = this;
-        if (retry === void 0) { retry = false; }
-        var isNewToken = false;
+    }
+    withRetry(promiseFactory, retry = false) {
+        let isNewToken = false;
         return this.getWithAuth(retry)
-            .then(function (res) {
-            isNewToken = _this._lastToken !== res;
-            _this._lastToken = res;
+            .then(res => {
+            isNewToken = this._lastToken !== res;
+            this._lastToken = res;
             return res;
         })
             .then(promiseFactory)
-            .catch(function (err) {
+            .catch(err => {
             // Only retry if the result is unauthorized and the last token isn't the same as the new one.
             if ('code' in err &&
                 err.code === Code.UNAUTHORIZED &&
                 !retry &&
                 isNewToken) {
                 logDebug('Retrying due to unauthorized');
-                return _this.withRetry(promiseFactory, true);
+                return this.withRetry(promiseFactory, true);
             }
             throw err;
         });
-    };
-    return RESTTransport;
-}());
+    }
+}
 
 /**
  * @license
@@ -803,7 +754,7 @@ var RESTTransport = /** @class */ (function () {
  */
 function mutationRef(dcInstance, mutationName, variables) {
     dcInstance.setInitialized();
-    var ref = {
+    const ref = {
         dataConnect: dcInstance,
         name: mutationName,
         refType: MUTATION_STR,
@@ -814,27 +765,23 @@ function mutationRef(dcInstance, mutationName, variables) {
 /**
  * @internal
  */
-var MutationManager = /** @class */ (function () {
-    function MutationManager(_transport) {
+class MutationManager {
+    constructor(_transport) {
         this._transport = _transport;
         this._inflight = [];
     }
-    MutationManager.prototype.executeMutation = function (mutationRef) {
-        var _this = this;
-        var result = this._transport.invokeMutation(mutationRef.name, mutationRef.variables);
-        var withRefPromise = result.then(function (res) {
-            var obj = tslib.__assign(tslib.__assign({}, res), { source: SOURCE_SERVER, ref: mutationRef, fetchTime: Date.now().toLocaleString() });
+    executeMutation(mutationRef) {
+        const result = this._transport.invokeMutation(mutationRef.name, mutationRef.variables);
+        const withRefPromise = result.then(res => {
+            const obj = Object.assign(Object.assign({}, res), { source: SOURCE_SERVER, ref: mutationRef, fetchTime: Date.now().toLocaleString() });
             return obj;
         });
         this._inflight.push(result);
-        var removePromise = function () {
-            return (_this._inflight = _this._inflight.filter(function (promise) { return promise !== result; }));
-        };
+        const removePromise = () => (this._inflight = this._inflight.filter(promise => promise !== result));
         result.then(removePromise, removePromise);
         return withRefPromise;
-    };
-    return MutationManager;
-}());
+    }
+}
 /**
  * Execute Mutation
  * @param mutationRef mutation to execute
@@ -860,7 +807,7 @@ function executeMutation(mutationRef) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var FIREBASE_DATA_CONNECT_EMULATOR_HOST_VAR = 'FIREBASE_DATA_CONNECT_EMULATOR_HOST';
+const FIREBASE_DATA_CONNECT_EMULATOR_HOST_VAR = 'FIREBASE_DATA_CONNECT_EMULATOR_HOST';
 /**
  *
  * @param fullHost
@@ -868,18 +815,18 @@ var FIREBASE_DATA_CONNECT_EMULATOR_HOST_VAR = 'FIREBASE_DATA_CONNECT_EMULATOR_HO
  * @internal
  */
 function parseOptions(fullHost) {
-    var _a = fullHost.split('://'), protocol = _a[0], hostName = _a[1];
-    var isSecure = protocol === 'https';
-    var _b = hostName.split(':'), host = _b[0], portAsString = _b[1];
-    var port = Number(portAsString);
-    return { host: host, port: port, sslEnabled: isSecure };
+    const [protocol, hostName] = fullHost.split('://');
+    const isSecure = protocol === 'https';
+    const [host, portAsString] = hostName.split(':');
+    const port = Number(portAsString);
+    return { host, port, sslEnabled: isSecure };
 }
 /**
  * Class representing Firebase Data Connect
  */
-var DataConnect = /** @class */ (function () {
+class DataConnect {
     // @internal
-    function DataConnect(app, 
+    constructor(app, 
     // TODO(mtewani): Replace with _dataConnectOptions in the future
     dataConnectOptions, _authProvider, _appCheckProvider) {
         this.app = app;
@@ -890,7 +837,7 @@ var DataConnect = /** @class */ (function () {
         this._initialized = false;
         this._isUsingGeneratedSdk = false;
         if (typeof process !== 'undefined' && process.env) {
-            var host = process.env[FIREBASE_DATA_CONNECT_EMULATOR_HOST_VAR];
+            const host = process.env[FIREBASE_DATA_CONNECT_EMULATOR_HOST_VAR];
             if (host) {
                 logDebug('Found custom host. Using emulator');
                 this.isEmulator = true;
@@ -899,23 +846,23 @@ var DataConnect = /** @class */ (function () {
         }
     }
     // @internal
-    DataConnect.prototype._useGeneratedSdk = function () {
+    _useGeneratedSdk() {
         if (!this._isUsingGeneratedSdk) {
             this._isUsingGeneratedSdk = true;
         }
-    };
-    DataConnect.prototype._delete = function () {
+    }
+    _delete() {
         app._removeServiceInstance(this.app, 'data-connect', JSON.stringify(this.getSettings()));
         return Promise.resolve();
-    };
+    }
     // @internal
-    DataConnect.prototype.getSettings = function () {
-        var copy = JSON.parse(JSON.stringify(this.dataConnectOptions));
+    getSettings() {
+        const copy = JSON.parse(JSON.stringify(this.dataConnectOptions));
         delete copy.projectId;
         return copy;
-    };
+    }
     // @internal
-    DataConnect.prototype.setInitialized = function () {
+    setInitialized() {
         if (this._initialized) {
             return;
         }
@@ -936,18 +883,17 @@ var DataConnect = /** @class */ (function () {
         }
         this._queryManager = new QueryManager(this._transport);
         this._mutationManager = new MutationManager(this._transport);
-    };
+    }
     // @internal
-    DataConnect.prototype.enableEmulator = function (transportOptions) {
+    enableEmulator(transportOptions) {
         if (this._initialized) {
             logError('enableEmulator called after initialization');
             throw new DataConnectError(Code.ALREADY_INITIALIZED, 'DataConnect instance already initialized!');
         }
         this._transportOptions = transportOptions;
         this.isEmulator = true;
-    };
-    return DataConnect;
-}());
+    }
+}
 /**
  * Connect to the DataConnect Emulator
  * @param dc Data Connect instance
@@ -955,13 +901,12 @@ var DataConnect = /** @class */ (function () {
  * @param port port of emulator server
  * @param sslEnabled use https
  */
-function connectDataConnectEmulator(dc, host, port, sslEnabled) {
-    if (sslEnabled === void 0) { sslEnabled = false; }
-    dc.enableEmulator({ host: host, port: port, sslEnabled: sslEnabled });
+function connectDataConnectEmulator(dc, host, port, sslEnabled = false) {
+    dc.enableEmulator({ host, port, sslEnabled });
 }
 function getDataConnect(appOrOptions, optionalOptions) {
-    var app$1;
-    var dcOptions;
+    let app$1;
+    let dcOptions;
     if ('location' in appOrOptions) {
         dcOptions = appOrOptions;
         app$1 = app.getApp();
@@ -973,12 +918,12 @@ function getDataConnect(appOrOptions, optionalOptions) {
     if (!app$1 || Object.keys(app$1).length === 0) {
         app$1 = app.getApp();
     }
-    var provider = app._getProvider(app$1, 'data-connect');
-    var identifier = JSON.stringify(dcOptions);
+    const provider = app._getProvider(app$1, 'data-connect');
+    const identifier = JSON.stringify(dcOptions);
     if (provider.isInitialized(identifier)) {
-        var dcInstance = provider.getImmediate({ identifier: identifier });
-        var options = provider.getOptions(identifier);
-        var optionsValid = Object.keys(options).length > 0;
+        const dcInstance = provider.getImmediate({ identifier });
+        const options = provider.getOptions(identifier);
+        const optionsValid = Object.keys(options).length > 0;
         if (optionsValid) {
             logDebug('Re-using cached instance');
             return dcInstance;
@@ -999,13 +944,13 @@ function getDataConnect(appOrOptions, optionalOptions) {
  * @internal
  */
 function validateDCOptions(dcOptions) {
-    var fields = ['connector', 'location', 'service'];
+    const fields = ['connector', 'location', 'service'];
     if (!dcOptions) {
         throw new DataConnectError(Code.INVALID_ARGUMENT, 'DC Option Required');
     }
-    fields.forEach(function (field) {
+    fields.forEach(field => {
         if (dcOptions[field] === null || dcOptions[field] === undefined) {
-            throw new DataConnectError(Code.INVALID_ARGUMENT, "".concat(field, " Required"));
+            throw new DataConnectError(Code.INVALID_ARGUMENT, `${field} Required`);
         }
     });
     return true;
@@ -1020,25 +965,40 @@ function terminate(dataConnect) {
     // TODO(mtewani): Stop pending tasks
 }
 
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 function registerDataConnect(variant) {
     setSDKVersion(app.SDK_VERSION);
-    app._registerComponent(new component.Component('data-connect', function (container, _a) {
-        var settings = _a.instanceIdentifier, options = _a.options;
-        var app = container.getProvider('app').getImmediate();
-        var authProvider = container.getProvider('auth-internal');
-        var appCheckProvider = container.getProvider('app-check-internal');
-        var newOpts = options;
+    app._registerComponent(new component.Component('data-connect', (container, { instanceIdentifier: settings, options }) => {
+        const app = container.getProvider('app').getImmediate();
+        const authProvider = container.getProvider('auth-internal');
+        const appCheckProvider = container.getProvider('app-check-internal');
+        let newOpts = options;
         if (settings) {
             newOpts = JSON.parse(settings);
         }
         if (!app.options.projectId) {
             throw new DataConnectError(Code.INVALID_ARGUMENT, 'Project ID must be provided. Did you pass in a proper projectId to initializeApp?');
         }
-        return new DataConnect(app, tslib.__assign(tslib.__assign({}, newOpts), { projectId: app.options.projectId }), authProvider, appCheckProvider);
+        return new DataConnect(app, Object.assign(Object.assign({}, newOpts), { projectId: app.options.projectId }), authProvider, appCheckProvider);
     }, "PUBLIC" /* ComponentType.PUBLIC */).setMultipleInstances(true));
     app.registerVersion(name, version, variant);
     // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation
-    app.registerVersion(name, version, 'cjs5');
+    app.registerVersion(name, version, 'cjs2017');
 }
 
 /**
@@ -1089,7 +1049,7 @@ function queryRef(dcInstance, queryName, variables, initialCache) {
  * @returns `QueryRef`
  */
 function toQueryRef(serializedRef) {
-    var _a = serializedRef.refInfo, name = _a.name, variables = _a.variables, connectorConfig = _a.connectorConfig;
+    const { refInfo: { name, variables, connectorConfig } } = serializedRef;
     return queryRef(getDataConnect(connectorConfig), name, variables);
 }
 
@@ -1120,8 +1080,8 @@ function toQueryRef(serializedRef) {
  * @internal
  */
 function validateArgs(connectorConfig, dcOrVars, vars, validateVars) {
-    var dcInstance;
-    var realVars;
+    let dcInstance;
+    let realVars;
     if (dcOrVars && 'enableEmulator' in dcOrVars) {
         dcInstance = dcOrVars;
         realVars = vars;
@@ -1161,22 +1121,22 @@ function validateArgs(connectorConfig, dcOrVars, vars, validateVars) {
  * @returns `SubscriptionOptions`
  */
 function subscribe(queryRefOrSerializedResult, observerOrOnNext, onError, onComplete) {
-    var ref;
-    var initialCache;
+    let ref;
+    let initialCache;
     if ('refInfo' in queryRefOrSerializedResult) {
-        var serializedRef = queryRefOrSerializedResult;
-        var data = serializedRef.data, source = serializedRef.source, fetchTime = serializedRef.fetchTime;
+        const serializedRef = queryRefOrSerializedResult;
+        const { data, source, fetchTime } = serializedRef;
         initialCache = {
-            data: data,
-            source: source,
-            fetchTime: fetchTime
+            data,
+            source,
+            fetchTime
         };
         ref = toQueryRef(serializedRef);
     }
     else {
         ref = queryRefOrSerializedResult;
     }
-    var onResult = undefined;
+    let onResult = undefined;
     if (typeof observerOrOnNext === 'function') {
         onResult = observerOrOnNext;
     }