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

package/dist/index.cjs.js

@@ -0,0 +1,965 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var app = require('@firebase/app');
+var component = require('@firebase/component');
+var logger$1 = require('@firebase/logger');
+var util = require('@firebase/util');
+
+const name = "@firebase/data-connect";
+const 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. */
+let 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.
+ */
+const logger = new logger$1.Logger('@firebase/data-connect');
+function setLogLevel(logLevel) {
+    logger.setLogLevel(logLevel);
+}
+function logDebug(msg) {
+    // if (logger.logLevel <= LogLevel.DEBUG) {
+    logger.debug(`DataConnect (${SDK_VERSION}): ${msg}`);
+    // }
+}
+function logError(msg) {
+    // if (logger.logLevel <= LogLevel.ERROR) {
+    logger.error(`DataConnect (${SDK_VERSION}): ${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.
+ */
+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(auth => (this.auth_ = auth));
+        }
+    }
+    getToken(forceRefresh) {
+        if (!this.auth_) {
+            return new Promise((resolve, reject) => {
+                setTimeout(() => {
+                    if (this.auth_) {
+                        this.getToken(forceRefresh).then(resolve, reject);
+                    }
+                    else {
+                        resolve(null);
+                    }
+                }, 0);
+            });
+        }
+        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;
+            }
+            else {
+                logError('Error received when attempting to retrieve token: ' +
+                    JSON.stringify(error));
+                return Promise.reject(error);
+            }
+        });
+    }
+    addTokenChangeListener(listener) {
+        var _a;
+        (_a = this.auth_) === null || _a === void 0 ? void 0 : _a.addAuthTokenListener(listener);
+    }
+    removeTokenChangeListener(listener) {
+        this.authProvider_
+            .get()
+            .then(auth => auth.removeAuthTokenListener(listener));
+    }
+}
+class EmulatorTokenProvider {
+    constructor(accessToken) {
+        this.accessToken = accessToken;
+    }
+    getToken(forceRefresh) {
+        return Promise.resolve({
+            accessToken: this.accessToken
+        });
+    }
+    addTokenChangeListener(listener) {
+        // Invoke the listener immediately to match the behavior in Firebase Auth
+        // (see packages/auth/src/auth.js#L1807)
+        listener(this.accessToken);
+    }
+    removeTokenChangeListener(listener) { }
+    notifyForInvalidToken() { }
+}
+/** A string that is treated as an admin access token by the RTDB emulator. Used by Admin SDK. */
+EmulatorTokenProvider.OWNER = 'owner';
+
+/**
+ * @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.
+ */
+const QueryStr = 'query';
+const MutationStr = 'mutation';
+const SOURCE_SERVER = 'SERVER';
+const 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.
+ */
+let encoderImpl;
+function setEncoder(encoder) {
+    encoderImpl = encoder;
+}
+setEncoder(o => 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,
+            refInfo: {
+                name: queryRef.name,
+                variables: queryRef.variables,
+                connectorConfig: Object.assign({ projectId: queryRef.dataConnect.app.options.projectId }, queryRef.dataConnect.getSettings())
+            },
+            fetchTime: Date.now().toLocaleString(),
+            source
+        };
+    };
+}
+class QueryManager {
+    constructor(transport) {
+        this.transport = transport;
+        this._queries = new Map();
+    }
+    track(queryName, variables, initialCache) {
+        const ref = {
+            name: queryName,
+            variables,
+            refType: QueryStr
+        };
+        const key = encoderImpl(ref);
+        const newTrackedQuery = {
+            ref,
+            subscriptions: [],
+            currentCache: initialCache || null,
+            lastError: null
+        };
+        // @ts-ignore
+        setIfNotExists(this._queries, key, newTrackedQuery);
+        return this._queries.get(key);
+    }
+    addSubscription(queryRef, onResultCallback, onErrorCallback, initialCache) {
+        const key = encoderImpl({
+            name: queryRef.name,
+            variables: queryRef.variables,
+            refType: QueryStr
+        });
+        const trackedQuery = this._queries.get(key);
+        const subscription = {
+            userCallback: onResultCallback,
+            errCallback: onErrorCallback
+        };
+        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.');
+            if (!trackedQuery.currentCache ||
+                (trackedQuery.currentCache &&
+                    compareDates(trackedQuery.currentCache.fetchTime, initialCache.fetchTime))) {
+                trackedQuery.currentCache = initialCache;
+            }
+        }
+        if (trackedQuery.currentCache !== null) {
+            const 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
+        });
+        if (!trackedQuery.currentCache) {
+            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, err => { });
+        }
+        return unsubscribe;
+    }
+    executeQuery(queryRef) {
+        const key = encoderImpl({
+            name: queryRef.name,
+            variables: queryRef.variables,
+            refType: QueryStr
+        });
+        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
+            };
+            return result;
+        }, err => {
+            trackedQuery.lastError = err;
+            trackedQuery.subscriptions.forEach(subscription => {
+                if (subscription.errCallback) {
+                    subscription.errCallback(err);
+                }
+            });
+            throw err;
+        });
+        return newR;
+    }
+    enableEmulator(host, port) {
+        this.transport.useEmulator(host, port);
+    }
+}
+function compareDates(str1, str2) {
+    const date1 = new Date(str1);
+    const 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.
+ */
+const 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. */
+class DataConnectError extends util.FirebaseError {
+    /** @hideconstructor */
+    constructor(
+    /**
+     * The backend error code associated with this error.
+     */
+    code, 
+    /**
+     * A custom error description.
+     */
+    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 = () => `${this.name}: [code=${this.code}]: ${this.message}`;
+    }
+}
+
+/**
+ * @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) {
+    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 += `:${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 `${baseUrl}/v1alpha/projects/${project}/locations/${location}/services/${service}/connectors/${connector}`;
+}
+function addToken(url, apiKey) {
+    if (!apiKey) {
+        return url;
+    }
+    const 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.
+ */
+let connectFetch = globalThis.fetch;
+function dcFetch(url, body, { signal }, accessToken) {
+    if (!connectFetch) {
+        throw new DataConnectError(Code.OTHER, 'No Fetch Implementation detected!');
+    }
+    const headers = {
+        'Content-Type': 'application/json'
+    };
+    if (accessToken) {
+        headers['X-Firebase-Auth-Token'] = accessToken;
+    }
+    const bodyStr = JSON.stringify(body);
+    logDebug(`Making request out to ${url} with body: ${bodyStr}`);
+    return connectFetch(url, {
+        body: bodyStr,
+        method: 'POST',
+        headers,
+        signal
+    })
+        .then(async (response) => {
+        let jsonResponse = null;
+        try {
+            jsonResponse = await response.json();
+        }
+        catch (e) {
+            throw new DataConnectError(Code.OTHER, JSON.stringify(e));
+        }
+        if (response.status >= 400) {
+            logError('Error while performing request: ' + JSON.stringify(jsonResponse));
+            throw new DataConnectError(Code.OTHER, JSON.stringify(jsonResponse));
+        }
+        return jsonResponse;
+    })
+        .then(res => {
+        if (res.errors && res.errors.length) {
+            const 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.
+ */
+class RESTTransport {
+    constructor(options, apiKey, authProvider, transportOptions) {
+        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 = (queryName, body) => {
+            const abortController = new AbortController();
+            // TODO(mtewani): Update to proper value
+            const withAuth = this.getWithAuth().then(() => {
+                return 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.accessToken);
+            });
+            return {
+                then: withAuth.then.bind(withAuth)
+            };
+        };
+        this.invokeMutation = (mutationName, body) => {
+            const abortController = new AbortController();
+            const taskResult = this.getWithAuth().then(() => {
+                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.accessToken);
+            });
+            return {
+                then: taskResult.then.bind(taskResult),
+                // catch: taskResult.catch.bind(taskResult),
+                // finally: taskResult.finally.bind(taskResult),
+                cancel: () => 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;
+        }
+        const { location, projectId: project, connector, service } = options;
+        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;
+    }
+    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;
+        }
+        if (typeof isSecure !== 'undefined') {
+            this.secure = isSecure;
+        }
+    }
+    onTokenChanged(newToken) {
+        this.accessToken = newToken;
+    }
+    getWithAuth() {
+        let starterPromise = new Promise(resolve => resolve(this.accessToken));
+        if (!this.authInitialized_) {
+            if (this.authProvider) {
+                starterPromise = this.authProvider
+                    .getToken(/*forceToken=*/ false)
+                    .then(data => {
+                    if (!data) {
+                        return null;
+                    }
+                    this.accessToken = data.accessToken;
+                    return this.accessToken;
+                });
+            }
+            else {
+                starterPromise = new Promise(resolve => resolve(''));
+            }
+        }
+        return starterPromise;
+    }
+}
+
+/**
+ * @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();
+    const ref = {
+        dataConnect: dcInstance,
+        name: queryName,
+        refType: MutationStr,
+        variables: variables
+    };
+    return ref;
+}
+class MutationManager {
+    constructor(transport) {
+        this.transport = transport;
+        this._inflight = [];
+    }
+    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);
+        const removePromise = () => (this._inflight = this._inflight.filter(promise => promise !== result));
+        result.then(removePromise, removePromise);
+        return withRefPromise;
+    }
+}
+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.
+ */
+const FIREBASE_DATA_CONNECT_EMULATOR_HOST_VAR = 'FIREBASE_DATA_CONNECT_EMULATOR_HOST';
+/**
+ *
+ * @param fullHost
+ * @returns TransportOptions
+ * @internal
+ */
+function parseOptions(fullHost) {
+    const [protocol, hostName] = fullHost.split('://');
+    const isSecure = protocol === 'https';
+    const [host, portAsString] = hostName.split(':');
+    const port = Number(portAsString);
+    return { host, port, sslEnabled: isSecure };
+}
+class DataConnect {
+    constructor(app, dataConnectOptions, authProvider) {
+        this.app = app;
+        this.dataConnectOptions = dataConnectOptions;
+        this.authProvider = authProvider;
+        this.isEmulator = false;
+        this.initialized = false;
+        if (typeof process !== 'undefined' && process.env) {
+            const host = process.env[FIREBASE_DATA_CONNECT_EMULATOR_HOST_VAR];
+            if (host) {
+                logDebug('Found custom host. Using emulator');
+                this.isEmulator = true;
+                this.transportOptions = parseOptions(host);
+            }
+        }
+    }
+    _delete() {
+        app._removeServiceInstance(this.app, 'data-connect', JSON.stringify(this.getSettings()));
+        return Promise.resolve();
+    }
+    getSettings() {
+        const copy = JSON.parse(JSON.stringify(this.dataConnectOptions));
+        delete copy.projectId;
+        return copy;
+    }
+    setInitialized() {
+        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(token => {
+                logDebug(`New Token Available: ${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);
+    }
+    enableEmulator(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;
+    }
+}
+function connectDataConnectEmulator(dc, host, port, sslEnabled = false) {
+    dc.enableEmulator({ host, port, sslEnabled });
+}
+function getDataConnect(appOrOptions, optionalOptions) {
+    let app$1;
+    let dcOptions;
+    if ('location' in appOrOptions) {
+        dcOptions = appOrOptions;
+        app$1 = app.getApp();
+    }
+    else {
+        dcOptions = optionalOptions;
+        app$1 = appOrOptions;
+    }
+    if (!app$1) {
+        app$1 = app.getApp();
+    }
+    const provider = app._getProvider(app$1, 'data-connect');
+    const identifier = JSON.stringify(dcOptions);
+    if (provider.isInitialized(identifier)) {
+        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;
+        }
+    }
+    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
+}
+
+/**
+ * @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', (container, { instanceIdentifier: settings, options }) => {
+        const app = container.getProvider('app').getImmediate();
+        const authProvider = container.getProvider('auth-internal');
+        let newOpts = options;
+        if (settings) {
+            newOpts = JSON.parse(settings);
+        }
+        return new DataConnect(app, Object.assign(Object.assign({}, newOpts), { projectId: app.options.projectId }), authProvider);
+    }, "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, 'cjs2017');
+}
+
+/**
+ * @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) {
+    const { refInfo: { name, variables, connectorConfig } } = serializedRef;
+    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) {
+    let ref;
+    let initialCache;
+    if ('refInfo' in queryRefOrSerializedResult) {
+        let serializedRef = queryRefOrSerializedResult;
+        const { data, source, fetchTime } = serializedRef;
+        initialCache = {
+            data,
+            source,
+            fetchTime
+        };
+        ref = toQueryRef(serializedRef);
+    }
+    else {
+        ref = queryRefOrSerializedResult;
+    }
+    let 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) => {
+// })
+
+exports.DataConnect = DataConnect;
+exports.EmulatorTokenProvider = EmulatorTokenProvider;
+exports.FIREBASE_DATA_CONNECT_EMULATOR_HOST_VAR = FIREBASE_DATA_CONNECT_EMULATOR_HOST_VAR;
+exports.FirebaseAuthProvider = FirebaseAuthProvider;
+exports.MutationManager = MutationManager;
+exports.MutationStr = MutationStr;
+exports.QueryStr = QueryStr;
+exports.SOURCE_CACHE = SOURCE_CACHE;
+exports.SOURCE_SERVER = SOURCE_SERVER;
+exports.connectDataConnectEmulator = connectDataConnectEmulator;
+exports.executeMutation = executeMutation;
+exports.executeQuery = executeQuery;
+exports.getDataConnect = getDataConnect;
+exports.mutationRef = mutationRef;
+exports.parseOptions = parseOptions;
+exports.queryRef = queryRef;
+exports.setLogLevel = setLogLevel;
+exports.subscribe = subscribe;
+exports.terminate = terminate;
+exports.toQueryRef = toQueryRef;
+//# sourceMappingURL=index.cjs.js.map