reactfire 4.2.3-exp.c7357da → 4.2.4

package/dist/performance.d.ts

@@ -4,4 +4,4 @@ export interface SuspensePerfProps {
     traceId: string;
     fallback: React.ReactNode;
 }
-export declare function SuspenseWithPerf({ children, traceId, fallback }: SuspensePerfProps): JSX.Element;
+export declare function SuspenseWithPerf({ children, traceId, fallback }: SuspensePerfProps): React.ReactElement;

package/dist/sdk.d.ts

@@ -23,31 +23,31 @@ export declare const RemoteConfigSdkContext: React.Context<RemoteConfig | undefi
 type FirebaseSdks = Analytics | AppCheck | Auth | Database | Firestore | FirebasePerformance | FirebaseStorage | Functions | RemoteConfig;
 export declare const AppCheckProvider: (props: React.PropsWithChildren<{
     sdk: AppCheck;
-}>) => React.JSX.Element;
+}>) => React.ReactElement;
 export declare const AuthProvider: (props: React.PropsWithChildren<{
     sdk: Auth;
-}>) => React.JSX.Element;
+}>) => React.ReactElement;
 export declare const AnalyticsProvider: (props: React.PropsWithChildren<{
     sdk: Analytics;
-}>) => React.JSX.Element;
+}>) => React.ReactElement;
 export declare const DatabaseProvider: (props: React.PropsWithChildren<{
     sdk: Database;
-}>) => React.JSX.Element;
+}>) => React.ReactElement;
 export declare const FirestoreProvider: (props: React.PropsWithChildren<{
     sdk: Firestore;
-}>) => React.JSX.Element;
+}>) => React.ReactElement;
 export declare const FunctionsProvider: (props: React.PropsWithChildren<{
     sdk: Functions;
-}>) => React.JSX.Element;
+}>) => React.ReactElement;
 export declare const PerformanceProvider: (props: React.PropsWithChildren<{
     sdk: FirebasePerformance;
-}>) => React.JSX.Element;
+}>) => React.ReactElement;
 export declare const StorageProvider: (props: React.PropsWithChildren<{
     sdk: FirebaseStorage;
-}>) => React.JSX.Element;
+}>) => React.ReactElement;
 export declare const RemoteConfigProvider: (props: React.PropsWithChildren<{
     sdk: RemoteConfig;
-}>) => React.JSX.Element;
+}>) => React.ReactElement;
 export declare const useAppCheck: () => AppCheck;
 export declare const useAuth: () => Auth;
 export declare const useAnalytics: () => Analytics;

package/dist/storage.d.ts

@@ -16,11 +16,10 @@ export declare function useStorageTask<T = unknown>(task: UploadTask, ref: Stora
  * @param options
  */
 export declare function useStorageDownloadURL<T = string>(ref: StorageReference, options?: ReactFireOptions<T>): ObservableStatus<string | T>;
-type StorageImageProps = {
+export type StorageImageProps = {
     storagePath: string;
     storage?: FirebaseStorage;
     suspense?: boolean;
-    placeHolder?: JSX.Element;
+    placeHolder?: React.ReactNode;
 };
 export declare function StorageImage(props: StorageImageProps & React.DetailedHTMLProps<React.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>): React.JSX.Element;
-export {};

package/dist/useObservable.d.ts

@@ -2,7 +2,7 @@ import { Observable } from 'rxjs';
 import { SuspenseSubject } from './SuspenseSubject';
 import { ReactFireOptions } from './';
 export declare function preloadObservable<T>(source: Observable<T>, id: string, suspenseEnabled?: boolean): SuspenseSubject<T>;
-export interface ObservableStatus<T> {
+interface ObservableStatusBase<T> {
     /**
      * The loading status.
      *
@@ -28,7 +28,7 @@ export interface ObservableStatus<T> {
      *
      * If `initialData` is passed in, the first value of `data` will be the valuea provided in `initialData` **UNLESS** the underlying observable is ready, in which case it will skip `initialData`.
      */
-    data: T;
+    data: T | undefined;
     /**
      * Any error that may have occurred in the underlying observable
      */
@@ -38,4 +38,20 @@ export interface ObservableStatus<T> {
      */
     firstValuePromise: Promise<void>;
 }
+export interface ObservableStatusSuccess<T> extends ObservableStatusBase<T> {
+    status: 'success';
+    data: T;
+}
+export interface ObservableStatusError<T> extends ObservableStatusBase<T> {
+    status: 'error';
+    isComplete: true;
+    error: Error;
+}
+export interface ObservableStatusLoading<T> extends ObservableStatusBase<T> {
+    status: 'loading';
+    data: undefined;
+    hasEmitted: false;
+}
+export type ObservableStatus<T> = ObservableStatusLoading<T> | ObservableStatusError<T> | ObservableStatusSuccess<T>;
 export declare function useObservable<T = unknown>(observableId: string, source: Observable<T>, config?: ReactFireOptions): ObservableStatus<T>;
+export {};

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "4.2.3-exp.c7357da",
+  "version": "4.2.4",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.umd.cjs",
@@ -36,7 +36,7 @@
     "docs:fork": "typedoc --options typedoc.json --gitRemote upstream && markdown-toc -i docs/use.md"
   },
   "peerDependencies": {
-    "firebase": "^9.0.0 || next",
+    "firebase": "^9.0.0 || ^10.0.0 || ^11.0.0 || ^12.0.0 || next",
     "react": ">=16 || experimental"
   },
   "husky": {
@@ -71,42 +71,44 @@
     }
   ],
   "devDependencies": {
-    "@rollup/plugin-typescript": "^11.1.1",
+    "@rollup/plugin-typescript": "^12.3.0",
     "@size-limit/preset-small-lib": "^8.2.6",
     "@testing-library/jest-dom": "^5.16.5",
     "@testing-library/react": "^14.0.0",
     "@types/react": "^18.2.0",
     "@types/react-dom": "^18.2.0",
+    "@types/use-sync-external-store": "^0.0.3",
     "@typescript-eslint/eslint-plugin": "^5.60.1",
     "@typescript-eslint/parser": "^5.60.1",
-    "@vitejs/plugin-react": "^4.0.1",
-    "@vitest/ui": "^0.32.2",
+    "@vitejs/plugin-react": "^6.0.2",
+    "@vitest/ui": "^4.1.9",
     "cross-fetch": "^3.1.6",
     "eslint": "^8.43.0",
     "eslint-plugin-no-only-tests": "^3.1.0",
     "eslint-plugin-react": "^7.32.2",
     "eslint-plugin-react-hooks": "^4.6.0",
-    "firebase": "^9.9.0",
-    "firebase-tools": "^12.4.0",
+    "firebase": "^11.10.0",
+    "firebase-tools": "^15.22.3",
     "globalthis": "^1.0.3",
     "husky": "^8.0.3",
     "jest-environment-jsdom": "^29.5.0",
     "jsdom": "^22.1.0",
     "markdown-toc": "^1.2.0",
-    "prettier": "^2.8.8",
+    "prettier": "^3.8.4",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "react-test-renderer": "^18.2.0",
     "rollup-plugin-visualizer": "^5.9.2",
     "size-limit": "^8.2.6",
-    "typedoc": "^0.24.8",
-    "typedoc-plugin-markdown": "^3.15.3",
-    "typescript": "^5.1.3",
-    "vite": "^4.3.9",
-    "vitest": "^0.32.2"
+    "typedoc": "^0.28.19",
+    "typedoc-plugin-markdown": "^4.12.0",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.16",
+    "vitest": "^4.1.9"
   },
   "dependencies": {
-    "rxfire": "^6.0.3",
-    "rxjs": "^6.6.3 || ^7.0.1"
+    "rxfire": "^6.1.0",
+    "rxjs": "^6.6.3 || ^7.0.1",
+    "use-sync-external-store": "^1.2.0"
   }
 }

package/src/SuspenseSubject.ts

@@ -1,14 +1,17 @@
 import { empty, Observable, Subject, Subscriber, Subscription } from 'rxjs';
 import { catchError, shareReplay, tap } from 'rxjs/operators';
+import { ObservableStatus } from './useObservable';
 
 export class SuspenseSubject<T> extends Subject<T> {
   private _value: T | undefined;
   private _hasValue = false;
-  private _timeoutHandler: NodeJS.Timeout;
+  private _timeoutHandler: ReturnType<typeof setTimeout>;
   private _firstEmission: Promise<void>;
   private _error: any = undefined;
   private _innerObservable: Observable<T>;
   private _warmupSubscription: Subscription;
+  private _immutableStatus: ObservableStatus<T>;
+  private _isComplete = false;
 
   // @ts-expect-error: TODO: double check to see if this is an RXJS thing or if we should listen to TS
   private _innerSubscriber: Subscription;
@@ -18,6 +21,16 @@ export class SuspenseSubject<T> extends Subject<T> {
   constructor(innerObservable: Observable<T>, private _timeoutWindow: number, private _suspenseEnabled: boolean) {
     super();
     this._firstEmission = new Promise<void>((resolve) => (this._resolveFirstEmission = resolve));
+
+    this._immutableStatus = {
+      status: 'loading',
+      hasEmitted: false,
+      isComplete: false,
+      data: undefined,
+      error: undefined,
+      firstValuePromise: this._firstEmission
+    };
+
     this._innerObservable = innerObservable.pipe(
       tap({
         next: (v) => {
@@ -28,7 +41,12 @@ export class SuspenseSubject<T> extends Subject<T> {
           // resolve the promise, so suspense tries again
           this._error = e;
           this._resolveFirstEmission();
+          this._updateImmutableStatus();
         },
+        complete: () => {
+          this._isComplete = true;
+          this._updateImmutableStatus();
+        }
       }),
       catchError(() => empty()),
       shareReplay(1)
@@ -69,10 +87,27 @@ export class SuspenseSubject<T> extends Subject<T> {
     return this._firstEmission;
   }
 
+  private _updateImmutableStatus() {
+    // @ts-expect-error
+    // TS fails here because ObservableStatus defines specific
+    // relationships between the fields. This is difficult to
+    // code for here, so the relationships between the ObservableStatus fields
+    // are mostly checked in tests instead
+    this._immutableStatus = {
+      status: this._error ? 'error' : (this._hasValue ? 'success' : 'loading'),
+      hasEmitted: this._hasValue,
+      isComplete: this._isComplete,
+      data: this._value,
+      error: this._error,
+      firstValuePromise: this._firstEmission
+    };
+  }
+
   private _next(value: T) {
     this._hasValue = true;
     this._value = value;
     this._resolveFirstEmission();
+    this._updateImmutableStatus();
   }
 
   private _reset() {
@@ -84,6 +119,7 @@ export class SuspenseSubject<T> extends Subject<T> {
     this._value = undefined;
     this._error = undefined;
     this._firstEmission = new Promise<void>((resolve) => (this._resolveFirstEmission = resolve));
+    this._updateImmutableStatus();
   }
 
   _subscribe(subscriber: Subscriber<T>): Subscription {
@@ -97,4 +133,8 @@ export class SuspenseSubject<T> extends Subject<T> {
   get ourError() {
     return this._error;
   }
+
+  get immutableStatus() {
+    return this._immutableStatus;
+  }
 }

package/src/auth.tsx

@@ -25,7 +25,17 @@ export function useUser<T = unknown>(options?: ReactFireOptions<T>): ObservableS
   const observableId = `auth:user:${auth.name}`;
   const observable$ = user(auth);
 
-  return useObservable(observableId, observable$, options);
+  const _options: ReactFireOptions<T> = { ...options };
+
+  // If a user is already signed in, seed initialData so consumers see the user
+  // synchronously on the first render without waiting for the async observable.
+  // We only do this when currentUser is truthy to avoid masking the uninitialized
+  // (null before auth has loaded from storage) case as "signed out".
+  if (auth.currentUser && !('initialData' in _options) && !('startWithValue' in _options)) {
+    _options.initialData = auth.currentUser as unknown as T;
+  }
+
+  return useObservable(observableId, observable$, _options);
 }
 
 export function useIdTokenResult(user: User, forceRefresh = false, options?: ReactFireOptions<IdTokenResult>): ObservableStatus<IdTokenResult> {
@@ -201,7 +211,14 @@ function getClaimsObjectValidator(requiredClaims: Claims): ClaimsValidator {
  * Meant for Concurrent mode only (`<FirebaseAppProvider suspense=true />`). [More detail](https://github.com/FirebaseExtended/reactfire/issues/325#issuecomment-827654376).
  */
 export function ClaimsCheck({ user, fallback, children, requiredClaims }: ClaimsCheckProps) {
-  const { data } = useIdTokenResult(user, false);
+  const { data, status, error } = useIdTokenResult(user, false);
+  
+  if (status === 'loading') {
+    throw new Error('ClaimsCheck must be run in Suspense mode');
+  } else if (status === 'error') {
+    throw error
+  }
+
   const { claims } = data;
   const missingClaims: { [key: string]: { expected: string; actual: string | undefined } } = {};
 
@@ -237,7 +254,7 @@ export function ClaimsCheck({ user, fallback, children, requiredClaims }: Claims
  *
  * Meant for Concurrent mode only (`<FirebaseAppProvider suspense=true />`). [More detail](https://github.com/FirebaseExtended/reactfire/issues/325#issuecomment-827654376).
  */
-export function AuthCheck({ fallback, children, requiredClaims }: AuthCheckProps): JSX.Element {
+export function AuthCheck({ fallback, children, requiredClaims }: AuthCheckProps): React.ReactElement {
   const { data: user } = useUser<User>();
 
   const suspenseMode = useSuspenseEnabledFromConfigAndContext();

package/src/firebaseApp.tsx

@@ -3,13 +3,15 @@ import { getApps, initializeApp, registerVersion } from 'firebase/app';
 
 import type { FirebaseApp, FirebaseOptions } from 'firebase/app';
 
+declare const process: { env: Record<string, string | undefined> };
+
 // INVESTIGATE I don't like magic strings, can we have export this in js-sdk?
 const DEFAULT_APP_NAME = '[DEFAULT]';
 
 const FirebaseAppContext = React.createContext<FirebaseApp | undefined>(undefined);
 const SuspenseEnabledContext = React.createContext<boolean>(false);
 
-interface FirebaseAppProviderProps {
+export interface FirebaseAppProviderProps {
   firebaseApp?: FirebaseApp;
   firebaseConfig?: FirebaseOptions;
   appName?: string;

package/src/firestore.tsx

@@ -59,25 +59,25 @@ export function useFirestoreDocOnce<T = DocumentData>(ref: DocumentReference<T>,
 /**
  * Subscribe to Firestore Document changes and unwrap the document into a plain object
  */
-export function useFirestoreDocData<T = unknown>(ref: DocumentReference<T>, options?: ReactFireOptions<T>): ObservableStatus<T> {
+export function useFirestoreDocData<T = unknown>(ref: DocumentReference<T>, options?: ReactFireOptions<T>): ObservableStatus<T | undefined> {
   const idField = options ? checkIdField(options) : 'NO_ID_FIELD';
 
   const observableId = `firestore:docData:${ref.firestore.app.name}:${ref.path}:idField=${idField}`;
   const observable = docData(ref, { idField });
 
-  return useObservable(observableId, observable, options);
+  return useObservable(observableId, observable, options) as ObservableStatus<T>;
 }
 
 /**
  * Get a Firestore document, unwrap the document into a plain object, and don't subscribe to changes
  */
-export function useFirestoreDocDataOnce<T = unknown>(ref: DocumentReference<T>, options?: ReactFireOptions<T>): ObservableStatus<T> {
+export function useFirestoreDocDataOnce<T = unknown>(ref: DocumentReference<T>, options?: ReactFireOptions<T>): ObservableStatus<T | undefined> {
   const idField = options ? checkIdField(options) : 'NO_ID_FIELD';
 
   const observableId = `firestore:docDataOnce:${ref.firestore.app.name}:${ref.path}:idField=${idField}`;
   const observable$ = docData(ref, { idField }).pipe(first());
 
-  return useObservable(observableId, observable$, options);
+  return useObservable(observableId, observable$, options) as ObservableStatus<T>;
 }
 
 /**

package/src/performance.tsx

@@ -6,20 +6,21 @@ export interface SuspensePerfProps {
   fallback: React.ReactNode;
 }
 
-export function SuspenseWithPerf({ children, traceId, fallback }: SuspensePerfProps): JSX.Element {
+export function SuspenseWithPerf({ children, traceId, fallback }: SuspensePerfProps): React.ReactElement {
   // TODO: Should this import firebase/performance?
 
-  const entries = performance?.getEntriesByName?.(traceId, 'measure') || [];
+  const perf = typeof globalThis !== 'undefined' ? globalThis.performance : undefined;
+  const entries = perf?.getEntriesByName?.(traceId, 'measure') || [];
   const startMarkName = `_${traceId}Start[${entries.length}]`;
   const endMarkName = `_${traceId}End[${entries.length}]`;
 
   const Fallback = () => {
-    React.useLayoutEffect(() => {
-      performance?.mark?.(startMarkName);
+    React.useEffect(() => {
+      perf?.mark?.(startMarkName);
 
       return () => {
-        performance?.mark?.(endMarkName);
-        performance?.measure?.(traceId, startMarkName, endMarkName);
+        perf?.mark?.(endMarkName);
+        perf?.measure?.(traceId, startMarkName, endMarkName);
       };
     }, []);
 

package/src/sdk.tsx

@@ -28,7 +28,7 @@ export const RemoteConfigSdkContext = React.createContext<RemoteConfig | undefin
 type FirebaseSdks = Analytics | AppCheck | Auth | Database | Firestore | FirebasePerformance | FirebaseStorage | Functions | RemoteConfig;
 
 function getSdkProvider<Sdk extends FirebaseSdks>(SdkContext: React.Context<Sdk | undefined>) {
-  return function SdkProvider(props: React.PropsWithChildren<{ sdk: Sdk }>) {
+  return function SdkProvider(props: React.PropsWithChildren<{ sdk: Sdk }>): React.ReactElement {
     if (!props.sdk) throw new Error('no sdk provided');
 
     const contextualAppName = useFirebaseApp().name;

package/src/storage.tsx

@@ -33,11 +33,11 @@ export function useStorageDownloadURL<T = string>(ref: StorageReference, options
   return useObservable(observableId, observable$, options);
 }
 
-type StorageImageProps = {
+export type StorageImageProps = {
   storagePath: string;
   storage?: FirebaseStorage;
   suspense?: boolean;
-  placeHolder?: JSX.Element;
+  placeHolder?: React.ReactNode;
 };
 
 function StorageFromContext(props: StorageImageProps & React.DetailedHTMLProps<React.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>) {
@@ -48,7 +48,7 @@ function StorageFromContext(props: StorageImageProps & React.DetailedHTMLProps<R
   return <INTERNALStorageImage {...props} />;
 }
 
-function INTERNALStorageImage(props: StorageImageProps & React.DetailedHTMLProps<React.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>): JSX.Element {
+function INTERNALStorageImage(props: StorageImageProps & React.DetailedHTMLProps<React.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>): React.ReactNode {
   const { storage, storagePath, suspense, placeHolder, ...imgProps } = props;
 
   const reactfireOptions: ReactFireOptions<string> = {

package/src/useObservable.ts

@@ -1,4 +1,5 @@
 import * as React from 'react';
+import { useSyncExternalStore } from 'use-sync-external-store/shim';
 import { Observable } from 'rxjs';
 import { SuspenseSubject } from './SuspenseSubject';
 import { useSuspenseEnabledFromConfigAndContext } from './firebaseApp';
@@ -26,7 +27,7 @@ export function preloadObservable<T>(source: Observable<T>, id: string, suspense
   }
 }
 
-export interface ObservableStatus<T> {
+interface ObservableStatusBase<T> {
   /**
    * The loading status.
    *
@@ -52,7 +53,7 @@ export interface ObservableStatus<T> {
    *
    * If `initialData` is passed in, the first value of `data` will be the valuea provided in `initialData` **UNLESS** the underlying observable is ready, in which case it will skip `initialData`.
    */
-  data: T;
+  data: T | undefined;
   /**
    * Any error that may have occurred in the underlying observable
    */
@@ -63,42 +64,33 @@ export interface ObservableStatus<T> {
   firstValuePromise: Promise<void>;
 }
 
-function reducerFactory<T>(observable: SuspenseSubject<T>) {
-  return function reducer(state: ObservableStatus<T>, action: 'value' | 'error' | 'complete'): ObservableStatus<T> {
-    // always make sure these values are in sync with the observable
-    const newState = {
-      ...state,
-      hasEmitted: state.hasEmitted || observable.hasValue,
-      error: observable.ourError,
-      firstValuePromise: observable.firstEmission,
-    };
-    if (observable.hasValue) {
-      newState.data = observable.value;
-    }
+export interface ObservableStatusSuccess<T> extends ObservableStatusBase<T> {
+  status: 'success';
+  data: T;
+}
 
-    switch (action) {
-      case 'value':
-        newState.status = 'success';
-        return newState;
-      case 'error':
-        newState.status = 'error';
-        return newState;
-      case 'complete':
-        newState.isComplete = true;
-        return newState;
-      default:
-        throw new Error(`invalid action "${action}"`);
-    }
-  };
+export interface ObservableStatusError<T> extends ObservableStatusBase<T> {
+  status: 'error';
+  isComplete: true;
+  error: Error;
 }
 
+export interface ObservableStatusLoading<T> extends ObservableStatusBase<T> {
+  status: 'loading';
+  data: undefined;
+  hasEmitted: false;
+}
+
+export type ObservableStatus<T> = ObservableStatusLoading<T> | ObservableStatusError<T> | ObservableStatusSuccess<T>;
+
 export function useObservable<T = unknown>(observableId: string, source: Observable<T>, config: ReactFireOptions = {}): ObservableStatus<T> {
-  // Register the observable with the cache
   if (!observableId) {
     throw new Error('cannot call useObservable without an observableId');
   }
+
   const suspenseEnabled = useSuspenseEnabledFromConfigAndContext(config.suspense);
 
+  // Register the observable with the cache
   const observable = preloadObservable(source, observableId, suspenseEnabled);
 
   // Suspend if suspense is enabled and no initial data exists
@@ -108,31 +100,56 @@ export function useObservable<T = unknown>(observableId: string, source: Observa
     throw observable.firstEmission;
   }
 
-  const initialState: ObservableStatus<T> = {
-    status: hasData ? 'success' : 'loading',
-    hasEmitted: hasData,
-    isComplete: false,
-    data: observable.hasValue ? observable.value : config?.initialData ?? config?.startWithValue,
-    error: observable.ourError,
-    firstValuePromise: observable.firstEmission,
-  };
-  const [status, dispatch] = React.useReducer<React.Reducer<ObservableStatus<T>, 'value' | 'error' | 'complete'>>(reducerFactory<T>(observable), initialState);
-
-  React.useEffect(() => {
-    const subscription = observable.subscribe({
-      next: () => {
-        dispatch('value');
-      },
-      error: (e) => {
-        dispatch('error');
-        throw e;
-      },
-      complete: () => {
-        dispatch('complete');
-      },
-    });
-    return () => subscription.unsubscribe();
+  const subscribe = React.useCallback((onStoreChange: () => void) => {
+      const subscription = observable.subscribe({
+        next: () => {
+          onStoreChange();
+        },
+        error: (e) => {
+          onStoreChange();
+          throw e;
+        },
+        complete: () => {
+          onStoreChange();
+        },
+      });
+
+      return () => {
+        subscription.unsubscribe();
+      }
+  }, [observable])
+
+  const getSnapshot = React.useCallback<() => ObservableStatus<T>>(() => {
+    return observable.immutableStatus;
   }, [observable]);
 
-  return status;
+  const update = useSyncExternalStore(subscribe, getSnapshot);
+
+  // Return a new object with initialData overlaid rather than mutating the shared
+  // _immutableStatus reference, which is the same object across all components
+  // using the same observableId.
+  if (!observable.hasValue && hasData) {
+    const initialDataValue = config?.initialData ?? config?.startWithValue;
+
+    // In suspense mode, throw errors so React Error Boundaries can catch them.
+    // In non-suspense mode, surface errors via status so consumers can handle them locally.
+    if (suspenseEnabled && update.error) {
+      throw update.error;
+    }
+
+    return {
+      ...update,
+      data: initialDataValue,
+      status: 'success',
+      hasEmitted: true,
+    } as ObservableStatus<T>;
+  }
+
+  // throw an error if there is an error
+  // TODO(jhuleatt) this is the current, tested-for, behavior. But do we actually want it?
+  if (update.error) {
+    throw update.error;
+  }
+
+  return update;
 }