@firebase/data-connect 0.0.2-dataconnect-preview.388b61c7e → 0.0.3-canary.beaa4dffb

package/dist/node-esm/index.node.esm.js

@@ -25,7 +25,8 @@ const Code = {
     NOT_INITIALIZED: 'not-initialized',
     NOT_SUPPORTED: 'not-supported',
     INVALID_ARGUMENT: 'invalid-argument',
-    PARTIAL_ERROR: 'partial-error'
+    PARTIAL_ERROR: 'partial-error',
+    UNAUTHORIZED: 'unauthorized'
 };
 /** An error returned by a DataConnect operation. */
 class DataConnectError extends FirebaseError {
@@ -122,16 +123,30 @@ let connectFetch = globalThis.fetch;
 function initializeFetch(fetchImpl) {
     connectFetch = fetchImpl;
 }
-function dcFetch(url, body, { signal }, accessToken) {
+function getGoogApiClientValue(_isUsingGen) {
+    let str = 'gl-js/ fire/' + SDK_VERSION;
+    if (_isUsingGen) {
+        str += ' web/gen';
+    }
+    return str;
+}
+function dcFetch(url, body, { signal }, appId, accessToken, appCheckToken, _isUsingGen) {
     if (!connectFetch) {
         throw new DataConnectError(Code.OTHER, 'No Fetch Implementation detected!');
     }
     const headers = {
-        'Content-Type': 'application/json'
+        'Content-Type': 'application/json',
+        'X-Goog-Api-Client': getGoogApiClientValue(_isUsingGen)
     };
     if (accessToken) {
         headers['X-Firebase-Auth-Token'] = accessToken;
     }
+    if (appId) {
+        headers['x-firebase-gmpid'] = appId;
+    }
+    if (appCheckToken) {
+        headers['X-Firebase-AppCheck'] = appCheckToken;
+    }
     const bodyStr = JSON.stringify(body);
     logDebug(`Making request out to ${url} with body: ${bodyStr}`);
     return connectFetch(url, {
@@ -139,8 +154,9 @@ function dcFetch(url, body, { signal }, accessToken) {
         method: 'POST',
         headers,
         signal
-    }).catch(err => {
-        throw new DataConnectError(Code.OTHER, "Failed to fetch: " + JSON.stringify(err));
+    })
+        .catch(err => {
+        throw new DataConnectError(Code.OTHER, 'Failed to fetch: ' + JSON.stringify(err));
     })
         .then(async (response) => {
         let jsonResponse = null;
@@ -150,9 +166,13 @@ function dcFetch(url, body, { signal }, accessToken) {
         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));
-            throw new DataConnectError(Code.OTHER, JSON.stringify(jsonResponse));
+            if (response.status === 401) {
+                throw new DataConnectError(Code.UNAUTHORIZED, message);
+            }
+            throw new DataConnectError(Code.OTHER, message);
         }
         return jsonResponse;
     })
@@ -164,10 +184,70 @@ function dcFetch(url, body, { signal }, accessToken) {
         }
         return res;
     });
+}
+function getMessage(obj) {
+    if ('message' in obj) {
+        return obj.message;
+    }
+    return JSON.stringify(obj);
 }
 
 const name = "@firebase/data-connect";
-const version = "0.0.2-dataconnect-preview.388b61c7e";
+const version = "0.0.3-canary.beaa4dffb";
+
+/**
+ * @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.
+ */
+/**
+ * @internal
+ * Abstraction around AppCheck's token fetching capabilities.
+ */
+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(appCheck => (this.appCheck = appCheck)).catch());
+        }
+    }
+    getToken(forceRefresh) {
+        if (!this.appCheck) {
+            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(() => {
+                    if (this.appCheck) {
+                        this.getToken(forceRefresh).then(resolve, reject);
+                    }
+                    else {
+                        resolve(null);
+                    }
+                }, 0);
+            });
+        }
+        return this.appCheck.getToken(forceRefresh);
+    }
+    addTokenChangeListener(listener) {
+        var _a;
+        void ((_a = this.appCheckProvider) === null || _a === void 0 ? void 0 : _a.get().then(appCheck => appCheck.addTokenListener(listener)));
+    }
+}
 
 /**
  * @license
@@ -185,6 +265,7 @@ const version = "0.0.2-dataconnect-preview.388b61c7e";
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+// @internal
 class FirebaseAuthProvider {
     constructor(_appName, _options, _authProvider) {
         this._appName = _appName;
@@ -227,7 +308,8 @@ class FirebaseAuthProvider {
     removeTokenChangeListener(listener) {
         this._authProvider
             .get()
-            .then(auth => auth.removeAuthTokenListener(listener));
+            .then(auth => auth.removeAuthTokenListener(listener))
+            .catch(err => logError(err));
     }
 }
 
@@ -467,7 +549,7 @@ function urlBuilder(projectConfig, transportOptions) {
         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}`;
+    return `${baseUrl}/v1beta/projects/${project}/locations/${location}/services/${service}/connectors/${connector}`;
 }
 function addToken(url, apiKey) {
     if (!apiKey) {
@@ -495,41 +577,44 @@ function addToken(url, apiKey) {
  * limitations under the License.
  */
 class RESTTransport {
-    constructor(options, apiKey, authProvider, transportOptions) {
-        var _a;
+    constructor(options, apiKey, appId, authProvider, appCheckProvider, transportOptions, _isUsingGen = false) {
+        var _a, _b;
         this.apiKey = apiKey;
+        this.appId = appId;
         this.authProvider = authProvider;
+        this.appCheckProvider = appCheckProvider;
+        this._isUsingGen = _isUsingGen;
         this._host = '';
         this._location = 'l';
         this._connectorName = '';
         this._secure = true;
         this._project = 'p';
         this._accessToken = null;
-        this._authInitialized = false;
+        this._appCheckToken = null;
+        this._lastToken = null;
         // 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);
-            });
+            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)
+                then: withAuth.then.bind(withAuth),
+                catch: withAuth.catch.bind(withAuth)
             };
         };
         this.invokeMutation = (mutationName, body) => {
             const abortController = new AbortController();
-            const taskResult = this.getWithAuth().then(() => {
+            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._accessToken);
+                }, abortController, this.appId, this._accessToken, this._appCheckToken, this._isUsingGen);
             });
             return {
                 then: taskResult.then.bind(taskResult),
@@ -563,6 +648,11 @@ class RESTTransport {
             logDebug(`New Token Available: ${token}`);
             this._accessToken = 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;
+        });
     }
     get endpointUrl() {
         return urlBuilder({
@@ -584,26 +674,52 @@ class RESTTransport {
     onTokenChanged(newToken) {
         this._accessToken = newToken;
     }
-    getWithAuth() {
+    async getWithAuth(forceToken = false) {
+        var _a;
         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(''));
-            }
+        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;
+            });
+        }
+        else {
+            starterPromise = new Promise(resolve => resolve(''));
         }
         return starterPromise;
     }
+    _setLastToken(lastToken) {
+        this._lastToken = lastToken;
+    }
+    withRetry(promiseFactory, retry = false) {
+        let isNewToken = false;
+        return this.getWithAuth(retry)
+            .then(res => {
+            isNewToken = this._lastToken !== res;
+            this._lastToken = res;
+            return res;
+        })
+            .then(promiseFactory)
+            .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);
+            }
+            throw err;
+        });
+    }
 }
 
 /**
@@ -702,14 +818,17 @@ function parseOptions(fullHost) {
  * Class representing Firebase Data Connect
  */
 class DataConnect {
+    // @internal
     constructor(app, 
     // TODO(mtewani): Replace with _dataConnectOptions in the future
-    dataConnectOptions, _authProvider) {
+    dataConnectOptions, _authProvider, _appCheckProvider) {
         this.app = app;
         this.dataConnectOptions = dataConnectOptions;
         this._authProvider = _authProvider;
+        this._appCheckProvider = _appCheckProvider;
         this.isEmulator = false;
-        this.initialized = false;
+        this._initialized = false;
+        this._isUsingGeneratedSdk = false;
         if (typeof process !== 'undefined' && process.env) {
             const host = process.env[FIREBASE_DATA_CONNECT_EMULATOR_HOST_VAR];
             if (host) {
@@ -719,17 +838,25 @@ class DataConnect {
             }
         }
     }
+    // @internal
+    _useGeneratedSdk() {
+        if (!this._isUsingGeneratedSdk) {
+            this._isUsingGeneratedSdk = true;
+        }
+    }
     _delete() {
         _removeServiceInstance(this.app, 'data-connect', JSON.stringify(this.getSettings()));
         return Promise.resolve();
     }
+    // @internal
     getSettings() {
         const copy = JSON.parse(JSON.stringify(this.dataConnectOptions));
         delete copy.projectId;
         return copy;
     }
+    // @internal
     setInitialized() {
-        if (this.initialized) {
+        if (this._initialized) {
             return;
         }
         if (this._transportClass === undefined) {
@@ -739,16 +866,20 @@ class DataConnect {
         if (this._authProvider) {
             this._authTokenProvider = new FirebaseAuthProvider(this.app.name, this.app.options, this._authProvider);
         }
-        this.initialized = true;
-        this._transport = new this._transportClass(this.dataConnectOptions, this.app.options.apiKey, this._authTokenProvider);
+        if (this._appCheckProvider) {
+            this._appCheckTokenProvider = new AppCheckTokenProvider(this.app.name, this._appCheckProvider);
+        }
+        this._initialized = true;
+        this._transport = new this._transportClass(this.dataConnectOptions, this.app.options.apiKey, this.app.options.appId, this._authTokenProvider, this._appCheckTokenProvider, undefined, this._isUsingGeneratedSdk);
         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);
     }
+    // @internal
     enableEmulator(transportOptions) {
-        if (this.initialized) {
+        if (this._initialized) {
             logError('enableEmulator called after initialization');
             throw new DataConnectError(Code.ALREADY_INITIALIZED, 'DataConnect instance already initialized!');
         }
@@ -777,7 +908,7 @@ function getDataConnect(appOrOptions, optionalOptions) {
         dcOptions = optionalOptions;
         app = appOrOptions;
     }
-    if (!app) {
+    if (!app || Object.keys(app).length === 0) {
         app = getApp();
     }
     const provider = _getProvider(app, 'data-connect');
@@ -791,9 +922,7 @@ function getDataConnect(appOrOptions, optionalOptions) {
             return dcInstance;
         }
     }
-    if (!dcOptions) {
-        throw new DataConnectError(Code.INVALID_ARGUMENT, 'DC Option Required');
-    }
+    validateDCOptions(dcOptions);
     logDebug('Creating new DataConnect instance');
     // Initialize with options.
     return provider.initialize({
@@ -801,6 +930,24 @@ function getDataConnect(appOrOptions, optionalOptions) {
         options: dcOptions
     });
 }
+/**
+ *
+ * @param dcOptions
+ * @returns {void}
+ * @internal
+ */
+function validateDCOptions(dcOptions) {
+    const fields = ['connector', 'location', 'service'];
+    if (!dcOptions) {
+        throw new DataConnectError(Code.INVALID_ARGUMENT, 'DC Option Required');
+    }
+    fields.forEach(field => {
+        if (dcOptions[field] === null || dcOptions[field] === undefined) {
+            throw new DataConnectError(Code.INVALID_ARGUMENT, `${field} Required`);
+        }
+    });
+    return true;
+}
 /**
  * Delete DataConnect instance
  * @param dataConnect DataConnect instance
@@ -832,11 +979,15 @@ function registerDataConnect(variant) {
     _registerComponent(new 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);
         }
-        return new DataConnect(app, Object.assign(Object.assign({}, newOpts), { projectId: app.options.projectId }), authProvider);
+        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, Object.assign(Object.assign({}, newOpts), { projectId: app.options.projectId }), authProvider, appCheckProvider);
     }, "PUBLIC" /* ComponentType.PUBLIC */).setMultipleInstances(true));
     registerVersion(name, version, variant);
     // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation
@@ -895,6 +1046,49 @@ function toQueryRef(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.
+ */
+/**
+ * The generated SDK will allow the user to pass in either the variable or the data connect instance with the variable,
+ * and this function validates the variables and returns back the DataConnect instance and variables based on the arguments passed in.
+ * @param connectorConfig
+ * @param dcOrVars
+ * @param vars
+ * @param validateVars
+ * @returns {DataConnect} and {Variables} instance
+ * @internal
+ */
+function validateArgs(connectorConfig, dcOrVars, vars, validateVars) {
+    let dcInstance;
+    let realVars;
+    if (dcOrVars && 'enableEmulator' in dcOrVars) {
+        dcInstance = dcOrVars;
+        realVars = vars;
+    }
+    else {
+        dcInstance = getDataConnect(connectorConfig);
+        realVars = dcOrVars;
+    }
+    if (!dcInstance || (!realVars && validateVars)) {
+        throw new DataConnectError(Code.INVALID_ARGUMENT, 'Variables required.');
+    }
+    return { dc: dcInstance, vars: realVars };
+}
+
 /**
  * @license
  * Copyright 2024 Google LLC
@@ -969,5 +1163,5 @@ function subscribe(queryRefOrSerializedResult, observerOrOnNext, onError, onComp
 initializeFetch(fetch);
 registerDataConnect('node');
 
-export { DataConnect, FIREBASE_DATA_CONNECT_EMULATOR_HOST_VAR, FirebaseAuthProvider, MUTATION_STR, MutationManager, QUERY_STR, SOURCE_CACHE, SOURCE_SERVER, connectDataConnectEmulator, executeMutation, executeQuery, getDataConnect, mutationRef, parseOptions, queryRef, setLogLevel, subscribe, terminate, toQueryRef };
+export { DataConnect, MUTATION_STR, MutationManager, QUERY_STR, SOURCE_CACHE, SOURCE_SERVER, connectDataConnectEmulator, executeMutation, executeQuery, getDataConnect, mutationRef, parseOptions, queryRef, setLogLevel, subscribe, terminate, toQueryRef, validateArgs, validateDCOptions };
 //# sourceMappingURL=index.node.esm.js.map