@firebase/data-connect 0.0.1-dataconnect-preview.81ee5169c → 0.0.2-dataconnect-preview.388b61c7e

package/dist/index.node.cjs.js

@@ -149,6 +149,8 @@ function dcFetch(url, body, _a, accessToken) {
         method: 'POST',
         headers: headers,
         signal: signal
+    }).catch(function (err) {
+        throw new DataConnectError(Code.OTHER, "Failed to fetch: " + JSON.stringify(err));
     })
         .then(function (response) { return tslib.__awaiter(_this, void 0, void 0, function () {
         var jsonResponse, e_1;
@@ -186,7 +188,7 @@ function dcFetch(url, body, _a, accessToken) {
 }
 
 var name = "@firebase/data-connect";
-var version = "0.0.1-dataconnect-preview.81ee5169c";
+var version = "0.0.2-dataconnect-preview.388b61c7e";
 
 /**
  * @license
@@ -205,22 +207,22 @@ var version = "0.0.1-dataconnect-preview.81ee5169c";
  * limitations under the License.
  */
 var FirebaseAuthProvider = /** @class */ (function () {
-    function FirebaseAuthProvider(appName, options, authProvider_) {
+    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); });
+        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_) {
+        if (!this._auth) {
             return new Promise(function (resolve, reject) {
                 setTimeout(function () {
-                    if (_this.auth_) {
+                    if (_this._auth) {
                         _this.getToken(forceRefresh).then(resolve, reject);
                     }
                     else {
@@ -229,7 +231,7 @@ var FirebaseAuthProvider = /** @class */ (function () {
                 }, 0);
             });
         }
-        return this.auth_.getToken(forceRefresh).catch(function (error) {
+        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;
@@ -243,10 +245,10 @@ var FirebaseAuthProvider = /** @class */ (function () {
     };
     FirebaseAuthProvider.prototype.addTokenChangeListener = function (listener) {
         var _a;
-        (_a = this.auth_) === null || _a === void 0 ? void 0 : _a.addAuthTokenListener(listener);
+        (_a = this._auth) === null || _a === void 0 ? void 0 : _a.addAuthTokenListener(listener);
     };
     FirebaseAuthProvider.prototype.removeTokenChangeListener = function (listener) {
-        this.authProvider_
+        this._authProvider
             .get()
             .then(function (auth) { return auth.removeAuthTokenListener(listener); });
     };
@@ -269,8 +271,8 @@ var FirebaseAuthProvider = /** @class */ (function () {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var QueryStr = 'query';
-var MutationStr = 'mutation';
+var QUERY_STR = 'query';
+var MUTATION_STR = 'mutation';
 var SOURCE_SERVER = 'SERVER';
 var SOURCE_CACHE = 'CACHE';
 
@@ -357,7 +359,7 @@ var QueryManager = /** @class */ (function () {
         var ref = {
             name: queryName,
             variables: variables,
-            refType: QueryStr
+            refType: QUERY_STR
         };
         var key = encoderImpl(ref);
         var newTrackedQuery = {
@@ -375,7 +377,7 @@ var QueryManager = /** @class */ (function () {
         var key = encoderImpl({
             name: queryRef.name,
             variables: queryRef.variables,
-            refType: QueryStr
+            refType: QUERY_STR
         });
         var trackedQuery = this._queries.get(key);
         var subscription = {
@@ -424,7 +426,7 @@ var QueryManager = /** @class */ (function () {
         var key = encoderImpl({
             name: queryRef.name,
             variables: queryRef.variables,
-            refType: QueryStr
+            refType: QUERY_STR
         });
         var trackedQuery = this._queries.get(key);
         var result = this.transport.invokeQuery(queryRef.name, queryRef.variables);
@@ -524,24 +526,24 @@ var RESTTransport = /** @class */ (function () {
         var _a;
         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;
+        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),
+                    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);
+                abortController, _this._accessToken);
             });
             return {
                 then: withAuth.then.bind(withAuth)
@@ -551,10 +553,10 @@ var RESTTransport = /** @class */ (function () {
             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),
+                    name: "projects/".concat(_this._project, "/locations/").concat(_this._location, "/services/").concat(_this._serviceName, "/connectors/").concat(_this._connectorName),
                     operationName: mutationName,
                     variables: body
-                }, abortController, _this.accessToken);
+                }, abortController, _this._accessToken);
             });
             return {
                 then: taskResult.then.bind(taskResult),
@@ -565,60 +567,60 @@ var RESTTransport = /** @class */ (function () {
         };
         if (transportOptions) {
             if (typeof transportOptions.port === 'number') {
-                this.port = transportOptions.port;
+                this._port = transportOptions.port;
             }
             if (typeof transportOptions.sslEnabled !== 'undefined') {
-                this.secure = transportOptions.sslEnabled;
+                this._secure = transportOptions.sslEnabled;
             }
-            this.host = transportOptions.host;
+            this._host = transportOptions.host;
         }
         var location = options.location, project = options.projectId, connector = options.connector, service = options.service;
         if (location) {
-            this.location = location;
+            this._location = location;
         }
         if (project) {
-            this.project = project;
+            this._project = project;
         }
-        this.serviceName = service;
+        this._serviceName = service;
         if (!connector) {
             throw new DataConnectError(Code.INVALID_ARGUMENT, 'Connector Name required!');
         }
-        this.connectorName = connector;
+        this._connectorName = connector;
         (_a = this.authProvider) === null || _a === void 0 ? void 0 : _a.addTokenChangeListener(function (token) {
             logDebug("New Token Available: ".concat(token));
-            _this.accessToken = token;
+            _this._accessToken = token;
         });
     }
     Object.defineProperty(RESTTransport.prototype, "endpointUrl", {
         get: function () {
             return urlBuilder({
-                connector: this.connectorName,
-                location: this.location,
-                projectId: this.project,
-                service: this.serviceName
-            }, { host: this.host, sslEnabled: this.secure, port: this.port });
+                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;
+        this._host = host;
         if (typeof port === 'number') {
-            this.port = port;
+            this._port = port;
         }
         if (typeof isSecure !== 'undefined') {
-            this.secure = isSecure;
+            this._secure = isSecure;
         }
     };
     RESTTransport.prototype.onTokenChanged = function (newToken) {
-        this.accessToken = newToken;
+        this._accessToken = newToken;
     };
     RESTTransport.prototype.getWithAuth = function () {
         var _this = this;
         var starterPromise = new Promise(function (resolve) {
-            return resolve(_this.accessToken);
+            return resolve(_this._accessToken);
         });
-        if (!this.authInitialized_) {
+        if (!this._authInitialized) {
             if (this.authProvider) {
                 starterPromise = this.authProvider
                     .getToken(/*forceToken=*/ false)
@@ -626,8 +628,8 @@ var RESTTransport = /** @class */ (function () {
                     if (!data) {
                         return null;
                     }
-                    _this.accessToken = data.accessToken;
-                    return _this.accessToken;
+                    _this._accessToken = data.accessToken;
+                    return _this._accessToken;
                 });
             }
             else {
@@ -655,24 +657,34 @@ var RESTTransport = /** @class */ (function () {
  * 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();
     var ref = {
         dataConnect: dcInstance,
-        name: queryName,
-        refType: MutationStr,
+        name: mutationName,
+        refType: MUTATION_STR,
         variables: variables
     };
     return ref;
 }
+/**
+ * @internal
+ */
 var MutationManager = /** @class */ (function () {
-    function MutationManager(transport) {
-        this.transport = transport;
+    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 result = this._transport.invokeMutation(mutationRef.name, mutationRef.variables);
         var withRefPromise = result.then(function (res) {
             var obj = tslib.__assign(tslib.__assign({}, res), { source: SOURCE_SERVER, ref: mutationRef, fetchTime: Date.now().toLocaleString() });
             return obj;
@@ -686,6 +698,11 @@ var MutationManager = /** @class */ (function () {
     };
     return MutationManager;
 }());
+/**
+ * Execute Mutation
+ * @param mutationRef mutation to execute
+ * @returns `MutationRef`
+ */
 function executeMutation(mutationRef) {
     return mutationRef.dataConnect._mutationManager.executeMutation(mutationRef);
 }
@@ -720,11 +737,16 @@ function parseOptions(fullHost) {
     var port = Number(portAsString);
     return { host: host, port: port, sslEnabled: isSecure };
 }
+/**
+ * Class representing Firebase Data Connect
+ */
 var DataConnect = /** @class */ (function () {
-    function DataConnect(app, dataConnectOptions, authProvider) {
+    function DataConnect(app, 
+    // TODO(mtewani): Replace with _dataConnectOptions in the future
+    dataConnectOptions, _authProvider) {
         this.app = app;
         this.dataConnectOptions = dataConnectOptions;
-        this.authProvider = authProvider;
+        this._authProvider = _authProvider;
         this.isEmulator = false;
         this.initialized = false;
         if (typeof process !== 'undefined' && process.env) {
@@ -732,7 +754,7 @@ var DataConnect = /** @class */ (function () {
             if (host) {
                 logDebug('Found custom host. Using emulator');
                 this.isEmulator = true;
-                this.transportOptions = parseOptions(host);
+                this._transportOptions = parseOptions(host);
             }
         }
     }
@@ -749,31 +771,38 @@ var DataConnect = /** @class */ (function () {
         if (this.initialized) {
             return;
         }
-        if (this.transportClass === undefined) {
+        if (this._transportClass === undefined) {
             logDebug('transportClass not provided. Defaulting to RESTTransport.');
-            this.transportClass = RESTTransport;
+            this._transportClass = RESTTransport;
         }
-        if (this.authProvider) {
-            this.authTokenProvider = new FirebaseAuthProvider(this.app.name, this.app.options, this.authProvider);
+        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.transportOptions) {
-            this._transport.useEmulator(this.transportOptions.host, this.transportOptions.port, this.transportOptions.sslEnabled);
+        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');
+            logError('enableEmulator called after initialization');
             throw new DataConnectError(Code.ALREADY_INITIALIZED, 'DataConnect instance already initialized!');
         }
-        this.transportOptions = transportOptions;
+        this._transportOptions = transportOptions;
         this.isEmulator = true;
     };
     return DataConnect;
 }());
+/**
+ * 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) {
     if (sslEnabled === void 0) { sslEnabled = false; }
     dc.enableEmulator({ host: host, port: port, sslEnabled: sslEnabled });
@@ -813,8 +842,13 @@ function getDataConnect(appOrOptions, optionalOptions) {
         options: dcOptions
     });
 }
+/**
+ * Delete DataConnect instance
+ * @param dataConnect DataConnect instance
+ * @returns
+ */
 function terminate(dataConnect) {
-    dataConnect._delete();
+    return dataConnect._delete();
     // TODO(mtewani): Stop pending tasks
 }
 
@@ -851,19 +885,37 @@ 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);
     return {
         dataConnect: dcInstance,
-        refType: QueryStr,
+        refType: QUERY_STR,
         name: queryName,
         variables: variables
     };
 }
+/**
+ * Converts serialized ref to query ref
+ * @param serializedRef ref to convert to `QueryRef`
+ * @returns `QueryRef`
+ */
 function toQueryRef(serializedRef) {
     var _a = serializedRef.refInfo, name = _a.name, variables = _a.variables, connectorConfig = _a.connectorConfig;
     return queryRef(getDataConnect(connectorConfig), name, variables);
@@ -885,6 +937,14 @@ function toQueryRef(serializedRef) {
  * 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) {
     var ref;
     var initialCache;
@@ -938,9 +998,9 @@ registerDataConnect('node');
 exports.DataConnect = DataConnect;
 exports.FIREBASE_DATA_CONNECT_EMULATOR_HOST_VAR = FIREBASE_DATA_CONNECT_EMULATOR_HOST_VAR;
 exports.FirebaseAuthProvider = FirebaseAuthProvider;
+exports.MUTATION_STR = MUTATION_STR;
 exports.MutationManager = MutationManager;
-exports.MutationStr = MutationStr;
-exports.QueryStr = QueryStr;
+exports.QUERY_STR = QUERY_STR;
 exports.SOURCE_CACHE = SOURCE_CACHE;
 exports.SOURCE_SERVER = SOURCE_SERVER;
 exports.connectDataConnectEmulator = connectDataConnectEmulator;