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

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

@@ -139,6 +139,8 @@ function dcFetch(url, body, { signal }, accessToken) {
         method: 'POST',
         headers,
         signal
+    }).catch(err => {
+        throw new DataConnectError(Code.OTHER, "Failed to fetch: " + JSON.stringify(err));
     })
         .then(async (response) => {
         let jsonResponse = null;
@@ -165,7 +167,7 @@ function dcFetch(url, body, { signal }, accessToken) {
 }
 
 const name = "@firebase/data-connect";
-const version = "0.0.1-dataconnect-preview.81ee5169c";
+const version = "0.0.2-dataconnect-preview.388b61c7e";
 
 /**
  * @license
@@ -184,20 +186,20 @@ const version = "0.0.1-dataconnect-preview.81ee5169c";
  * 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));
+    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_) {
+        if (!this._auth) {
             return new Promise((resolve, reject) => {
                 setTimeout(() => {
-                    if (this.auth_) {
+                    if (this._auth) {
                         this.getToken(forceRefresh).then(resolve, reject);
                     }
                     else {
@@ -206,7 +208,7 @@ class FirebaseAuthProvider {
                 }, 0);
             });
         }
-        return this.auth_.getToken(forceRefresh).catch(error => {
+        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;
@@ -220,10 +222,10 @@ class FirebaseAuthProvider {
     }
     addTokenChangeListener(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);
     }
     removeTokenChangeListener(listener) {
-        this.authProvider_
+        this._authProvider
             .get()
             .then(auth => auth.removeAuthTokenListener(listener));
     }
@@ -245,8 +247,8 @@ class FirebaseAuthProvider {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const QueryStr = 'query';
-const MutationStr = 'mutation';
+const QUERY_STR = 'query';
+const MUTATION_STR = 'mutation';
 const SOURCE_SERVER = 'SERVER';
 const SOURCE_CACHE = 'CACHE';
 
@@ -333,7 +335,7 @@ class QueryManager {
         const ref = {
             name: queryName,
             variables,
-            refType: QueryStr
+            refType: QUERY_STR
         };
         const key = encoderImpl(ref);
         const newTrackedQuery = {
@@ -350,7 +352,7 @@ class QueryManager {
         const key = encoderImpl({
             name: queryRef.name,
             variables: queryRef.variables,
-            refType: QueryStr
+            refType: QUERY_STR
         });
         const trackedQuery = this._queries.get(key);
         const subscription = {
@@ -399,7 +401,7 @@ class QueryManager {
         const key = encoderImpl({
             name: queryRef.name,
             variables: queryRef.variables,
-            refType: QueryStr
+            refType: QUERY_STR
         });
         const trackedQuery = this._queries.get(key);
         const result = this.transport.invokeQuery(queryRef.name, queryRef.variables);
@@ -497,24 +499,24 @@ class RESTTransport {
         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 = (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}`,
+                    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);
+                abortController, this._accessToken);
             });
             return {
                 then: withAuth.then.bind(withAuth)
@@ -524,10 +526,10 @@ class RESTTransport {
             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}`,
+                    name: `projects/${this._project}/locations/${this._location}/services/${this._serviceName}/connectors/${this._connectorName}`,
                     operationName: mutationName,
                     variables: body
-                }, abortController, this.accessToken);
+                }, abortController, this._accessToken);
             });
             return {
                 then: taskResult.then.bind(taskResult),
@@ -538,53 +540,53 @@ class RESTTransport {
         };
         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;
         }
         const { location, projectId: project, connector, service } = options;
         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(token => {
             logDebug(`New Token Available: ${token}`);
-            this.accessToken = token;
+            this._accessToken = token;
         });
     }
     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 });
+            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;
+        this._host = host;
         if (typeof port === 'number') {
-            this.port = port;
+            this._port = port;
         }
         if (typeof isSecure !== 'undefined') {
-            this.secure = isSecure;
+            this._secure = isSecure;
         }
     }
     onTokenChanged(newToken) {
-        this.accessToken = newToken;
+        this._accessToken = newToken;
     }
     getWithAuth() {
-        let starterPromise = new Promise(resolve => resolve(this.accessToken));
-        if (!this.authInitialized_) {
+        let starterPromise = new Promise(resolve => resolve(this._accessToken));
+        if (!this._authInitialized) {
             if (this.authProvider) {
                 starterPromise = this.authProvider
                     .getToken(/*forceToken=*/ false)
@@ -592,8 +594,8 @@ class RESTTransport {
                     if (!data) {
                         return null;
                     }
-                    this.accessToken = data.accessToken;
-                    return this.accessToken;
+                    this._accessToken = data.accessToken;
+                    return this._accessToken;
                 });
             }
             else {
@@ -620,23 +622,33 @@ 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,
-        refType: MutationStr,
+        name: mutationName,
+        refType: MUTATION_STR,
         variables: variables
     };
     return ref;
 }
+/**
+ * @internal
+ */
 class MutationManager {
-    constructor(transport) {
-        this.transport = transport;
+    constructor(_transport) {
+        this._transport = _transport;
         this._inflight = [];
     }
     executeMutation(mutationRef) {
-        const result = this.transport.invokeMutation(mutationRef.name, mutationRef.variables);
+        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;
@@ -647,6 +659,11 @@ class MutationManager {
         return withRefPromise;
     }
 }
+/**
+ * Execute Mutation
+ * @param mutationRef mutation to execute
+ * @returns `MutationRef`
+ */
 function executeMutation(mutationRef) {
     return mutationRef.dataConnect._mutationManager.executeMutation(mutationRef);
 }
@@ -681,11 +698,16 @@ function parseOptions(fullHost) {
     const port = Number(portAsString);
     return { host, port, sslEnabled: isSecure };
 }
+/**
+ * Class representing Firebase Data Connect
+ */
 class DataConnect {
-    constructor(app, dataConnectOptions, authProvider) {
+    constructor(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) {
@@ -693,7 +715,7 @@ class DataConnect {
             if (host) {
                 logDebug('Found custom host. Using emulator');
                 this.isEmulator = true;
-                this.transportOptions = parseOptions(host);
+                this._transportOptions = parseOptions(host);
             }
         }
     }
@@ -710,30 +732,37 @@ class DataConnect {
         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);
     }
     enableEmulator(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;
     }
 }
+/**
+ * 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 });
 }
@@ -772,8 +801,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
 }
 
@@ -825,19 +859,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) {
     const { refInfo: { name, variables, connectorConfig } } = serializedRef;
     return queryRef(getDataConnect(connectorConfig), name, variables);
@@ -859,11 +911,19 @@ 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) {
     let ref;
     let initialCache;
     if ('refInfo' in queryRefOrSerializedResult) {
-        let serializedRef = queryRefOrSerializedResult;
+        const serializedRef = queryRefOrSerializedResult;
         const { data, source, fetchTime } = serializedRef;
         initialCache = {
             data,
@@ -909,5 +969,5 @@ function subscribe(queryRefOrSerializedResult, observerOrOnNext, onError, onComp
 initializeFetch(fetch);
 registerDataConnect('node');
 
-export { DataConnect, FIREBASE_DATA_CONNECT_EMULATOR_HOST_VAR, FirebaseAuthProvider, MutationManager, MutationStr, QueryStr, SOURCE_CACHE, SOURCE_SERVER, connectDataConnectEmulator, executeMutation, executeQuery, getDataConnect, mutationRef, parseOptions, queryRef, setLogLevel, subscribe, terminate, toQueryRef };
+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 };
 //# sourceMappingURL=index.node.esm.js.map