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

package/dist/index.cjs.js

@@ -4,11 +4,11 @@ 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');
+var logger$1 = require('@firebase/logger');
 
 const name = "@firebase/data-connect";
-const version = "0.0.1-dataconnect-preview.81ee5169c";
+const version = "0.0.2-dataconnect-preview.388b61c7e";
 
 /**
  * @license
@@ -36,6 +36,52 @@ 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 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
@@ -80,20 +126,20 @@ function logError(msg) {
  * 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 {
@@ -102,7 +148,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;
@@ -116,10 +162,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));
     }
@@ -141,8 +187,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';
 
@@ -229,7 +275,7 @@ class QueryManager {
         const ref = {
             name: queryName,
             variables,
-            refType: QueryStr
+            refType: QUERY_STR
         };
         const key = encoderImpl(ref);
         const newTrackedQuery = {
@@ -246,7 +292,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 = {
@@ -295,7 +341,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);
@@ -332,52 +378,6 @@ function compareDates(str1, 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
@@ -452,6 +452,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;
@@ -498,24 +500,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)
@@ -525,10 +527,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),
@@ -539,53 +541,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)
@@ -593,8 +595,8 @@ class RESTTransport {
                     if (!data) {
                         return null;
                     }
-                    this.accessToken = data.accessToken;
-                    return this.accessToken;
+                    this._accessToken = data.accessToken;
+                    return this._accessToken;
                 });
             }
             else {
@@ -621,23 +623,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;
@@ -648,6 +660,11 @@ class MutationManager {
         return withRefPromise;
     }
 }
+/**
+ * Execute Mutation
+ * @param mutationRef mutation to execute
+ * @returns `MutationRef`
+ */
 function executeMutation(mutationRef) {
     return mutationRef.dataConnect._mutationManager.executeMutation(mutationRef);
 }
@@ -682,11 +699,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) {
@@ -694,7 +716,7 @@ class DataConnect {
             if (host) {
                 logDebug('Found custom host. Using emulator');
                 this.isEmulator = true;
-                this.transportOptions = parseOptions(host);
+                this._transportOptions = parseOptions(host);
             }
         }
     }
@@ -711,30 +733,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 });
 }
@@ -773,8 +802,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
 }
 
@@ -826,19 +860,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);
@@ -860,11 +912,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,
@@ -896,34 +956,14 @@ function subscribe(queryRefOrSerializedResult, observerOrOnNext, onError, onComp
  *
  * @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) => {
-// })
+registerDataConnect();
 
 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;