@legendapp/state 2.2.0-next.73 → 2.2.0-next.75

package/src/is.ts

@@ -30,6 +30,13 @@ export function isBoolean(obj: unknown): obj is boolean {
 export function isPromise<T>(obj: unknown): obj is Promise<T> {
     return obj instanceof Promise;
 }
+export function isMap(obj: unknown): obj is Map<any, any> {
+    return obj instanceof Map;
+}
+export function isNumber(obj: unknown): obj is number {
+    const n = obj as number;
+    return n - n < 1;
+}
 export function isEmpty(obj: object): boolean {
     // Looping and returning false on the first property is faster than Object.keys(obj).length === 0
     // https://jsbench.me/qfkqv692c8

package/src/observableTypes.ts

@@ -41,11 +41,16 @@ interface ObservableObjectFns<T> {
 
 interface ObservableObjectFunctions<T = Record<string, any>> extends ObservablePrimitive<T>, ObservableObjectFns<T> {}
 
+type MapKey<T extends Map<any, any> | WeakMap<any, any>> = Parameters<T['has']>[0];
+type MapValue<T extends Map<any, any> | WeakMap<any, any>> = Parameters<T['get']>[0];
 type ObservableMap<T extends Map<any, any> | WeakMap<any, any>> = Omit<T, 'get' | 'size'> &
     Omit<ObservablePrimitive<T>, 'get' | 'size'> & {
         get(key: Parameters<T['get']>[0]): Observable<Parameters<T['set']>[1]>;
         get(): T;
         size: ImmutableObservableBase<number>;
+        assign(
+            value: Record<MapKey<T>, MapValue<T>> | Map<MapKey<T>, MapValue<T>> | WeakMap<MapKey<T>, MapValue<T>>,
+        ): Observable<T>;
     };
 
 type ObservableSet<T extends Set<any> | WeakSet<any>> = Omit<T, 'size'> &

package/src/react/For.tsx

@@ -1,5 +1,5 @@
 import type { Observable, ObservableObject, ObservableParam } from '@legendapp/state';
-import { internal, isArray, isFunction } from '@legendapp/state';
+import { internal, isArray, isFunction, isMap } from '@legendapp/state';
 import { FC, ReactElement, createElement, memo, useMemo, useRef } from 'react';
 import { observer } from './reactive-observer';
 import { useSelector } from './useSelector';
@@ -92,15 +92,15 @@ export function For<T, TProps>({
         }
     } else {
         // Render the values of the object / Map
-        const isMap = value instanceof Map;
-        const keys = isMap ? Array.from(value.keys()) : Object.keys(value);
+        const asMap = isMap(value);
+        const keys = asMap ? Array.from(value.keys()) : Object.keys(value);
         if (sortValues) {
-            keys.sort((A, B) => sortValues(isMap ? value.get(A)! : value[A], isMap ? value.get(B)! : value[B], A, B));
+            keys.sort((A, B) => sortValues(asMap ? value.get(A)! : value[A], asMap ? value.get(B)! : value[B], A, B));
         }
         for (let i = 0; i < keys.length; i++) {
             const key = keys[i];
-            if (isMap ? value.get(key) : value[key]) {
-                const item$ = isMap ? each!.get(key) : (each as ObservableObject<Record<string, any>>)[key];
+            if (asMap ? value.get(key) : value[key]) {
+                const item$ = asMap ? each!.get(key) : (each as ObservableObject<Record<string, any>>)[key];
                 const props: ForItemProps<any> & { key: string; item: Observable<any> } = {
                     key,
                     id: key,

package/src/sync/activateSyncedNode.ts

@@ -1,5 +1,4 @@
 import type {
-    GetMode,
     NodeValue,
     Observable,
     ObservableOnChangeParams,
@@ -35,18 +34,21 @@ export function enableActivateSyncedNode() {
                 pluginRemote.get = (params: ObservableSyncGetParams<any>) => {
                     onChange = params.onChange;
                     const updateLastSync = (lastSync: number) => (params.lastSync = lastSync);
-                    const setMode = (mode: GetMode) => (params.mode = mode);
 
                     const existingValue = getNodeValue(node);
                     const value = runWithRetry(node, { attemptNum: 0 }, () => {
-                        return get!({
+                        const paramsToGet = {
                             value:
                                 isFunction(existingValue) || existingValue?.[symbolLinked] ? undefined : existingValue,
                             lastSync: params.lastSync!,
                             updateLastSync,
-                            setMode,
+                            mode: params.mode!,
                             refresh,
-                        });
+                        };
+
+                        const ret = get!(paramsToGet);
+                        params.mode = paramsToGet.mode;
+                        return ret;
                     });
 
                     promiseReturn = value;

package/src/sync/syncHelpers.ts

@@ -1,15 +1,56 @@
-import { isObject } from '@legendapp/state';
-
-export function removeNullUndefined<T extends Record<string, any>>(val: T) {
-    if (val) {
-        Object.keys(val).forEach((key) => {
-            const v = val[key];
-            if (v === null || v === undefined) {
-                delete val[key];
-            } else if (isObject(v)) {
-                removeNullUndefined(v);
+import { isDate, isNullOrUndefined, isObject } from '@legendapp/state';
+
+export function removeNullUndefined<T extends Record<string, any>>(a: T, recursive?: boolean): T {
+    const out: T = {} as T;
+    Object.keys(a).forEach((key: keyof T) => {
+        if (a[key] !== null && a[key] !== undefined) {
+            out[key] = recursive && isObject(a[key]) ? removeNullUndefined(a[key]) : a[key];
+        }
+    });
+
+    return out;
+}
+
+export function diffObjects<T extends Record<string, any>>(obj1: T, obj2: T, deep: boolean = false): Partial<T> {
+    const diff: Partial<T> = {};
+    if (!obj1) return obj2 || diff;
+    if (!obj2) return obj1 || diff;
+
+    const keys = new Set<keyof T>([...Object.keys(obj1), ...Object.keys(obj2)] as (keyof T)[]);
+
+    keys.forEach((key) => {
+        const o1 = obj1[key];
+        const o2 = obj2[key];
+        if (deep ? !deepEqual(o1, o2) : o1 !== o2) {
+            if (!isDate(o1) || !isDate(o2) || o1.getTime() !== o2.getTime()) {
+                diff[key] = o2;
             }
-        });
+        }
+    });
+
+    return diff;
+}
+export function deepEqual<T extends Record<string, any> = any>(
+    a: T,
+    b: T,
+    ignoreFields?: string[],
+    nullVsUndefined?: boolean,
+): boolean {
+    if (a === b) {
+        return true;
+    }
+    if (isNullOrUndefined(a) !== isNullOrUndefined(b)) {
+        return false;
+    }
+
+    if (nullVsUndefined) {
+        a = removeNullUndefined(a, /*recursive*/ true);
+        b = removeNullUndefined(b, /*recursive*/ true);
     }
-    return val;
+
+    const replacer = ignoreFields
+        ? (key: string, value: any) => (ignoreFields.includes(key) ? undefined : value)
+        : undefined;
+
+    return JSON.stringify(a, replacer) === JSON.stringify(b, replacer);
 }

package/src/sync/syncObservable.ts

@@ -207,7 +207,12 @@ function mergeChanges(changes: Change[]) {
         const pathStr = change.path.join('/');
         const existing = changesByPath.get(pathStr);
         if (existing) {
-            existing.valueAtPath = change.valueAtPath;
+            // If setting a value back to what it was, no need to save it
+            if (change.valueAtPath === existing.prevAtPath) {
+                changesOut.splice(changesOut.indexOf(change), 1);
+            } else {
+                existing.valueAtPath = change.valueAtPath;
+            }
         } else {
             changesByPath.set(pathStr, change);
             changesOut.push(change);
@@ -226,6 +231,7 @@ function mergeQueuedChanges(allChanges: QueuedChange[]) {
     for (let i = 0; i < allChanges.length; i++) {
         const value = allChanges[i];
         const { obs, changes, inRemoteChange, getPrevious } = value;
+        const targetMap = inRemoteChange ? outRemote : outLocal;
         const changesMap = inRemoteChange ? changesByObsRemote : changesByObsLocal;
         const existing = changesMap.get(obs);
         const newChanges = existing ? [...existing, ...changes] : changes;
@@ -236,7 +242,7 @@ function mergeQueuedChanges(allChanges: QueuedChange[]) {
             previousByObs.set(obs, getPrevious());
         }
         value.valuePrevious = previousByObs.get(obs);
-        (inRemoteChange ? outRemote : outLocal).set(obs, value);
+        targetMap.set(obs, value);
     }
     return Array.from(outRemote.values()).concat(Array.from(outLocal.values()));
 }
@@ -532,8 +538,7 @@ async function doChangeLocal(changeInfo: PreppedChangeLocal | undefined) {
 
     const persist = syncOptions.persist;
     const { table, config: configLocal } = parseLocalConfig(persist!);
-    const configRemote = syncOptions;
-    const shouldSaveMetadata = persist && configRemote?.offlineBehavior === 'retry';
+    const shouldSaveMetadata = persist?.retrySync;
 
     if (saveRemote && shouldSaveMetadata) {
         // First save pending changes before saving local or remote
@@ -568,9 +573,9 @@ async function doChangeRemote(changeInfo: PreppedChangeRemote | undefined) {
 
     const persist = syncOptions.persist;
     const { table, config: configLocal } = parseLocalConfig(persist!);
-    const { offlineBehavior, allowSetIfGetError, onBeforeSet, onSetError, waitForSet, onAfterSet } =
+    const { allowSetIfGetError, onBeforeSet, onSetError, waitForSet, onAfterSet } =
         syncOptions || ({} as SyncedOptions);
-    const shouldSaveMetadata = persist && offlineBehavior === 'retry';
+    const shouldSaveMetadata = persist?.retrySync;
 
     if (changesRemote.length > 0) {
         // Wait for remote to be ready before saving
@@ -618,11 +623,11 @@ async function doChangeRemote(changeInfo: PreppedChangeRemote | undefined) {
             const pathStrs = Array.from(new Set(changesRemote.map((change) => change.pathStr)));
             const { changes, lastSync } = saved;
             if (pathStrs.length > 0) {
+                let transformedChanges: object | undefined = undefined;
+                const metadata: PersistMetadata = {};
                 if (persist) {
-                    const metadata: PersistMetadata = {};
                     const pendingMetadata = pluginPersist!.getMetadata(table, configLocal)?.pending;
                     const pending = localState.pendingChanges;
-                    let transformedChanges: object | undefined = undefined;
 
                     for (let i = 0; i < pathStrs.length; i++) {
                         const pathStr = pathStrs[i];
@@ -643,37 +648,39 @@ async function doChangeRemote(changeInfo: PreppedChangeRemote | undefined) {
                     if (lastSync) {
                         metadata.lastSync = lastSync;
                     }
+                }
 
-                    // Remote can optionally have data that needs to be merged back into the observable,
-                    // for example Firebase may update dateModified with the server timestamp
-                    if (changes && !isEmpty(changes)) {
-                        transformedChanges = transformLoadData(changes, syncOptions, false);
-                    }
+                // Remote can optionally have data that needs to be merged back into the observable,
+                // for example Firebase may update dateModified with the server timestamp
+                if (changes && !isEmpty(changes)) {
+                    transformedChanges = transformLoadData(changes, syncOptions, false);
+                }
 
-                    if (localState.numSavesOutstanding > 0) {
-                        if (transformedChanges) {
-                            if (!localState.pendingSaveResults) {
-                                localState.pendingSaveResults = [];
-                            }
-                            localState.pendingSaveResults.push(transformedChanges);
+                if (localState.numSavesOutstanding > 0) {
+                    if (transformedChanges) {
+                        if (!localState.pendingSaveResults) {
+                            localState.pendingSaveResults = [];
                         }
-                    } else {
-                        let allChanges = [...(localState.pendingSaveResults || []), transformedChanges].filter(
-                            (v) => v !== undefined,
-                        );
-                        if (allChanges.length > 0) {
-                            if (allChanges.some((change) => isPromise(change))) {
-                                allChanges = await Promise.all(allChanges);
-                            }
-                            onChangeRemote(() => mergeIntoObservable(obs, ...allChanges));
+                        localState.pendingSaveResults.push(transformedChanges);
+                    }
+                } else {
+                    let allChanges = [...(localState.pendingSaveResults || []), transformedChanges].filter(
+                        (v) => v !== undefined,
+                    );
+                    if (allChanges.length > 0) {
+                        if (allChanges.some((change) => isPromise(change))) {
+                            allChanges = await Promise.all(allChanges);
                         }
+                        onChangeRemote(() => mergeIntoObservable(obs, ...allChanges));
+                    }
 
+                    if (persist) {
                         if (shouldSaveMetadata && !isEmpty(metadata)) {
                             updateMetadata(obs, localState, syncState, syncOptions, metadata);
                         }
-
-                        localState.pendingSaveResults = [];
                     }
+
+                    localState.pendingSaveResults = [];
                 }
                 onAfterSet?.();
             }

package/src/sync-plugins/crud.ts

@@ -0,0 +1,373 @@
+import {
+    SyncTransform,
+    SyncedGetParams,
+    SyncedOptions,
+    SyncedSetParams,
+    internal,
+    isArray,
+    isNullOrUndefined,
+    isNumber,
+    isObject,
+    isString,
+} from '@legendapp/state';
+import { synced, diffObjects } from '@legendapp/state/sync';
+
+const { clone } = internal;
+
+export type CrudAsOption = 'Map' | 'object' | 'first' | 'array';
+
+export type CrudResult<T> = T;
+
+export interface SyncedCrudPropsSingle<TGet> {
+    get?: (params: SyncedGetParams) => Promise<CrudResult<TGet | null>> | CrudResult<TGet | null>;
+    initial?: TGet;
+}
+export interface SyncedCrudPropsMany<TGet, TOption extends CrudAsOption> {
+    list?: (params: SyncedGetParams) => Promise<CrudResult<TGet[]>> | CrudResult<TGet[]>;
+    as?: TOption;
+    initial?: InitialValue<TGet, TOption>;
+}
+export interface SyncedCrudPropsBase<TGet extends { id: string }, TSet = TGet, TOut = TGet>
+    extends Omit<SyncedOptions<TGet>, 'get' | 'set' | 'subscribe' | 'transform' | 'initial'> {
+    generateId?: () => string;
+    create?: (input: TSet, params: SyncedSetParams<TSet>) => Promise<CrudResult<TGet>>;
+    update?: (input: Partial<TGet>, params: SyncedSetParams<TSet>) => Promise<CrudResult<Partial<TGet>>>;
+    delete?: (input: TGet, params: SyncedSetParams<TSet>) => Promise<CrudResult<any>>;
+    onSaved?: (saved: Partial<TGet>, input: Partial<TGet>, isCreate: boolean) => Partial<TGet>;
+    transform?: SyncTransform<TOut, TGet>;
+    fieldUpdatedAt?: string;
+    updatePartial?: boolean;
+}
+
+type OutputType<TGet, TSet> = [TSet] extends [unknown] ? TGet : Partial<TGet> & TSet;
+
+type InitialValue<T, TOption extends CrudAsOption> = TOption extends 'Map'
+    ? Map<string, T>
+    : TOption extends 'object'
+    ? Record<string, T>
+    : TOption extends 'first'
+    ? T
+    : T[];
+
+export type SyncedCrudReturnType<TGet, TSet, TOption extends CrudAsOption> = Promise<
+    TOption extends 'Map'
+        ? Map<string, OutputType<TGet, TSet>>
+        : TOption extends 'object'
+        ? Record<string, OutputType<TGet, TSet>>
+        : TOption extends 'first'
+        ? OutputType<TGet, TSet>
+        : TGet[]
+> & {};
+
+let _asOption: CrudAsOption;
+
+function transformOut<T>(data: T, transform: undefined | ((value: T) => T)) {
+    return transform ? transform(clone(data)) : data;
+}
+
+// TODO
+export function createTransform<T extends Record<string, any>, T2 extends Record<string, any>>(
+    ...keys: (keyof T | { from: keyof T; to: keyof T2 })[]
+): SyncTransform<T2, T> {
+    return {
+        load: (value: T) => {
+            (keys as string[]).forEach((key) => {
+                const keyRemote = isObject(key) ? key.from : key;
+                const keyLocal = isObject(key) ? key.to : key;
+                const v = value[keyRemote];
+                if (!isNullOrUndefined(v)) {
+                    value[keyLocal as keyof T] = isString(v) ? JSON.parse(v as string) : v;
+                }
+                if (keyLocal !== keyRemote) {
+                    delete value[keyRemote];
+                }
+            });
+            return value as unknown as T2;
+        },
+        save: (value: T2) => {
+            (keys as string[]).forEach((key: string) => {
+                const keyRemote = isObject(key) ? key.from : key;
+                const keyLocal = isObject(key) ? key.to : key;
+                let v = (value as any)[keyLocal];
+                if (!isNullOrUndefined(v)) {
+                    if (isArray(v)) {
+                        v = v.filter((val) => !isNullOrUndefined(val));
+                    }
+                    value[keyRemote as keyof T2] =
+                        isNumber(v) || isObject(v) || isArray(v) ? (JSON.stringify(v) as any) : v;
+                }
+                if (keyLocal !== keyRemote) {
+                    delete value[keyLocal];
+                }
+            });
+            return value as unknown as T;
+        },
+    };
+}
+
+// TODO
+export function combineTransforms<T, T2>(
+    transform1: SyncTransform<T2, T>,
+    ...transforms: Partial<SyncTransform<T2, T>>[]
+): SyncTransform<T2, T> {
+    return {
+        load: (value: T) => {
+            let inValue = transform1.load?.(value) as any;
+            transforms.forEach((transform) => {
+                if (transform.load) {
+                    inValue = transform.load(inValue);
+                }
+            });
+            return inValue;
+        },
+        save: (value: T2) => {
+            let outValue = value as any;
+            transforms.forEach((transform) => {
+                if (transform.save) {
+                    outValue = transform.save(outValue);
+                }
+            });
+            return transform1.save?.(outValue) ?? outValue;
+        },
+    };
+}
+
+export function syncedCrud<TGet extends { id: string }, TSet = TGet, TOut = TGet>(
+    props: SyncedCrudPropsBase<TGet, TSet, TOut> & SyncedCrudPropsSingle<TGet>,
+): SyncedCrudReturnType<TOut, TSet, 'first'>;
+export function syncedCrud<
+    TGet extends { id: string },
+    TSet = TGet,
+    TOut = TGet,
+    TOption extends CrudAsOption = 'object',
+>(
+    props: SyncedCrudPropsBase<TGet, TSet, TOut> & SyncedCrudPropsMany<TGet, TOption>,
+): SyncedCrudReturnType<TOut, TSet, Exclude<TOption, 'first'>>;
+export function syncedCrud<
+    TGet extends { id: string },
+    TSet = TGet,
+    TOut = TGet,
+    TOption extends CrudAsOption = 'object',
+>(
+    props: SyncedCrudPropsBase<TGet, TSet, TOut> & (SyncedCrudPropsSingle<TGet> & SyncedCrudPropsMany<TGet, TOption>),
+): SyncedCrudReturnType<TOut, TSet, TOption> {
+    const {
+        get: getFn,
+        list: listFn,
+        create: createFn,
+        update: updateFn,
+        delete: deleteFn,
+        transform,
+        fieldUpdatedAt,
+        generateId,
+        updatePartial,
+        onSaved,
+        mode: modeParam,
+        ...rest
+    } = props;
+
+    let asType = props.as;
+
+    if (!asType) {
+        asType = (getFn ? 'first' : _asOption || 'array') as CrudAsOption as TOption;
+    }
+
+    const asMap = asType === 'Map';
+
+    const ensureId = (obj: { id: string }) => obj.id || (obj.id = generateId!());
+
+    const get: undefined | ((params: SyncedGetParams) => Promise<TOut>) =
+        getFn || listFn
+            ? async (getParams: SyncedGetParams) => {
+                  const { updateLastSync, lastSync } = getParams;
+                  if (listFn) {
+                      if (lastSync) {
+                          getParams.mode =
+                              modeParam || (asType === 'array' ? 'append' : asType === 'first' ? 'set' : 'assign');
+                      }
+
+                      let data = await listFn(getParams);
+                      let newLastSync = 0;
+                      for (let i = 0; i < data.length; i++) {
+                          const updated = (data[i] as any)[fieldUpdatedAt as any];
+                          if (updated) {
+                              newLastSync = Math.max(newLastSync, +new Date(updated));
+                          }
+                      }
+                      if (newLastSync && newLastSync !== lastSync) {
+                          updateLastSync(newLastSync);
+                      }
+                      if (transform?.load) {
+                          data = data.map(transform.load) as any;
+                      }
+                      if (asType === 'first') {
+                          return data.length > 0 ? data[0] : lastSync ? {} : null;
+                      } else if (asType === 'array') {
+                          return data;
+                      } else {
+                          const out: Record<string, any> = asMap ? new Map() : {};
+                          data.forEach((result: any) => {
+                              const value = result.__deleted ? internal.symbolDelete : result;
+                              asMap ? (out as Map<any, any>).set(result.id, value) : (out[result.id] = value);
+                          });
+                          return out;
+                      }
+                  } else if (getFn) {
+                      let data = await getFn(getParams);
+
+                      if (data) {
+                          const newLastSync = (data as any)[fieldUpdatedAt as any];
+                          if (newLastSync && newLastSync !== lastSync) {
+                              updateLastSync(newLastSync);
+                          }
+                          if (transform?.load) {
+                              data = transform.load(data as any) as any;
+                          }
+                      }
+
+                      return data as any;
+                  }
+              }
+            : undefined;
+
+    const set =
+        createFn || updateFn || deleteFn
+            ? async (params: SyncedSetParams<any> & { retryAsCreate?: boolean }) => {
+                  const { value, changes, update, retryAsCreate, valuePrevious } = params;
+                  const creates = new Map<string, TSet>();
+                  const updates = new Map<string, object>();
+                  const deletes = new Map<string, object>();
+
+                  changes.forEach(({ path, prevAtPath, valueAtPath }) => {
+                      if (asType === 'first') {
+                          if (value) {
+                              let id = value?.id;
+                              const isCreate = fieldUpdatedAt ? !value[fieldUpdatedAt!] : !prevAtPath;
+                              if (isCreate || retryAsCreate) {
+                                  id = ensureId(value);
+                                  creates.set(id, value);
+                              } else if (path.length === 0) {
+                                  if (valueAtPath) {
+                                      updates.set(id, valueAtPath);
+                                  } else if (prevAtPath) {
+                                      deletes.set(prevAtPath?.id, prevAtPath);
+                                  }
+                              } else {
+                                  const key = path[0];
+                                  updates.set(id, Object.assign(updates.get(id) || { id }, { [key]: value[key] }));
+                              }
+                          } else if (path.length === 0) {
+                              const id = prevAtPath?.id;
+                              if (id) {
+                                  deletes.set(id, prevAtPath);
+                              }
+                          }
+                      } else {
+                          let itemsChanged: any[] | undefined = undefined;
+                          let isCreateGuess: boolean;
+                          if (path.length === 0) {
+                              isCreateGuess =
+                                  !fieldUpdatedAt &&
+                                  !(
+                                      (asMap
+                                          ? Array.from((valueAtPath as Map<any, any>).values())
+                                          : isArray(valueAtPath)
+                                          ? valueAtPath
+                                          : Object.values(valueAtPath)
+                                      )?.length > 0
+                                  );
+                              itemsChanged = asMap
+                                  ? Array.from((valueAtPath as Map<any, any>).values())
+                                  : isArray(valueAtPath)
+                                  ? valueAtPath
+                                  : Object.values(valueAtPath);
+                          } else {
+                              const itemKey = path[0];
+                              const itemValue = asMap ? value.get(itemKey) : value[itemKey];
+                              isCreateGuess = !fieldUpdatedAt && path.length === 1 && !prevAtPath;
+                              if (!itemValue) {
+                                  if (path.length === 1 && prevAtPath) {
+                                      if (deleteFn) {
+                                          deletes.set(itemKey, prevAtPath);
+                                      } else {
+                                          console.log('[legend-state] missing delete function');
+                                      }
+                                  }
+                              } else {
+                                  itemsChanged = [itemValue];
+                              }
+                          }
+                          itemsChanged?.forEach((item) => {
+                              ensureId(item);
+                              const isCreate = fieldUpdatedAt ? !item[fieldUpdatedAt!] : isCreateGuess;
+                              if (isCreate) {
+                                  if (createFn) {
+                                      creates.set(item.id, item);
+                                  } else {
+                                      console.log('[legend-state] missing create function');
+                                  }
+                              } else {
+                                  if (updateFn) {
+                                      updates.set(item.id, item);
+                                  } else {
+                                      console.log('[legend-state] missing update function');
+                                  }
+                              }
+                          });
+                      }
+                  });
+
+                  const saveResult = async (
+                      itemKey: string,
+                      input: object,
+                      data: CrudResult<TSet>,
+                      isCreate: boolean,
+                  ) => {
+                      if (data && onSaved) {
+                          const dataLoaded: TGet = (transform?.load ? transform.load(data as any) : data) as any;
+
+                          const savedOut = onSaved(dataLoaded, input, isCreate);
+
+                          const updatedAt = fieldUpdatedAt ? savedOut[fieldUpdatedAt as keyof TGet] : undefined;
+
+                          const value =
+                              itemKey !== 'undefined' && asType !== 'first' ? { [itemKey]: savedOut } : savedOut;
+                          update({
+                              value,
+                              lastSync: updatedAt ? +new Date(updatedAt as any) : undefined,
+                              mode: 'merge',
+                          });
+                      }
+                  };
+
+                  return Promise.all([
+                      ...Array.from(creates).map(([itemKey, itemValue]) => {
+                          const createObj = transformOut(itemValue, transform?.save as any);
+                          return createFn!(createObj, params).then((result) =>
+                              saveResult(itemKey, createObj as object, result as any, true),
+                          );
+                      }),
+                      ...Array.from(updates).map(([itemKey, itemValue]) => {
+                          const toSave = updatePartial
+                              ? diffObjects(asType === 'first' ? valuePrevious : valuePrevious[itemKey], itemValue)
+                              : itemValue;
+                          const changed = transformOut(toSave as TGet, transform?.save as any);
+
+                          if (Object.keys(changed).length > 0) {
+                              return updateFn!(changed, params).then((result) =>
+                                  saveResult(itemKey, changed, result as any, false),
+                              );
+                          }
+                      }),
+                      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                      ...Array.from(deletes).map(([_, itemValue]) => deleteFn!(itemValue as TGet, params)),
+                  ]);
+              }
+            : undefined;
+
+    return synced<any>({
+        set,
+        get,
+        ...rest,
+    });
+}

package/src/sync-plugins/fetch.ts

@@ -1,5 +1,5 @@
 import { Synced, SyncedOptions, SyncedSetParams, isString } from '@legendapp/state';
-import { synced } from '@legendapp/state/persist';
+import { synced } from '@legendapp/state/sync';
 
 export interface SyncedFetchProps extends Omit<SyncedOptions, 'get' | 'set'> {
     get: string | RequestInfo;