@firebase/data-connect 0.0.1-dataconnect-preview.f2ddc3d7b

package/dist/index.esm5.js

@@ -0,0 +1,966 @@
+import { __assign, __extends, __awaiter, __generator } from 'tslib';
+import { _removeServiceInstance, getApp, _getProvider, _registerComponent, registerVersion, SDK_VERSION as SDK_VERSION$1 } from '@firebase/app';
+import { Component } from '@firebase/component';
+import { Logger } from '@firebase/logger';
+import { FirebaseError } from '@firebase/util';
+
+var name = "@firebase/data-connect";
+var version = "0.0.1";
+
+/**
+ * @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.
+ */
+/** The semver (www.semver.org) version of the SDK. */
+var SDK_VERSION = '';
+/**
+ * SDK_VERSION should be set before any database instance is created
+ * @internal
+ */
+function setSDKVersion(version) {
+    SDK_VERSION = version;
+}
+
+/**
+ * @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.
+ */
+var logger = new Logger('@firebase/data-connect');
+function setLogLevel(logLevel) {
+    logger.setLogLevel(logLevel);
+}
+function logDebug(msg) {
+    // if (logger.logLevel <= LogLevel.DEBUG) {
+    logger.debug("DataConnect (".concat(SDK_VERSION, "): ").concat(msg));
+    // }
+}
+function logError(msg) {
+    // if (logger.logLevel <= LogLevel.ERROR) {
+    logger.error("DataConnect (".concat(SDK_VERSION, "): ").concat(msg));
+    // }
+}
+
+/**
+ * @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.
+ */
+var FirebaseAuthProvider = /** @class */ (function () {
+    function FirebaseAuthProvider(appName, options, authProvider_) {
+        var _this = this;
+        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); });
+        }
+    }
+    FirebaseAuthProvider.prototype.getToken = function (forceRefresh) {
+        var _this = this;
+        if (!this.auth_) {
+            return new Promise(function (resolve, reject) {
+                setTimeout(function () {
+                    if (_this.auth_) {
+                        _this.getToken(forceRefresh).then(resolve, reject);
+                    }
+                    else {
+                        resolve(null);
+                    }
+                }, 0);
+            });
+        }
+        return this.auth_.getToken(forceRefresh).catch(function (error) {
+            if (error && error.code === 'auth/token-not-initialized') {
+                logDebug('Got auth/token-not-initialized error.  Treating as null token.');
+                return null;
+            }
+            else {
+                logError('Error received when attempting to retrieve token: ' +
+                    JSON.stringify(error));
+                return Promise.reject(error);
+            }
+        });
+    };
+    FirebaseAuthProvider.prototype.addTokenChangeListener = function (listener) {
+        var _a;
+        (_a = this.auth_) === null || _a === void 0 ? void 0 : _a.addAuthTokenListener(listener);
+    };
+    FirebaseAuthProvider.prototype.removeTokenChangeListener = function (listener) {
+        this.authProvider_
+            .get()
+            .then(function (auth) { return auth.removeAuthTokenListener(listener); });
+    };
+    return FirebaseAuthProvider;
+}());
+var EmulatorTokenProvider = /** @class */ (function () {
+    function EmulatorTokenProvider(accessToken) {
+        this.accessToken = accessToken;
+    }
+    EmulatorTokenProvider.prototype.getToken = function (forceRefresh) {
+        return Promise.resolve({
+            accessToken: this.accessToken
+        });
+    };
+    EmulatorTokenProvider.prototype.addTokenChangeListener = function (listener) {
+        // Invoke the listener immediately to match the behavior in Firebase Auth
+        // (see packages/auth/src/auth.js#L1807)
+        listener(this.accessToken);
+    };
+    EmulatorTokenProvider.prototype.removeTokenChangeListener = function (listener) { };
+    EmulatorTokenProvider.prototype.notifyForInvalidToken = function () { };
+    /** A string that is treated as an admin access token by the RTDB emulator. Used by Admin SDK. */
+    EmulatorTokenProvider.OWNER = 'owner';
+    return EmulatorTokenProvider;
+}());
+
+/**
+ * @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.
+ */
+var QueryStr = 'query';
+var MutationStr = 'mutation';
+var SOURCE_SERVER = 'SERVER';
+var SOURCE_CACHE = 'CACHE';
+
+/**
+ * @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.
+ */
+var encoderImpl;
+function setEncoder(encoder) {
+    encoderImpl = encoder;
+}
+setEncoder(function (o) { return JSON.stringify(o); });
+
+/**
+ * @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 setIfNotExists(map, key, val) {
+    if (!map.has(key)) {
+        map.set(key, val);
+    }
+}
+
+/**
+ * @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 getRefSerializer(queryRef, data, source) {
+    return function toJSON() {
+        return {
+            data: data,
+            refInfo: {
+                name: queryRef.name,
+                variables: queryRef.variables,
+                connectorConfig: __assign({ projectId: queryRef.dataConnect.app.options.projectId }, queryRef.dataConnect.getSettings())
+            },
+            fetchTime: Date.now().toLocaleString(),
+            source: source
+        };
+    };
+}
+var QueryManager = /** @class */ (function () {
+    function QueryManager(transport) {
+        this.transport = transport;
+        this._queries = new Map();
+    }
+    QueryManager.prototype.track = function (queryName, variables, initialCache) {
+        var ref = {
+            name: queryName,
+            variables: variables,
+            refType: QueryStr
+        };
+        var key = encoderImpl(ref);
+        var newTrackedQuery = {
+            ref: ref,
+            subscriptions: [],
+            currentCache: initialCache || null,
+            lastError: null
+        };
+        // @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({
+            name: queryRef.name,
+            variables: queryRef.variables,
+            refType: QueryStr
+        });
+        var trackedQuery = this._queries.get(key);
+        var subscription = {
+            userCallback: onResultCallback,
+            errCallback: onErrorCallback
+        };
+        var unsubscribe = function () {
+            var trackedQuery = _this._queries.get(key);
+            trackedQuery.subscriptions = trackedQuery.subscriptions.filter(function (sub) { return sub !== subscription; });
+        };
+        if (initialCache && trackedQuery.currentCache !== initialCache) {
+            logDebug('Initial cache found. Comparing dates.');
+            if (!trackedQuery.currentCache ||
+                (trackedQuery.currentCache &&
+                    compareDates(trackedQuery.currentCache.fetchTime, initialCache.fetchTime))) {
+                trackedQuery.currentCache = initialCache;
+            }
+        }
+        if (trackedQuery.currentCache !== null) {
+            var cachedData = trackedQuery.currentCache.data;
+            onResultCallback({
+                data: cachedData,
+                source: SOURCE_CACHE,
+                ref: queryRef,
+                toJSON: getRefSerializer(queryRef, trackedQuery.currentCache.data, SOURCE_CACHE),
+                fetchTime: trackedQuery.currentCache.fetchTime
+            });
+            if (trackedQuery.lastError !== null && onErrorCallback) {
+                onErrorCallback(undefined);
+            }
+        }
+        trackedQuery.subscriptions.push({
+            userCallback: onResultCallback,
+            errCallback: onErrorCallback,
+            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);
+            // We want to ignore the error and let subscriptions handle it
+            promise.then(undefined, function (err) { });
+        }
+        return unsubscribe;
+    };
+    QueryManager.prototype.executeQuery = function (queryRef) {
+        var key = encoderImpl({
+            name: queryRef.name,
+            variables: queryRef.variables,
+            refType: QueryStr
+        });
+        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 = __assign(__assign({}, res), { source: SOURCE_SERVER, ref: queryRef, toJSON: getRefSerializer(queryRef, res.data, SOURCE_SERVER), fetchTime: fetchTime });
+            trackedQuery.subscriptions.forEach(function (subscription) {
+                subscription.userCallback(result);
+            });
+            trackedQuery.currentCache = {
+                data: res.data,
+                source: SOURCE_CACHE,
+                fetchTime: fetchTime
+            };
+            return result;
+        }, function (err) {
+            trackedQuery.lastError = err;
+            trackedQuery.subscriptions.forEach(function (subscription) {
+                if (subscription.errCallback) {
+                    subscription.errCallback(err);
+                }
+            });
+            throw err;
+        });
+        return newR;
+    };
+    QueryManager.prototype.enableEmulator = function (host, port) {
+        this.transport.useEmulator(host, port);
+    };
+    return QueryManager;
+}());
+function compareDates(str1, str2) {
+    var date1 = new Date(str1);
+    var date2 = new Date(str2);
+    return date1.getTime() < date2.getTime();
+}
+
+/**
+ * @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.
+ */
+var Code = {
+    OTHER: 'other',
+    ALREADY_INITIALIZED: 'already-initialized',
+    NOT_INITIALIZED: 'not-initialized',
+    NOT_SUPPORTED: 'not-supported',
+    INVALID_ARGUMENT: 'invalid-argument',
+    PARTIAL_ERROR: 'partial-error'
+};
+/** An error returned by a DataConnect operation. */
+var DataConnectError = /** @class */ (function (_super) {
+    __extends(DataConnectError, _super);
+    /** @hideconstructor */
+    function DataConnectError(
+    /**
+     * The backend error code associated with this error.
+     */
+    code, 
+    /**
+     * A custom error description.
+     */
+    message) {
+        var _this = _super.call(this, code, message) || this;
+        _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;
+    }
+    return DataConnectError;
+}(FirebaseError));
+
+/**
+ * @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 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);
+    if (typeof port === 'number') {
+        baseUrl += ":".concat(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, "/v1alpha/projects/").concat(project, "/locations/").concat(location, "/services/").concat(service, "/connectors/").concat(connector);
+}
+function addToken(url, apiKey) {
+    if (!apiKey) {
+        return url;
+    }
+    var newUrl = new URL(url);
+    newUrl.searchParams.append('key', apiKey);
+    return newUrl.toString();
+}
+
+/**
+ * @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.
+ */
+var connectFetch = globalThis.fetch;
+function dcFetch(url, body, _a, accessToken) {
+    var _this = this;
+    var signal = _a.signal;
+    if (!connectFetch) {
+        throw new DataConnectError(Code.OTHER, 'No Fetch Implementation detected!');
+    }
+    var headers = {
+        'Content-Type': 'application/json'
+    };
+    if (accessToken) {
+        headers['X-Firebase-Auth-Token'] = accessToken;
+    }
+    var bodyStr = JSON.stringify(body);
+    logDebug("Making request out to ".concat(url, " with body: ").concat(bodyStr));
+    return connectFetch(url, {
+        body: bodyStr,
+        method: 'POST',
+        headers: headers,
+        signal: signal
+    })
+        .then(function (response) { return __awaiter(_this, void 0, void 0, function () {
+        var jsonResponse, e_1;
+        return __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:
+                    if (response.status >= 400) {
+                        logError('Error while performing request: ' + JSON.stringify(jsonResponse));
+                        throw new DataConnectError(Code.OTHER, JSON.stringify(jsonResponse));
+                    }
+                    return [2 /*return*/, jsonResponse];
+            }
+        });
+    }); })
+        .then(function (res) {
+        if (res.errors && res.errors.length) {
+            var stringified = JSON.stringify(res.errors);
+            logError('DataConnect error while performing request: ' + stringified);
+            throw new DataConnectError(Code.OTHER, stringified);
+        }
+        return res;
+    });
+}
+
+/**
+ * @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.
+ */
+var RESTTransport = /** @class */ (function () {
+    function RESTTransport(options, apiKey, authProvider, transportOptions) {
+        var _this = this;
+        this.apiKey = apiKey;
+        this.authProvider = authProvider;
+        this.host = '';
+        this.location = 'l';
+        this.connectorName = '';
+        this.secure = true;
+        this.project = 'p';
+        this.accessToken = null;
+        this.authInitialized_ = false;
+        // TODO(mtewani): Update U to include shape of body defined in line 13.
+        this.invokeQuery = function (queryName, body) {
+            var abortController = new AbortController();
+            // TODO(mtewani): Update to proper value
+            var withAuth = _this.getWithAuth().then(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.accessToken);
+            });
+            return {
+                then: withAuth.then.bind(withAuth)
+            };
+        };
+        this.invokeMutation = function (mutationName, body) {
+            var abortController = new AbortController();
+            var taskResult = _this.getWithAuth().then(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),
+                    operationName: mutationName,
+                    variables: body
+                }, abortController, _this.accessToken);
+            });
+            return {
+                then: taskResult.then.bind(taskResult),
+                // catch: taskResult.catch.bind(taskResult),
+                // finally: taskResult.finally.bind(taskResult),
+                cancel: function () { return abortController.abort(); }
+            };
+        };
+        if (transportOptions) {
+            if (typeof transportOptions.port === 'number') {
+                this.port = transportOptions.port;
+            }
+            if (typeof transportOptions.sslEnabled !== 'undefined') {
+                this.secure = transportOptions.sslEnabled;
+            }
+            this.host = transportOptions.host;
+        }
+        var location = options.location, project = options.projectId, connector = options.connector, service = options.service;
+        if (location) {
+            this.location = location;
+        }
+        if (project) {
+            this.project = project;
+        }
+        this.serviceName = service;
+        if (!connector) {
+            throw new DataConnectError(Code.INVALID_ARGUMENT, 'Connector Name required!');
+        }
+        this.connectorName = connector;
+    }
+    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) {
+        this.host = host;
+        if (typeof port === 'number') {
+            this.port = port;
+        }
+        if (typeof isSecure !== 'undefined') {
+            this.secure = isSecure;
+        }
+    };
+    RESTTransport.prototype.onTokenChanged = function (newToken) {
+        this.accessToken = newToken;
+    };
+    RESTTransport.prototype.getWithAuth = function () {
+        var _this = this;
+        var starterPromise = new Promise(function (resolve) {
+            return resolve(_this.accessToken);
+        });
+        if (!this.authInitialized_) {
+            if (this.authProvider) {
+                starterPromise = this.authProvider
+                    .getToken(/*forceToken=*/ false)
+                    .then(function (data) {
+                    if (!data) {
+                        return null;
+                    }
+                    _this.accessToken = data.accessToken;
+                    return _this.accessToken;
+                });
+            }
+            else {
+                starterPromise = new Promise(function (resolve) { return resolve(''); });
+            }
+        }
+        return starterPromise;
+    };
+    return RESTTransport;
+}());
+
+/**
+ * @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 mutationRef(dcInstance, queryName, variables) {
+    dcInstance.setInitialized();
+    var ref = {
+        dataConnect: dcInstance,
+        name: queryName,
+        refType: MutationStr,
+        variables: variables
+    };
+    return ref;
+}
+var MutationManager = /** @class */ (function () {
+    function MutationManager(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 = __assign(__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; }));
+        };
+        result.then(removePromise, removePromise);
+        return withRefPromise;
+    };
+    return MutationManager;
+}());
+function executeMutation(mutationRef) {
+    return mutationRef.dataConnect._mutationManager.executeMutation(mutationRef);
+}
+
+/**
+ * @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.
+ */
+var FIREBASE_DATA_CONNECT_EMULATOR_HOST_VAR = 'FIREBASE_DATA_CONNECT_EMULATOR_HOST';
+/**
+ *
+ * @param fullHost
+ * @returns TransportOptions
+ * @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 };
+}
+var DataConnect = /** @class */ (function () {
+    function DataConnect(app, dataConnectOptions, authProvider) {
+        this.app = app;
+        this.dataConnectOptions = dataConnectOptions;
+        this.authProvider = authProvider;
+        this.isEmulator = false;
+        this.initialized = false;
+        if (typeof process !== 'undefined' && process.env) {
+            var host = process.env[FIREBASE_DATA_CONNECT_EMULATOR_HOST_VAR];
+            if (host) {
+                logDebug('Found custom host. Using emulator');
+                this.isEmulator = true;
+                this.transportOptions = parseOptions(host);
+            }
+        }
+    }
+    DataConnect.prototype._delete = function () {
+        _removeServiceInstance(this.app, 'data-connect', JSON.stringify(this.getSettings()));
+        return Promise.resolve();
+    };
+    DataConnect.prototype.getSettings = function () {
+        var copy = JSON.parse(JSON.stringify(this.dataConnectOptions));
+        delete copy.projectId;
+        return copy;
+    };
+    DataConnect.prototype.setInitialized = function () {
+        var _this = this;
+        if (this.initialized) {
+            return;
+        }
+        if (this.transportClass === undefined) {
+            logDebug('transportClass not provided. Defaulting to RESTTransport.');
+            this.transportClass = RESTTransport;
+        }
+        if (this.authProvider) {
+            this.authTokenProvider = this.isEmulator
+                ? new EmulatorTokenProvider(EmulatorTokenProvider.OWNER)
+                : new FirebaseAuthProvider(this.app.name, this.app.options, this.authProvider);
+            this.authTokenProvider.addTokenChangeListener(function (token) {
+                logDebug("New Token Available: ".concat(token));
+                _this._transport.onTokenChanged(token);
+            });
+        }
+        this.initialized = true;
+        this._transport = new this.transportClass(this.dataConnectOptions, this.app.options.apiKey, this.authTokenProvider);
+        if (this.transportOptions) {
+            this._transport.useEmulator(this.transportOptions.host, this.transportOptions.port, this.transportOptions.sslEnabled);
+        }
+        this._queryManager = new QueryManager(this._transport);
+        this._mutationManager = new MutationManager(this._transport);
+    };
+    DataConnect.prototype.enableEmulator = function (transportOptions) {
+        if (this.initialized) {
+            logError('enableEmulator called without initializing');
+            throw new DataConnectError(Code.ALREADY_INITIALIZED, 'DataConnect instance already initialized!');
+        }
+        this.transportOptions = transportOptions;
+        this.isEmulator = true;
+    };
+    return DataConnect;
+}());
+function connectDataConnectEmulator(dc, host, port, sslEnabled) {
+    if (sslEnabled === void 0) { sslEnabled = false; }
+    dc.enableEmulator({ host: host, port: port, sslEnabled: sslEnabled });
+}
+function getDataConnect(appOrOptions, optionalOptions) {
+    var app;
+    var dcOptions;
+    if ('location' in appOrOptions) {
+        dcOptions = appOrOptions;
+        app = getApp();
+    }
+    else {
+        dcOptions = optionalOptions;
+        app = appOrOptions;
+    }
+    if (!app) {
+        app = getApp();
+    }
+    var provider = _getProvider(app, 'data-connect');
+    var 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;
+        if (optionsValid) {
+            logDebug('Re-using cached instance');
+            return dcInstance;
+        }
+    }
+    if (!dcOptions) {
+        throw new DataConnectError(Code.INVALID_ARGUMENT, 'DC Option Required');
+    }
+    logDebug('Creating new DataConnect instance');
+    // Initialize with options.
+    return provider.initialize({
+        instanceIdentifier: identifier,
+        options: dcOptions
+    });
+}
+function terminate(dataConnect) {
+    dataConnect._delete();
+    // TODO(mtewani): Stop pending tasks
+}
+
+function registerDataConnect(variant) {
+    setSDKVersion(SDK_VERSION$1);
+    _registerComponent(new 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 newOpts = options;
+        if (settings) {
+            newOpts = JSON.parse(settings);
+        }
+        return new DataConnect(app, __assign(__assign({}, newOpts), { projectId: app.options.projectId }), authProvider);
+    }, "PUBLIC" /* ComponentType.PUBLIC */).setMultipleInstances(true));
+    registerVersion(name, version, variant);
+    // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation
+    registerVersion(name, version, 'esm5');
+}
+
+/**
+ * @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 executeQuery(queryRef) {
+    return queryRef.dataConnect._queryManager.executeQuery(queryRef);
+}
+function queryRef(dcInstance, queryName, variables, initialCache) {
+    dcInstance.setInitialized();
+    dcInstance._queryManager.track(queryName, variables, initialCache);
+    return {
+        dataConnect: dcInstance,
+        refType: QueryStr,
+        name: queryName,
+        variables: variables
+    };
+}
+function toQueryRef(serializedRef) {
+    var _a = serializedRef.refInfo, name = _a.name, variables = _a.variables, connectorConfig = _a.connectorConfig;
+    return queryRef(getDataConnect(connectorConfig), name, variables);
+}
+
+/**
+ * @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 subscribe(queryRefOrSerializedResult, observerOrOnNext, onError, onComplete) {
+    var ref;
+    var initialCache;
+    if ('refInfo' in queryRefOrSerializedResult) {
+        var serializedRef = queryRefOrSerializedResult;
+        var data = serializedRef.data, source = serializedRef.source, fetchTime = serializedRef.fetchTime;
+        initialCache = {
+            data: data,
+            source: source,
+            fetchTime: fetchTime
+        };
+        ref = toQueryRef(serializedRef);
+    }
+    else {
+        ref = queryRefOrSerializedResult;
+    }
+    var onResult = undefined;
+    if (typeof observerOrOnNext === 'function') {
+        onResult = observerOrOnNext;
+    }
+    else {
+        onResult = observerOrOnNext.onNext;
+        onError = observerOrOnNext.onErr;
+        observerOrOnNext.onComplete;
+    }
+    if (!onResult) {
+        throw new DataConnectError(Code.INVALID_ARGUMENT, 'Must provide onNext');
+    }
+    return ref.dataConnect._queryManager.addSubscription(ref, onResult, onError, initialCache);
+}
+
+/**
+ * Firebase Data Connect
+ *
+ * @packageDocumentation
+ */
+registerDataConnect();
+// import { getDataConnect, queryRef } from './api';
+// import { getApp } from '@firebase/app';
+// const app = getApp();
+// const dc = getDataConnect({ location: '', connector: '', serviceId: '', projectId: '' });
+// interface Response {
+//     name: string;
+// }
+// const converter: Converter<Response> = {
+//   fromDataConnect(input: string) {
+//     return { name: input };
+//   },
+//   fromType(input) {
+//     return input;
+//   }
+// };
+// const myRef = queryRef(dc, '', converter);
+// // Ref's shouldn't have access to their own cache, right?
+// const a = execute(myRef);
+// subscribe(myRef, (res) => {
+// })
+
+export { DataConnect, EmulatorTokenProvider, FIREBASE_DATA_CONNECT_EMULATOR_HOST_VAR, FirebaseAuthProvider, MutationManager, MutationStr, QueryStr, SOURCE_CACHE, SOURCE_SERVER, connectDataConnectEmulator, executeMutation, executeQuery, getDataConnect, mutationRef, parseOptions, queryRef, setLogLevel, subscribe, terminate, toQueryRef };
+//# sourceMappingURL=index.esm5.js.map