@firebase/data-connect 0.0.2-dataconnect-preview.877f8b7d0 → 0.0.3-dataconnect-preview.d986d4bf2

package/dist/index.cjs.js

@@ -8,7 +8,7 @@ var util = require('@firebase/util');
 var logger$1 = require('@firebase/logger');
 
 const name = "@firebase/data-connect";
-const version = "0.0.2-dataconnect-preview.877f8b7d0";
+const version = "0.0.3-dataconnect-preview.d986d4bf2";
 
 /**
  * @license
@@ -58,7 +58,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 util.FirebaseError {
@@ -167,7 +168,8 @@ class FirebaseAuthProvider {
     removeTokenChangeListener(listener) {
         this._authProvider
             .get()
-            .then(auth => auth.removeAuthTokenListener(listener));
+            .then(auth => auth.removeAuthTokenListener(listener))
+            .catch(err => logError(err));
     }
 }
 
@@ -435,12 +437,20 @@ function addToken(url, apiKey) {
  * limitations under the License.
  */
 let connectFetch = globalThis.fetch;
-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 }, accessToken, _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;
@@ -452,8 +462,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;
@@ -463,9 +474,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;
     })
@@ -477,6 +492,12 @@ function dcFetch(url, body, { signal }, accessToken) {
         }
         return res;
     });
+}
+function getMessage(obj) {
+    if ('message' in obj) {
+        return obj.message;
+    }
+    return JSON.stringify(obj);
 }
 
 /**
@@ -496,10 +517,11 @@ function dcFetch(url, body, { signal }, accessToken) {
  * limitations under the License.
  */
 class RESTTransport {
-    constructor(options, apiKey, authProvider, transportOptions) {
+    constructor(options, apiKey, authProvider, transportOptions, _isUsingGen = false) {
         var _a;
         this.apiKey = apiKey;
         this.authProvider = authProvider;
+        this._isUsingGen = _isUsingGen;
         this._host = '';
         this._location = 'l';
         this._connectorName = '';
@@ -507,30 +529,30 @@ class RESTTransport {
         this._project = 'p';
         this._accessToken = null;
         this._authInitialized = false;
+        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._accessToken, 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._accessToken, this._isUsingGen);
             });
             return {
                 then: taskResult.then.bind(taskResult),
@@ -585,12 +607,12 @@ class RESTTransport {
     onTokenChanged(newToken) {
         this._accessToken = newToken;
     }
-    getWithAuth() {
+    getWithAuth(forceToken = false) {
         let starterPromise = new Promise(resolve => resolve(this._accessToken));
         if (!this._authInitialized) {
             if (this.authProvider) {
                 starterPromise = this.authProvider
-                    .getToken(/*forceToken=*/ false)
+                    .getToken(/*forceToken=*/ forceToken)
                     .then(data => {
                     if (!data) {
                         return null;
@@ -605,6 +627,30 @@ class RESTTransport {
         }
         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;
+        });
+    }
 }
 
 /**
@@ -623,16 +669,26 @@ class RESTTransport {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-function mutationRef(dcInstance, queryName, variables) {
+/**
+ *
+ * @param dcInstance Data Connect instance
+ * @param mutationName name of mutation
+ * @param variables variables to send with mutation
+ * @returns `MutationRef`
+ */
+function mutationRef(dcInstance, mutationName, variables) {
     dcInstance.setInitialized();
     const ref = {
         dataConnect: dcInstance,
-        name: queryName,
+        name: mutationName,
         refType: MUTATION_STR,
         variables: variables
     };
     return ref;
 }
+/**
+ * @internal
+ */
 class MutationManager {
     constructor(_transport) {
         this._transport = _transport;
@@ -650,6 +706,11 @@ class MutationManager {
         return withRefPromise;
     }
 }
+/**
+ * Execute Mutation
+ * @param mutationRef mutation to execute
+ * @returns `MutationRef`
+ */
 function executeMutation(mutationRef) {
     return mutationRef.dataConnect._mutationManager.executeMutation(mutationRef);
 }
@@ -684,6 +745,9 @@ function parseOptions(fullHost) {
     const port = Number(portAsString);
     return { host, port, sslEnabled: isSecure };
 }
+/**
+ * Class representing Firebase Data Connect
+ */
 class DataConnect {
     constructor(app, 
     // TODO(mtewani): Replace with _dataConnectOptions in the future
@@ -693,6 +757,7 @@ class DataConnect {
         this._authProvider = _authProvider;
         this.isEmulator = 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) {
@@ -702,6 +767,14 @@ class DataConnect {
             }
         }
     }
+    /*
+      @internal
+    */
+    _useGeneratedSdk() {
+        if (!this._isUsingGeneratedSdk) {
+            this._isUsingGeneratedSdk = true;
+        }
+    }
     _delete() {
         app._removeServiceInstance(this.app, 'data-connect', JSON.stringify(this.getSettings()));
         return Promise.resolve();
@@ -723,7 +796,7 @@ class DataConnect {
             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);
+        this._transport = new this._transportClass(this.dataConnectOptions, this.app.options.apiKey, this._authTokenProvider, undefined, this._isUsingGeneratedSdk);
         if (this._transportOptions) {
             this._transport.useEmulator(this._transportOptions.host, this._transportOptions.port, this._transportOptions.sslEnabled);
         }
@@ -739,6 +812,13 @@ class DataConnect {
         this.isEmulator = true;
     }
 }
+/**
+ * Connect to the DataConnect Emulator
+ * @param dc Data Connect instance
+ * @param host host of emulator server
+ * @param port port of emulator server
+ * @param sslEnabled use https
+ */
 function connectDataConnectEmulator(dc, host, port, sslEnabled = false) {
     dc.enableEmulator({ host, port, sslEnabled });
 }
@@ -753,7 +833,7 @@ function getDataConnect(appOrOptions, optionalOptions) {
         dcOptions = optionalOptions;
         app$1 = appOrOptions;
     }
-    if (!app$1) {
+    if (!app$1 || Object.keys(app$1).length === 0) {
         app$1 = app.getApp();
     }
     const provider = app._getProvider(app$1, 'data-connect');
@@ -767,9 +847,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({
@@ -777,6 +855,29 @@ 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
+ * @returns
+ */
 function terminate(dataConnect) {
     return dataConnect._delete();
     // TODO(mtewani): Stop pending tasks
@@ -807,6 +908,9 @@ function registerDataConnect(variant) {
         if (settings) {
             newOpts = JSON.parse(settings);
         }
+        if (!app.options.projectId) {
+            throw new DataConnectError(Code.INVALID_ARGUMENT, 'Project ID must be provided. Did you pass in a proper projectId to initializeApp?');
+        }
         return new DataConnect(app, Object.assign(Object.assign({}, newOpts), { projectId: app.options.projectId }), authProvider);
     }, "PUBLIC" /* ComponentType.PUBLIC */).setMultipleInstances(true));
     app.registerVersion(name, version, variant);
@@ -830,9 +934,22 @@ function registerDataConnect(variant) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+/**
+ * Execute Query
+ * @param queryRef query to execute.
+ * @returns `QueryPromise`
+ */
 function executeQuery(queryRef) {
     return queryRef.dataConnect._queryManager.executeQuery(queryRef);
 }
+/**
+ * Execute Query
+ * @param dcInstance Data Connect instance to use.
+ * @param queryName Query to execute
+ * @param variables Variables to execute with
+ * @param initialCache initial cache to use for client hydration
+ * @returns `QueryRef`
+ */
 function queryRef(dcInstance, queryName, variables, initialCache) {
     dcInstance.setInitialized();
     dcInstance._queryManager.track(queryName, variables, initialCache);
@@ -843,6 +960,11 @@ function queryRef(dcInstance, queryName, variables, initialCache) {
         variables: variables
     };
 }
+/**
+ * Converts serialized ref to query ref
+ * @param serializedRef ref to convert to `QueryRef`
+ * @returns `QueryRef`
+ */
 function toQueryRef(serializedRef) {
     const { refInfo: { name, variables, connectorConfig } } = serializedRef;
     return queryRef(getDataConnect(connectorConfig), name, variables);
@@ -864,6 +986,57 @@ function toQueryRef(serializedRef) {
  * 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
+ *
+ * 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.
+ */
+/**
+ * Subscribe to a `QueryRef`
+ * @param queryRefOrSerializedResult query ref or serialized result.
+ * @param observerOrOnNext observer object or next function.
+ * @param onError Callback to call when error gets thrown.
+ * @param onComplete Called when subscription completes.
+ * @returns `SubscriptionOptions`
+ */
 function subscribe(queryRefOrSerializedResult, observerOrOnNext, onError, onComplete) {
     let ref;
     let initialCache;
@@ -921,4 +1094,6 @@ exports.setLogLevel = setLogLevel;
 exports.subscribe = subscribe;
 exports.terminate = terminate;
 exports.toQueryRef = toQueryRef;
+exports.validateArgs = validateArgs;
+exports.validateDCOptions = validateDCOptions;
 //# sourceMappingURL=index.cjs.js.map