@legendapp/state 3.0.0-beta.0 → 3.0.0-beta.11

package/sync-plugins/crud.js

@@ -256,40 +256,38 @@ function syncedCrud(props) {
     const saveResult = async (itemKey, input, data, isCreate) => {
       var _a;
       if (data) {
-        const saved = (transform == null ? void 0 : transform.load) ? await transform.load(data, "set") : data;
+        let saved = (transform == null ? void 0 : transform.load) ? await transform.load(data, "set") : data;
         const isChild = itemKey !== "undefined" && asType !== "value";
         const currentPeeked = state.getNodeValue(node);
         const currentValue = isChild ? (_a = asType === "array" && state.isArray(currentPeeked) ? currentPeeked.find((v) => v[fieldId] === itemKey) : void 0) != null ? _a : currentPeeked[itemKey] : currentPeeked;
-        const dataOnSaved = {
-          saved,
-          input,
-          currentValue,
-          isCreate,
-          props
-        };
-        let savedOut = saved;
-        if (savedOut && !state.isNullOrUndefined(currentValue)) {
-          savedOut = clone(savedOut);
-          Object.keys(savedOut).forEach((key) => {
+        if (saved && !state.isNullOrUndefined(currentValue)) {
+          if (onSaved) {
+            const ret = onSaved({
+              saved,
+              input,
+              currentValue,
+              isCreate,
+              props
+            });
+            if (ret) {
+              saved = ret;
+            }
+          }
+          saved = clone(saved);
+          Object.keys(saved).forEach((key) => {
             const i = input[key];
             const c = currentValue[key];
             if (
               // value is already the new value, can ignore
-              savedOut[key] === c || // user has changed local value
-              key !== "id" && i !== c
+              saved[key] === c || // user has changed local value
+              key !== fieldId && i !== c
             ) {
-              delete savedOut[key];
+              delete saved[key];
             }
           });
-          if (onSaved) {
-            const ret = onSaved(dataOnSaved);
-            if (ret) {
-              savedOut = ret;
-            }
-          }
-          const createdAt = fieldCreatedAt ? savedOut[fieldCreatedAt] : void 0;
-          const updatedAt = fieldUpdatedAt ? savedOut[fieldUpdatedAt] : void 0;
-          const value2 = itemKey !== "undefined" && asType !== "value" ? { [itemKey]: savedOut } : savedOut;
+          const createdAt = fieldCreatedAt ? saved[fieldCreatedAt] : void 0;
+          const updatedAt = fieldUpdatedAt ? saved[fieldUpdatedAt] : void 0;
+          const value2 = itemKey !== "undefined" && asType !== "value" ? { [itemKey]: saved } : saved;
           update({
             value: value2,
             lastSync: updatedAt || createdAt ? +new Date(updatedAt || createdAt) : void 0,

package/sync-plugins/crud.mjs

@@ -254,40 +254,38 @@ function syncedCrud(props) {
     const saveResult = async (itemKey, input, data, isCreate) => {
       var _a;
       if (data) {
-        const saved = (transform == null ? void 0 : transform.load) ? await transform.load(data, "set") : data;
+        let saved = (transform == null ? void 0 : transform.load) ? await transform.load(data, "set") : data;
         const isChild = itemKey !== "undefined" && asType !== "value";
         const currentPeeked = getNodeValue(node);
         const currentValue = isChild ? (_a = asType === "array" && isArray(currentPeeked) ? currentPeeked.find((v) => v[fieldId] === itemKey) : void 0) != null ? _a : currentPeeked[itemKey] : currentPeeked;
-        const dataOnSaved = {
-          saved,
-          input,
-          currentValue,
-          isCreate,
-          props
-        };
-        let savedOut = saved;
-        if (savedOut && !isNullOrUndefined(currentValue)) {
-          savedOut = clone(savedOut);
-          Object.keys(savedOut).forEach((key) => {
+        if (saved && !isNullOrUndefined(currentValue)) {
+          if (onSaved) {
+            const ret = onSaved({
+              saved,
+              input,
+              currentValue,
+              isCreate,
+              props
+            });
+            if (ret) {
+              saved = ret;
+            }
+          }
+          saved = clone(saved);
+          Object.keys(saved).forEach((key) => {
             const i = input[key];
             const c = currentValue[key];
             if (
               // value is already the new value, can ignore
-              savedOut[key] === c || // user has changed local value
-              key !== "id" && i !== c
+              saved[key] === c || // user has changed local value
+              key !== fieldId && i !== c
             ) {
-              delete savedOut[key];
+              delete saved[key];
             }
           });
-          if (onSaved) {
-            const ret = onSaved(dataOnSaved);
-            if (ret) {
-              savedOut = ret;
-            }
-          }
-          const createdAt = fieldCreatedAt ? savedOut[fieldCreatedAt] : void 0;
-          const updatedAt = fieldUpdatedAt ? savedOut[fieldUpdatedAt] : void 0;
-          const value2 = itemKey !== "undefined" && asType !== "value" ? { [itemKey]: savedOut } : savedOut;
+          const createdAt = fieldCreatedAt ? saved[fieldCreatedAt] : void 0;
+          const updatedAt = fieldUpdatedAt ? saved[fieldUpdatedAt] : void 0;
+          const value2 = itemKey !== "undefined" && asType !== "value" ? { [itemKey]: saved } : saved;
           update({
             value: value2,
             lastSync: updatedAt || createdAt ? +new Date(updatedAt || createdAt) : void 0,

package/sync-plugins/supabase.js

@@ -36,9 +36,9 @@ function syncedSupabase(props) {
     schema,
     filter,
     actions,
-    fieldCreatedAt: fieldCreatedAtParam,
-    fieldUpdatedAt: fieldUpdatedAtParam,
-    fieldDeleted: fieldDeletedParam,
+    fieldCreatedAt,
+    fieldUpdatedAt,
+    fieldDeleted,
     realtime,
     changesSince,
     transform: transformParam,
@@ -54,9 +54,17 @@ function syncedSupabase(props) {
     ...rest
   } = props;
   const client = supabase;
-  const fieldCreatedAt = fieldCreatedAtParam || (changesSince === "last-sync" ? "created_at" : void 0);
-  const fieldUpdatedAt = fieldUpdatedAtParam || (changesSince === "last-sync" ? "updated_at" : void 0);
-  const fieldDeleted = fieldDeletedParam || (changesSince === "last-sync" ? "deleted" : void 0);
+  if (process.env.NODE_ENV === "development" && changesSince === "last-sync") {
+    if (!fieldCreatedAt) {
+      console.warn("[legend-state] fieldCreatedAt is required when using last-sync mode");
+    }
+    if (!fieldUpdatedAt) {
+      console.warn("[legend-state] fieldUpdatedAt is required when using last-sync mode");
+    }
+    if (!fieldDeleted) {
+      console.warn("[legend-state] fieldDeleted is required when using last-sync mode");
+    }
+  }
   const list = !actions || actions.includes("read") ? listParam ? wrapSupabaseFn(listParam) : async (params) => {
     const { lastSync } = params;
     const clientSchema = schema ? client.schema(schema) : client;

package/sync-plugins/supabase.mjs

@@ -34,9 +34,9 @@ function syncedSupabase(props) {
     schema,
     filter,
     actions,
-    fieldCreatedAt: fieldCreatedAtParam,
-    fieldUpdatedAt: fieldUpdatedAtParam,
-    fieldDeleted: fieldDeletedParam,
+    fieldCreatedAt,
+    fieldUpdatedAt,
+    fieldDeleted,
     realtime,
     changesSince,
     transform: transformParam,
@@ -52,9 +52,17 @@ function syncedSupabase(props) {
     ...rest
   } = props;
   const client = supabase;
-  const fieldCreatedAt = fieldCreatedAtParam || (changesSince === "last-sync" ? "created_at" : void 0);
-  const fieldUpdatedAt = fieldUpdatedAtParam || (changesSince === "last-sync" ? "updated_at" : void 0);
-  const fieldDeleted = fieldDeletedParam || (changesSince === "last-sync" ? "deleted" : void 0);
+  if (process.env.NODE_ENV === "development" && changesSince === "last-sync") {
+    if (!fieldCreatedAt) {
+      console.warn("[legend-state] fieldCreatedAt is required when using last-sync mode");
+    }
+    if (!fieldUpdatedAt) {
+      console.warn("[legend-state] fieldUpdatedAt is required when using last-sync mode");
+    }
+    if (!fieldDeleted) {
+      console.warn("[legend-state] fieldDeleted is required when using last-sync mode");
+    }
+  }
   const list = !actions || actions.includes("read") ? listParam ? wrapSupabaseFn(listParam) : async (params) => {
     const { lastSync } = params;
     const clientSchema = schema ? client.schema(schema) : client;

package/sync-plugins/tanstack-query.d.mts

@@ -1,14 +1,14 @@
-import { SyncedOptions } from '@legendapp/state/sync';
+import { SyncedOptions, Synced } from '@legendapp/state/sync';
 import { QueryKey, QueryObserverOptions, QueryClient, MutationObserverOptions, DefaultError } from '@tanstack/query-core';
 
-interface ObservableQueryOptions<TQueryFnData, TError, TData, TQueryKey extends QueryKey> extends Omit<QueryObserverOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey'> {
+interface ObservableQueryOptions<TQueryFnData, TError, TData, TQueryKey extends QueryKey> extends Omit<QueryObserverOptions<TQueryFnData, TError, TData, TData, TQueryKey>, 'queryKey'> {
     queryKey?: TQueryKey | (() => TQueryKey);
 }
-interface SyncedQueryParams<TQueryFnData, TError, TData, TQueryKey extends QueryKey> extends Omit<SyncedOptions<TData>, 'get' | 'set'> {
+interface SyncedQueryParams<TQueryFnData, TError, TData, TQueryKey extends QueryKey> extends Omit<SyncedOptions<TData>, 'get' | 'set' | 'retry'> {
     queryClient: QueryClient;
     query: ObservableQueryOptions<TQueryFnData, TError, TData, TQueryKey>;
-    mutation?: MutationObserverOptions<TData, TError, void>;
+    mutation?: MutationObserverOptions<TQueryFnData, TError, TData>;
 }
-declare function syncedQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(params: SyncedQueryParams<TQueryFnData, TError, TData, TQueryKey>): TData;
+declare function syncedQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(params: SyncedQueryParams<TQueryFnData, TError, TData, TQueryKey>): Synced<TData>;
 
 export { type ObservableQueryOptions, type SyncedQueryParams, syncedQuery };

package/sync-plugins/tanstack-query.d.ts

@@ -1,14 +1,14 @@
-import { SyncedOptions } from '@legendapp/state/sync';
+import { SyncedOptions, Synced } from '@legendapp/state/sync';
 import { QueryKey, QueryObserverOptions, QueryClient, MutationObserverOptions, DefaultError } from '@tanstack/query-core';
 
-interface ObservableQueryOptions<TQueryFnData, TError, TData, TQueryKey extends QueryKey> extends Omit<QueryObserverOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey'> {
+interface ObservableQueryOptions<TQueryFnData, TError, TData, TQueryKey extends QueryKey> extends Omit<QueryObserverOptions<TQueryFnData, TError, TData, TData, TQueryKey>, 'queryKey'> {
     queryKey?: TQueryKey | (() => TQueryKey);
 }
-interface SyncedQueryParams<TQueryFnData, TError, TData, TQueryKey extends QueryKey> extends Omit<SyncedOptions<TData>, 'get' | 'set'> {
+interface SyncedQueryParams<TQueryFnData, TError, TData, TQueryKey extends QueryKey> extends Omit<SyncedOptions<TData>, 'get' | 'set' | 'retry'> {
     queryClient: QueryClient;
     query: ObservableQueryOptions<TQueryFnData, TError, TData, TQueryKey>;
-    mutation?: MutationObserverOptions<TData, TError, void>;
+    mutation?: MutationObserverOptions<TQueryFnData, TError, TData>;
 }
-declare function syncedQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(params: SyncedQueryParams<TQueryFnData, TError, TData, TQueryKey>): TData;
+declare function syncedQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(params: SyncedQueryParams<TQueryFnData, TError, TData, TQueryKey>): Synced<TData>;
 
 export { type ObservableQueryOptions, type SyncedQueryParams, syncedQuery };

package/sync-plugins/tanstack-query.js

@@ -5,8 +5,14 @@ var sync = require('@legendapp/state/sync');
 var queryCore = require('@tanstack/query-core');
 
 // src/sync-plugins/tanstack-query.ts
+var nextMutationKey = 0;
 function syncedQuery(params) {
-  const { query: options, mutation: mutationOptions, queryClient, ...rest } = params;
+  const { query: options, mutation: mutationOptions, queryClient, initial: initialParam, ...rest } = params;
+  if (initialParam !== void 0) {
+    const initialValue = state.isFunction(initialParam) ? initialParam() : initialParam;
+    options.initialData = initialValue;
+  }
+  const initial = options.initialData;
   const Observer = queryCore.QueryObserver;
   const defaultedOptions = queryClient.defaultQueryOptions(
     options
@@ -66,8 +72,16 @@ function syncedQuery(params) {
   };
   let set = void 0;
   if (mutationOptions) {
-    const mutator = new queryCore.MutationObserver(queryClient, mutationOptions);
+    const options2 = {
+      mutationKey: ["LS-mutation", nextMutationKey++],
+      ...mutationOptions
+    };
+    const mutator = new queryCore.MutationObserver(queryClient, options2);
     set = ({ value }) => {
+      const mutationCache = queryClient.getMutationCache();
+      mutationCache.findAll({ mutationKey: options2.mutationKey }).forEach((mutation) => {
+        mutationCache.remove(mutation);
+      });
       return mutator.mutate(value);
     };
   }
@@ -75,6 +89,7 @@ function syncedQuery(params) {
     get,
     set,
     subscribe,
+    initial,
     ...rest
   });
 }

package/sync-plugins/tanstack-query.mjs

@@ -3,8 +3,14 @@ import { synced } from '@legendapp/state/sync';
 import { MutationObserver, QueryObserver, notifyManager } from '@tanstack/query-core';
 
 // src/sync-plugins/tanstack-query.ts
+var nextMutationKey = 0;
 function syncedQuery(params) {
-  const { query: options, mutation: mutationOptions, queryClient, ...rest } = params;
+  const { query: options, mutation: mutationOptions, queryClient, initial: initialParam, ...rest } = params;
+  if (initialParam !== void 0) {
+    const initialValue = isFunction(initialParam) ? initialParam() : initialParam;
+    options.initialData = initialValue;
+  }
+  const initial = options.initialData;
   const Observer = QueryObserver;
   const defaultedOptions = queryClient.defaultQueryOptions(
     options
@@ -64,8 +70,16 @@ function syncedQuery(params) {
   };
   let set = void 0;
   if (mutationOptions) {
-    const mutator = new MutationObserver(queryClient, mutationOptions);
+    const options2 = {
+      mutationKey: ["LS-mutation", nextMutationKey++],
+      ...mutationOptions
+    };
+    const mutator = new MutationObserver(queryClient, options2);
     set = ({ value }) => {
+      const mutationCache = queryClient.getMutationCache();
+      mutationCache.findAll({ mutationKey: options2.mutationKey }).forEach((mutation) => {
+        mutationCache.remove(mutation);
+      });
       return mutator.mutate(value);
     };
   }
@@ -73,6 +87,7 @@ function syncedQuery(params) {
     get,
     set,
     subscribe,
+    initial,
     ...rest
   });
 }

package/sync-plugins/tanstack-react-query.d.mts

@@ -1,8 +1,10 @@
 import { SyncedQueryParams } from '@legendapp/state/sync-plugins/tanstack-query';
-import { DefaultError, QueryKey } from '@tanstack/query-core';
+import { DefaultError, QueryKey, QueryClient } from '@tanstack/query-core';
 import { Observable } from '@legendapp/state';
 import { Synced } from '@legendapp/state/sync';
 
-declare function useObservableSyncedQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(params: SyncedQueryParams<TQueryFnData, TError, TData, TQueryKey>): Observable<Synced<TData>>;
+declare function useObservableSyncedQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(params: Omit<SyncedQueryParams<TQueryFnData, TError, TData, TQueryKey>, 'queryClient'> & {
+    queryClient?: QueryClient;
+}): Observable<Synced<TData>>;
 
 export { useObservableSyncedQuery };

package/sync-plugins/tanstack-react-query.d.ts

@@ -1,8 +1,10 @@
 import { SyncedQueryParams } from '@legendapp/state/sync-plugins/tanstack-query';
-import { DefaultError, QueryKey } from '@tanstack/query-core';
+import { DefaultError, QueryKey, QueryClient } from '@tanstack/query-core';
 import { Observable } from '@legendapp/state';
 import { Synced } from '@legendapp/state/sync';
 
-declare function useObservableSyncedQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(params: SyncedQueryParams<TQueryFnData, TError, TData, TQueryKey>): Observable<Synced<TData>>;
+declare function useObservableSyncedQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(params: Omit<SyncedQueryParams<TQueryFnData, TError, TData, TQueryKey>, 'queryClient'> & {
+    queryClient?: QueryClient;
+}): Observable<Synced<TData>>;
 
 export { useObservableSyncedQuery };

package/sync.js

@@ -639,8 +639,11 @@ async function doChangeRemote(changeInfo) {
       );
       let didError = false;
       if (state.isPromise(savedPromise)) {
-        await savedPromise.catch(() => {
+        await savedPromise.catch((error) => {
           didError = true;
+          if (!syncOptions.retry) {
+            onError(error);
+          }
         });
       }
       if (!didError) {
@@ -740,9 +743,20 @@ async function loadLocal(value$, syncOptions, syncState$, localState) {
       await state.when(initialized$);
     }
     if (persistPlugin.loadTable) {
-      const promise = persistPlugin.loadTable(table, config);
-      if (promise) {
-        await promise;
+      try {
+        const promise = persistPlugin.loadTable(table, config);
+        if (promise) {
+          await promise;
+        }
+      } catch (err) {
+        if (process.env.NODE_ENV === "development") {
+          console.error(
+            "[legend-state] Error loading local cache. This would be a crashing error in production.",
+            err
+          );
+        } else {
+          throw err;
+        }
       }
     }
     const prevValue = getNodeValue(node);
@@ -845,7 +859,8 @@ function syncObservable(obs$, syncOptionsOrSynced) {
       localState.isApplyingPending = false;
     }
   };
-  if (syncOptions.get) {
+  const { get, subscribe } = syncOptions;
+  if (get || subscribe) {
     sync = async () => {
       var _a;
       if (isSynced && (!getNodeValue(getNode(syncState$)).isSyncEnabled || state.shouldIgnoreUnobserved(node, sync))) {
@@ -858,8 +873,7 @@ function syncObservable(obs$, syncOptionsOrSynced) {
       }
       const lastSync = (_a = metadatas.get(obs$)) == null ? void 0 : _a.lastSync;
       const pending = localState.pendingChanges;
-      const get = syncOptions.get;
-      if (get) {
+      if (get || subscribe) {
         const { waitFor } = syncOptions;
         const runGet = () => {
           var _a2;
@@ -952,7 +966,7 @@ function syncObservable(obs$, syncOptionsOrSynced) {
             node.activationState.onChange = onChange;
           }
           if (!isSubscribed && syncOptions.subscribe) {
-            const subscribe = syncOptions.subscribe;
+            const subscribe2 = syncOptions.subscribe;
             isSubscribed = true;
             const doSubscribe = () => {
               const subscribeParams = {
@@ -960,17 +974,27 @@ function syncObservable(obs$, syncOptionsOrSynced) {
                 value$: obs$,
                 lastSync,
                 update: (params) => {
-                  state.when(syncState$.isLoaded, () => {
-                    state.when(waitFor || true, () => {
-                      params.mode || (params.mode = syncOptions.mode || "merge");
-                      onChange(params);
-                    });
-                  });
+                  state.when(
+                    () => !get || syncState$.isLoaded.get(),
+                    () => {
+                      state.when(waitFor || true, () => {
+                        params.mode || (params.mode = syncOptions.mode || "merge");
+                        onChange(params);
+                        if (!syncState$.isLoaded.peek()) {
+                          syncState$.assign({
+                            isLoaded: syncStateValue.numPendingRemoteLoads < 1,
+                            error: void 0,
+                            isGetting: syncStateValue.numPendingGets > 0
+                          });
+                        }
+                      });
+                    }
+                  );
                 },
                 refresh: () => state.when(syncState$.isLoaded, sync),
                 onError: (error) => onGetError(error, { source: "subscribe", subscribeParams })
               };
-              unsubscribe = subscribe(subscribeParams);
+              unsubscribe = subscribe2(subscribeParams);
             };
             if (waitFor) {
               state.whenReady(waitFor, doSubscribe);
@@ -979,85 +1003,87 @@ function syncObservable(obs$, syncOptionsOrSynced) {
             }
           }
           const existingValue = getNodeValue(node);
-          const onError = (error) => onGetError(error, { getParams, source: "get" });
-          const getParams = {
-            node,
-            value$: obs$,
-            value: state.isFunction(existingValue) || (existingValue == null ? void 0 : existingValue[symbolLinked]) ? void 0 : existingValue,
-            mode: syncOptions.mode,
-            refresh: sync,
-            options: syncOptions,
-            lastSync,
-            updateLastSync: (lastSync2) => getParams.lastSync = lastSync2,
-            onError,
-            retryNum: 0,
-            cancelRetry: false
-          };
-          let modeBeforeReset = void 0;
-          const beforeGetParams = {
-            value: getParams.value,
-            lastSync,
-            pendingChanges: pending && !state.isEmpty(pending) ? pending : void 0,
-            clearPendingChanges: async () => {
-              localState.pendingChanges = {};
-              await updateMetadataImmediate(obs$, localState, syncState$, syncOptions, {
-                pending: localState.pendingChanges
-              });
-            },
-            resetCache: () => {
-              var _a3;
-              modeBeforeReset = getParams.mode;
-              getParams.mode = "set";
-              return (_a3 = syncStateValue.resetPersistence) == null ? void 0 : _a3.call(syncStateValue);
-            },
-            cancel: false
-          };
-          (_a2 = syncOptions.onBeforeGet) == null ? void 0 : _a2.call(syncOptions, beforeGetParams);
-          if (!beforeGetParams.cancel) {
-            syncState$.assign({
-              numPendingGets: (syncStateValue.numPendingGets || 0) + 1,
-              isGetting: true
-            });
-            const got = runWithRetry(
-              getParams,
-              syncOptions.retry,
-              (retryEvent) => {
-                const params = getParams;
-                params.cancelRetry = retryEvent.cancelRetry;
-                params.retryNum = retryEvent.retryNum;
-                return get(params);
-              },
-              onError
-            );
-            const numGets = node.numGets = (node.numGets || 0) + 1;
-            const handle = (value) => {
-              syncState$.numPendingGets.set((v) => v - 1);
-              if (isWaitingForLoad) {
-                isWaitingForLoad = false;
-                syncStateValue.numPendingRemoteLoads--;
-              }
-              if (numGets >= (node.getNumResolved || 0)) {
-                node.getNumResolved = node.numGets;
-                onChange({
-                  value,
-                  lastSync: getParams.lastSync,
-                  mode: getParams.mode
+          if (get) {
+            const onError = (error) => onGetError(error, { getParams, source: "get" });
+            const getParams = {
+              node,
+              value$: obs$,
+              value: state.isFunction(existingValue) || (existingValue == null ? void 0 : existingValue[symbolLinked]) ? void 0 : existingValue,
+              mode: syncOptions.mode,
+              refresh: sync,
+              options: syncOptions,
+              lastSync,
+              updateLastSync: (lastSync2) => getParams.lastSync = lastSync2,
+              onError,
+              retryNum: 0,
+              cancelRetry: false
+            };
+            let modeBeforeReset = void 0;
+            const beforeGetParams = {
+              value: getParams.value,
+              lastSync,
+              pendingChanges: pending && !state.isEmpty(pending) ? pending : void 0,
+              clearPendingChanges: async () => {
+                localState.pendingChanges = {};
+                await updateMetadataImmediate(obs$, localState, syncState$, syncOptions, {
+                  pending: localState.pendingChanges
                 });
-              }
-              if (modeBeforeReset) {
-                getParams.mode = modeBeforeReset;
-                modeBeforeReset = void 0;
-              }
+              },
+              resetCache: () => {
+                var _a3;
+                modeBeforeReset = getParams.mode;
+                getParams.mode = "set";
+                return (_a3 = syncStateValue.resetPersistence) == null ? void 0 : _a3.call(syncStateValue);
+              },
+              cancel: false
+            };
+            (_a2 = syncOptions.onBeforeGet) == null ? void 0 : _a2.call(syncOptions, beforeGetParams);
+            if (!beforeGetParams.cancel) {
               syncState$.assign({
-                isLoaded: syncStateValue.numPendingRemoteLoads < 1,
-                error: void 0,
-                isGetting: syncStateValue.numPendingGets > 0
+                numPendingGets: (syncStateValue.numPendingGets || 0) + 1,
+                isGetting: true
               });
-            };
-            if (state.isPromise(got)) {
-              got.then(handle).catch(onError);
-            } else {
-              handle(got);
+              const got = runWithRetry(
+                getParams,
+                syncOptions.retry,
+                (retryEvent) => {
+                  const params = getParams;
+                  params.cancelRetry = retryEvent.cancelRetry;
+                  params.retryNum = retryEvent.retryNum;
+                  return get(params);
+                },
+                onError
+              );
+              const numGets = node.numGets = (node.numGets || 0) + 1;
+              const handle = (value) => {
+                syncState$.numPendingGets.set((v) => v - 1);
+                if (isWaitingForLoad) {
+                  isWaitingForLoad = false;
+                  syncStateValue.numPendingRemoteLoads--;
+                }
+                if (numGets >= (node.getNumResolved || 0)) {
+                  node.getNumResolved = node.numGets;
+                  onChange({
+                    value,
+                    lastSync: getParams.lastSync,
+                    mode: getParams.mode
+                  });
+                }
+                if (modeBeforeReset) {
+                  getParams.mode = modeBeforeReset;
+                  modeBeforeReset = void 0;
+                }
+                syncState$.assign({
+                  isLoaded: syncStateValue.numPendingRemoteLoads < 1,
+                  error: void 0,
+                  isGetting: syncStateValue.numPendingGets > 0
+                });
+              };
+              if (state.isPromise(got)) {
+                got.then(handle).catch(onError);
+              } else {
+                handle(got);
+              }
             }
           }
         };
@@ -1129,7 +1155,7 @@ function syncObservable(obs$, syncOptionsOrSynced) {
     return true;
   };
   state.when(onAllPersistLoaded, function() {
-    if (syncOptions.get && syncOptions.syncMode === "auto") {
+    if ((syncOptions.get || syncOptions.subscribe) && syncOptions.syncMode === "auto") {
       sync();
     }
     if ((syncOptions == null ? void 0 : syncOptions.set) || (syncOptions == null ? void 0 : syncOptions.persist)) {