@legendapp/state 3.0.0-beta.2 → 3.0.0-beta.20

package/sync-plugins/crud.mjs

@@ -1,9 +1,9 @@
-import { isPromise, applyChanges, isNullOrUndefined, setAtPath, symbolDelete, isArray, internal, getNodeValue } from '@legendapp/state';
+import { isPromise, isNullOrUndefined, applyChanges, setAtPath, symbolDelete, isArray, internal, getNodeValue } from '@legendapp/state';
 import { synced, deepEqual, internal as internal$1, diffObjects } from '@legendapp/state/sync';
 
 // src/sync-plugins/crud.ts
 var { clone } = internal;
-var { waitForSet } = internal$1;
+var { waitForSet, runWithRetry } = internal$1;
 function transformOut(data, transform) {
   return transform ? transform(clone(data)) : data;
 }
@@ -23,6 +23,35 @@ function computeLastSync(data, fieldUpdatedAt, fieldCreatedAt) {
   }
   return newLastSync;
 }
+function retrySet(params, retry, action, itemKey, itemValue, change, queuedRetries, actionFn, saveResult) {
+  if (action === "delete") {
+    if (queuedRetries.create.has(itemKey)) {
+      queuedRetries.create.delete(itemKey);
+    }
+    if (queuedRetries.update.has(itemKey)) {
+      queuedRetries.update.delete(itemKey);
+    }
+  } else {
+    if (queuedRetries.delete.has(itemKey)) {
+      queuedRetries.delete.delete(itemKey);
+    }
+  }
+  const queuedRetry = queuedRetries[action].get(itemKey);
+  if (queuedRetry) {
+    itemValue = Object.assign(queuedRetry, itemValue);
+  }
+  queuedRetries[action].set(itemKey, itemValue);
+  const paramsWithChanges = { ...params, changes: [change] };
+  return runWithRetry(
+    paramsWithChanges,
+    retry,
+    "create_" + itemKey,
+    () => actionFn(itemValue, paramsWithChanges).then((result) => {
+      queuedRetries[action].delete(itemKey);
+      return saveResult(itemKey, itemValue, result, true, change);
+    })
+  );
+}
 function syncedCrud(props) {
   const {
     get: getFn,
@@ -43,10 +72,16 @@ function syncedCrud(props) {
     changesSince,
     generateId,
     waitForSet: waitForSetParam,
+    retry,
     ...rest
   } = props;
   const fieldId = fieldIdProp || "id";
   const pendingCreates = /* @__PURE__ */ new Set();
+  const queuedRetries = {
+    create: /* @__PURE__ */ new Map(),
+    update: /* @__PURE__ */ new Map(),
+    delete: /* @__PURE__ */ new Map()
+  };
   let asType = props.as;
   if (!asType) {
     asType = getFn ? "value" : "object";
@@ -75,69 +110,75 @@ function syncedCrud(props) {
     return out;
   };
   const transformRows = (data) => {
-    return Promise.all(
+    return data.length ? Promise.all(
       data.map(
         (value) => (
           // Skip transforming any children with symbolDelete or fieldDeleted because they'll get deleted by resultsToOutType
           value[symbolDelete] || fieldDeleted && value[fieldDeleted] || fieldDeletedList && value[fieldDeletedList] ? value : transform.load(value, "get")
         )
       )
-    );
+    ) : [];
   };
   const get = getFn || listFn ? (getParams) => {
-    const { updateLastSync, lastSync, value } = getParams;
-    if (listFn) {
-      const isLastSyncMode = changesSince === "last-sync";
-      if (isLastSyncMode && lastSync) {
-        getParams.mode = modeParam || (asType === "array" ? "append" : asType === "value" ? "set" : "assign");
-      }
-      const listPromise = listFn(getParams);
-      const toOut = (transformed) => {
-        var _a;
-        if (asType === "value") {
-          return transformed.length > 0 ? transformed[0] : (_a = (isLastSyncMode && lastSync || fieldDeleted) && value) != null ? _a : null;
-        } else {
-          return resultsToOutType(transformed);
+    return runWithRetry(getParams, retry, getFn || listFn, () => {
+      const { updateLastSync, lastSync, value } = getParams;
+      if (listFn) {
+        const isLastSyncMode = changesSince === "last-sync";
+        if (isLastSyncMode && lastSync) {
+          getParams.mode = modeParam || (asType === "array" ? "append" : asType === "value" ? "set" : "assign");
         }
-      };
-      const processResults = (data) => {
-        data || (data = []);
-        if (fieldUpdatedAt) {
-          const newLastSync = computeLastSync(data, fieldUpdatedAt, fieldCreatedAt);
-          if (newLastSync && newLastSync !== lastSync) {
-            updateLastSync(newLastSync);
+        const listPromise = listFn(getParams);
+        const toOut = (transformed) => {
+          if (asType === "value") {
+            if (transformed.length > 0) {
+              return transformed[0];
+            } else {
+              return value ? void 0 : null;
+            }
+          } else {
+            return resultsToOutType(transformed);
           }
-        }
-        let transformed = data;
-        if (transform == null ? void 0 : transform.load) {
-          transformed = transformRows(data);
-        }
-        return isPromise(transformed) ? transformed.then(toOut) : toOut(transformed);
-      };
-      return isPromise(listPromise) ? listPromise.then(processResults) : processResults(listPromise);
-    } else if (getFn) {
-      const dataPromise = getFn(getParams);
-      const processData = (data) => {
-        let transformed = data;
-        if (data) {
-          const newLastSync = data[fieldUpdatedAt] || data[fieldCreatedAt];
-          if (newLastSync && newLastSync !== lastSync) {
-            updateLastSync(newLastSync);
+        };
+        const processResults = (data) => {
+          data || (data = []);
+          if (fieldUpdatedAt) {
+            const newLastSync = computeLastSync(data, fieldUpdatedAt, fieldCreatedAt);
+            if (newLastSync && newLastSync !== lastSync) {
+              updateLastSync(newLastSync);
+            }
           }
+          let transformed = data;
           if (transform == null ? void 0 : transform.load) {
-            transformed = transform.load(data, "get");
+            transformed = transformRows(data);
           }
-        }
-        return transformed;
-      };
-      return isPromise(dataPromise) ? dataPromise.then(processData) : processData(dataPromise);
-    }
+          return isPromise(transformed) ? transformed.then(toOut) : toOut(transformed);
+        };
+        return isPromise(listPromise) ? listPromise.then(processResults) : processResults(listPromise);
+      } else if (getFn) {
+        const dataPromise = getFn(getParams);
+        const processData = (data) => {
+          let transformed = data;
+          if (data) {
+            const newLastSync = data[fieldUpdatedAt] || data[fieldCreatedAt];
+            if (newLastSync && newLastSync !== lastSync) {
+              updateLastSync(newLastSync);
+            }
+            if (transform == null ? void 0 : transform.load) {
+              transformed = transform.load(data, "get");
+            }
+          }
+          return transformed;
+        };
+        return isPromise(dataPromise) ? dataPromise.then(processData) : processData(dataPromise);
+      }
+    });
   } : void 0;
   const set = createFn || updateFn || deleteFn ? async (params) => {
     const { value, changes, update, retryAsCreate, node } = params;
     const creates = /* @__PURE__ */ new Map();
     const updates = /* @__PURE__ */ new Map();
     const deletes = /* @__PURE__ */ new Set();
+    const changesById = /* @__PURE__ */ new Map();
     const getUpdateValue = (itemValue, prev) => {
       return updatePartial ? Object.assign(
         diffObjects(
@@ -146,7 +187,7 @@ function syncedCrud(props) {
           /*deep*/
           true
         ),
-        itemValue[fieldId] ? { [fieldId]: itemValue[fieldId] } : {}
+        !isNullOrUndefined(itemValue[fieldId]) ? { [fieldId]: itemValue[fieldId] } : {}
       ) : itemValue;
     };
     changes.forEach((change) => {
@@ -155,10 +196,11 @@ function syncedCrud(props) {
         if (value) {
           let id = value == null ? void 0 : value[fieldId];
           let isCreate = fieldCreatedAt ? !value[fieldCreatedAt] : !prevAtPath;
-          if (!id && generateId) {
+          if (!isNullOrUndefined(id) && generateId) {
             id = ensureId(value, fieldId, generateId);
           }
-          if (id) {
+          if (!isNullOrUndefined(id)) {
+            changesById.set(id, change);
             if (pendingCreates.has(id)) {
               isCreate = false;
             }
@@ -188,6 +230,7 @@ function syncedCrud(props) {
           }
         } else if (path.length === 0) {
           deletes.add(prevAtPath);
+          changesById.set(prevAtPath[fieldId], change);
         }
       } else {
         let itemsChanged = [];
@@ -195,7 +238,7 @@ function syncedCrud(props) {
           const changed = asMap ? Array.from(valueAtPath.entries()) : Object.entries(valueAtPath);
           for (let i = 0; i < changed.length; i++) {
             const [key, value2] = changed[i];
-            const prev = asMap ? prevAtPath.get(key) : prevAtPath[key];
+            const prev = prevAtPath ? asMap ? prevAtPath.get(key) : prevAtPath[key] : void 0;
             if (isNullOrUndefined(value2) && !isNullOrUndefined(prev)) {
               deletes.add(prev);
               return false;
@@ -212,6 +255,7 @@ function syncedCrud(props) {
           if (!itemValue) {
             if (path.length === 1 && prevAtPath) {
               deletes.add(prevAtPath);
+              changesById.set(prevAtPath[fieldId], change);
             }
           } else {
             const previous = setAtPath(
@@ -233,17 +277,18 @@ function syncedCrud(props) {
               console.error("[legend-state]: added item without an id");
             }
             if (createFn) {
-              pendingCreates.add(item[fieldId]);
-              creates.set(item[fieldId], item);
+              const id = item[fieldId];
+              changesById.set(id, change);
+              pendingCreates.add(id);
+              creates.set(id, item);
             } else {
               console.warn("[legend-state] missing create function");
             }
           } else {
             if (updateFn) {
-              updates.set(
-                item[fieldId],
-                updates.has(item[fieldId]) ? Object.assign(updates.get(item[fieldId]), item) : item
-              );
+              const id = item[fieldId];
+              changesById.set(id, change);
+              updates.set(id, updates.has(id) ? Object.assign(updates.get(id), item) : item);
             } else {
               console.warn("[legend-state] missing update function");
             }
@@ -251,93 +296,139 @@ function syncedCrud(props) {
         });
       }
     });
-    const saveResult = async (itemKey, input, data, isCreate) => {
+    const saveResult = async (itemKey, input, data, isCreate, change) => {
       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) => {
+        const currentValue = isChild ? (_a = asType === "array" && isArray(currentPeeked) ? currentPeeked.find((v) => v[fieldId] === itemKey) : void 0) != null ? _a : asType === "Map" ? currentPeeked.get(itemKey) : currentPeeked[itemKey] : currentPeeked;
+        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 !== void 0 && i !== c
             ) {
-              delete savedOut[key];
+              delete saved[key];
             }
           });
-          if (onSaved) {
-            const ret = onSaved(dataOnSaved);
-            if (ret) {
-              savedOut = ret;
+          let value2;
+          if (asType === "array") {
+            const index = currentPeeked.findIndex(
+              (cur) => cur[fieldId] === itemKey
+            );
+            if (index < 0) {
+              console.warn("[legend-state] Item saved that does not exist in array", saved);
+            } else {
+              value2 = { [index < 0 ? 0 : index]: saved };
             }
+          } else {
+            value2 = itemKey !== "undefined" && asType !== "value" ? { [itemKey]: saved } : saved;
+          }
+          if (value2 !== void 0) {
+            update({
+              value: value2,
+              mode: "merge",
+              changes: [change]
+            });
           }
-          const createdAt = fieldCreatedAt ? savedOut[fieldCreatedAt] : void 0;
-          const updatedAt = fieldUpdatedAt ? savedOut[fieldUpdatedAt] : void 0;
-          const value2 = itemKey !== "undefined" && asType !== "value" ? { [itemKey]: savedOut } : savedOut;
-          update({
-            value: value2,
-            lastSync: updatedAt || createdAt ? +new Date(updatedAt || createdAt) : void 0,
-            mode: "merge"
-          });
         }
       }
     };
     return Promise.all([
+      // Handle creates
       ...Array.from(creates).map(async ([itemKey, itemValue]) => {
         if (waitForSetParam) {
           await waitForSet(waitForSetParam, changes, itemValue, { type: "create" });
         }
         const createObj = await transformOut(itemValue, transform == null ? void 0 : transform.save);
-        return createFn(createObj, params).then((result) => {
-          return saveResult(itemKey, createObj, result, true);
-        }).finally(() => {
+        return retrySet(
+          params,
+          retry,
+          "create",
+          itemKey,
+          createObj,
+          changesById.get(itemKey),
+          queuedRetries,
+          createFn,
+          saveResult
+        ).then(() => {
           pendingCreates.delete(itemKey);
         });
       }),
+      // Handle updates
       ...Array.from(updates).map(async ([itemKey, itemValue]) => {
         if (waitForSetParam) {
           await waitForSet(waitForSetParam, changes, itemValue, { type: "update" });
         }
-        const toSave = itemValue;
-        const changed = await transformOut(toSave, transform == null ? void 0 : transform.save);
+        const changed = await transformOut(itemValue, transform == null ? void 0 : transform.save);
         if (Object.keys(changed).length > 0) {
-          return updateFn(changed, params).then(
-            (result) => result && saveResult(itemKey, changed, result, false)
+          return retrySet(
+            params,
+            retry,
+            "update",
+            itemKey,
+            changed,
+            changesById.get(itemKey),
+            queuedRetries,
+            updateFn,
+            saveResult
           );
         }
       }),
-      ...Array.from(deletes).map(async (valuePrevious) => {
-        if (valuePrevious !== symbolDelete) {
-          if (waitForSetParam) {
-            await waitForSet(waitForSetParam, changes, valuePrevious, { type: "delete" });
-          }
-          if (deleteFn) {
-            deleteFn(valuePrevious, params);
-          } else if (fieldDeleted && updateFn) {
-            const valueId = valuePrevious[fieldId];
-            if (valueId) {
-              updateFn({ ...{ [fieldId]: valueId }, [fieldDeleted]: true }, params);
-            } else {
-              console.error("[legend-state]: deleting item without an id");
-            }
-          } else {
-            console.warn("[legend-state] missing delete function");
-          }
+      // Handle deletes
+      ...Array.from(deletes).filter((val) => val !== symbolDelete).map(async (valuePrevious) => {
+        if (waitForSetParam) {
+          await waitForSet(waitForSetParam, changes, valuePrevious, { type: "delete" });
+        }
+        const itemKey = valuePrevious[fieldId];
+        if (!itemKey) {
+          console.error("[legend-state]: deleting item without an id");
+          return;
+        }
+        if (deleteFn) {
+          return retrySet(
+            params,
+            retry,
+            "delete",
+            itemKey,
+            valuePrevious,
+            changesById.get(itemKey),
+            queuedRetries,
+            deleteFn,
+            saveResult
+          );
+        }
+        if (fieldDeleted && updateFn) {
+          return retrySet(
+            params,
+            retry,
+            "delete",
+            itemKey,
+            { [fieldId]: itemKey, [fieldDeleted]: true },
+            changesById.get(itemKey),
+            queuedRetries,
+            updateFn,
+            saveResult
+          );
         }
+        console.warn("[legend-state] missing delete function");
       })
     ]);
   } : void 0;

package/sync-plugins/firebase.d.mts

@@ -1,4 +1,4 @@
-import { FieldTransforms } from '@legendapp/state/sync';
+import { FieldTransforms, SyncedErrorParams } from '@legendapp/state/sync';
 export { FieldTransforms } from '@legendapp/state/sync';
 import { CrudAsOption, SyncedCrudPropsMany, SyncedCrudPropsBase, SyncedCrudReturnType } from '@legendapp/state/sync-plugins/crud';
 import { DatabaseReference, Query } from 'firebase/database';
@@ -6,11 +6,12 @@ import { DatabaseReference, Query } from 'firebase/database';
 declare function transformObjectFields(dataIn: Record<string, any>, map: Record<string, any>): any;
 declare function invertFieldMap(obj: Record<string, any>): any;
 
-interface SyncedFirebaseProps<TRemote extends object, TLocal, TAs extends CrudAsOption = 'value'> extends Omit<SyncedCrudPropsMany<TRemote, TLocal, TAs>, 'list' | 'retry'>, SyncedCrudPropsBase<TRemote, TLocal> {
+interface SyncedFirebaseProps<TRemote extends object, TLocal, TAs extends CrudAsOption = 'value'> extends Omit<SyncedCrudPropsMany<TRemote, TLocal, TAs>, 'list' | 'retry'>, Omit<SyncedCrudPropsBase<TRemote, TLocal>, 'onError'> {
     refPath: (uid: string | undefined) => string;
     query?: (ref: DatabaseReference) => DatabaseReference | Query;
     fieldId?: string;
     fieldTransforms?: FieldTransforms<TRemote>;
+    onError?: (error: Error, params: FirebaseErrorParams) => void;
     realtime?: boolean;
     requireAuth?: boolean;
     readonly?: boolean;
@@ -22,6 +23,9 @@ interface SyncedFirebaseConfiguration {
     enabled?: boolean;
 }
 declare function configureSyncedFirebase(config: SyncedFirebaseConfiguration): void;
+interface FirebaseErrorParams extends Omit<SyncedErrorParams, 'source'> {
+    source: 'list' | 'get' | 'create' | 'update' | 'delete';
+}
 declare function syncedFirebase<TRemote extends object, TLocal = TRemote, TAs extends CrudAsOption = 'object'>(props: SyncedFirebaseProps<TRemote, TLocal, TAs>): SyncedCrudReturnType<TLocal, TAs>;
 
-export { type SyncedFirebaseProps, configureSyncedFirebase, invertFieldMap, syncedFirebase, transformObjectFields };
+export { type FirebaseErrorParams, type SyncedFirebaseProps, configureSyncedFirebase, invertFieldMap, syncedFirebase, transformObjectFields };

package/sync-plugins/firebase.d.ts

@@ -1,4 +1,4 @@
-import { FieldTransforms } from '@legendapp/state/sync';
+import { FieldTransforms, SyncedErrorParams } from '@legendapp/state/sync';
 export { FieldTransforms } from '@legendapp/state/sync';
 import { CrudAsOption, SyncedCrudPropsMany, SyncedCrudPropsBase, SyncedCrudReturnType } from '@legendapp/state/sync-plugins/crud';
 import { DatabaseReference, Query } from 'firebase/database';
@@ -6,11 +6,12 @@ import { DatabaseReference, Query } from 'firebase/database';
 declare function transformObjectFields(dataIn: Record<string, any>, map: Record<string, any>): any;
 declare function invertFieldMap(obj: Record<string, any>): any;
 
-interface SyncedFirebaseProps<TRemote extends object, TLocal, TAs extends CrudAsOption = 'value'> extends Omit<SyncedCrudPropsMany<TRemote, TLocal, TAs>, 'list' | 'retry'>, SyncedCrudPropsBase<TRemote, TLocal> {
+interface SyncedFirebaseProps<TRemote extends object, TLocal, TAs extends CrudAsOption = 'value'> extends Omit<SyncedCrudPropsMany<TRemote, TLocal, TAs>, 'list' | 'retry'>, Omit<SyncedCrudPropsBase<TRemote, TLocal>, 'onError'> {
     refPath: (uid: string | undefined) => string;
     query?: (ref: DatabaseReference) => DatabaseReference | Query;
     fieldId?: string;
     fieldTransforms?: FieldTransforms<TRemote>;
+    onError?: (error: Error, params: FirebaseErrorParams) => void;
     realtime?: boolean;
     requireAuth?: boolean;
     readonly?: boolean;
@@ -22,6 +23,9 @@ interface SyncedFirebaseConfiguration {
     enabled?: boolean;
 }
 declare function configureSyncedFirebase(config: SyncedFirebaseConfiguration): void;
+interface FirebaseErrorParams extends Omit<SyncedErrorParams, 'source'> {
+    source: 'list' | 'get' | 'create' | 'update' | 'delete';
+}
 declare function syncedFirebase<TRemote extends object, TLocal = TRemote, TAs extends CrudAsOption = 'object'>(props: SyncedFirebaseProps<TRemote, TLocal, TAs>): SyncedCrudReturnType<TLocal, TAs>;
 
-export { type SyncedFirebaseProps, configureSyncedFirebase, invertFieldMap, syncedFirebase, transformObjectFields };
+export { type FirebaseErrorParams, type SyncedFirebaseProps, configureSyncedFirebase, invertFieldMap, syncedFirebase, transformObjectFields };

package/sync-plugins/firebase.js

@@ -185,7 +185,8 @@ function syncedFirebase(props) {
     }
     return ref;
   };
-  const list = async ({ lastSync, onError }) => {
+  const list = async (getParams) => {
+    const { lastSync, onError } = getParams;
     const ref = computeRef(lastSync);
     return new Promise((resolve) => {
       fns.once(
@@ -204,7 +205,7 @@ function syncedFirebase(props) {
           didList = true;
           resolve(values);
         },
-        onError
+        (error) => onError(error, { source: "list", type: "get", retry: getParams })
       );
     });
   };
@@ -354,6 +355,7 @@ function syncedFirebase(props) {
   }
   return crud.syncedCrud({
     ...rest,
+    // Workaround for type errors
     list,
     subscribe,
     create,

package/sync-plugins/firebase.mjs

@@ -183,7 +183,8 @@ function syncedFirebase(props) {
     }
     return ref;
   };
-  const list = async ({ lastSync, onError }) => {
+  const list = async (getParams) => {
+    const { lastSync, onError } = getParams;
     const ref = computeRef(lastSync);
     return new Promise((resolve) => {
       fns.once(
@@ -202,7 +203,7 @@ function syncedFirebase(props) {
           didList = true;
           resolve(values);
         },
-        onError
+        (error) => onError(error, { source: "list", type: "get", retry: getParams })
       );
     });
   };
@@ -352,6 +353,7 @@ function syncedFirebase(props) {
   }
   return syncedCrud({
     ...rest,
+    // Workaround for type errors
     list,
     subscribe,
     create,

package/sync-plugins/keel.d.mts

@@ -1,5 +1,5 @@
-import { SyncedGetSetSubscribeBaseParams, OnErrorRetryParams, SyncedSetParams } from '@legendapp/state/sync';
-import { SyncedCrudPropsBase, SyncedCrudReturnType, CrudAsOption, SyncedCrudPropsSingle, CrudResult, SyncedCrudPropsMany } from '@legendapp/state/sync-plugins/crud';
+import { SyncedGetSetSubscribeBaseParams } from '@legendapp/state/sync';
+import { CrudErrorParams, SyncedCrudPropsBase, SyncedCrudReturnType, CrudAsOption, SyncedCrudPropsSingle, CrudResult, SyncedCrudPropsMany } from '@legendapp/state/sync-plugins/crud';
 
 interface KeelObjectBase {
     id: string;
@@ -13,6 +13,7 @@ type APIError = {
     type: string;
     message: string;
     requestId?: string;
+    error?: unknown;
 };
 type APIResult<T> = Result<T, APIError>;
 type Data<T> = {
@@ -24,7 +25,6 @@ type Err<U> = {
     error: U;
 };
 type Result<T, U> = NonNullable<Data<T> | Err<U>>;
-declare function generateKeelId(): string;
 interface KeelGetParams {
 }
 interface KeelListParams<Where = {}> {
@@ -62,7 +62,7 @@ interface SyncedKeelPropsManyWhere<TRemote extends {
 }, TLocal, AOption extends CrudAsOption, Where extends Record<string, any>> extends SyncedKeelPropsManyBase<TRemote, TLocal, AOption> {
     list?: (params: KeelListParams<NoInfer<Where>>) => Promise<CrudResult<APIResult<{
         results: TRemote[];
-        pageInfo: any;
+        pageInfo?: any;
     }>>>;
     where?: Where | (() => Where);
 }
@@ -71,7 +71,7 @@ interface SyncedKeelPropsManyNoWhere<TRemote extends {
 }, TLocal, AOption extends CrudAsOption> extends SyncedKeelPropsManyBase<TRemote, TLocal, AOption> {
     list?: (params: KeelListParams<{}>) => Promise<CrudResult<APIResult<{
         results: TRemote[];
-        pageInfo: any;
+        pageInfo?: any;
     }>>>;
     where?: never | {};
 }
@@ -88,12 +88,8 @@ interface SyncedKeelPropsSingle<TRemote extends {
     list?: never;
     as?: never;
 }
-interface ErrorDetails {
-    type: 'create' | 'update' | 'delete';
-    params: SyncedSetParams<any>;
-    input: any;
+interface KeelErrorParams extends CrudErrorParams {
     action: string;
-    error: APIResult<any>['error'];
 }
 interface SyncedKeelPropsBase<TRemote extends {
     id: string;
@@ -102,7 +98,7 @@ interface SyncedKeelPropsBase<TRemote extends {
     create?: (i: NoInfer<Partial<TRemote>>) => Promise<APIResult<NoInfer<TRemote>>>;
     update?: (params: {
         where: any;
-        values?: Partial<TRemote>;
+        values?: Partial<NoInfer<TRemote>>;
     }) => Promise<APIResult<TRemote>>;
     delete?: (params: {
         id: string;
@@ -113,7 +109,7 @@ interface SyncedKeelPropsBase<TRemote extends {
     };
     refreshAuth?: () => void | Promise<void>;
     requireAuth?: boolean;
-    onError?: (error: Error, retryParams: OnErrorRetryParams, details: ErrorDetails) => void;
+    onError?: (error: Error, params: KeelErrorParams) => void;
 }
 declare function syncedKeel<TRemote extends {
     id: string;
@@ -122,4 +118,4 @@ declare function syncedKeel<TRemote extends {
     id: string;
 }, TLocal = TRemote, TOption extends CrudAsOption = 'object', Where extends Record<string, any> = {}>(props: SyncedKeelPropsBase<TRemote, TLocal> & SyncedKeelPropsMany<TRemote, TLocal, TOption, Where>): SyncedCrudReturnType<TLocal, Exclude<TOption, 'value'>>;
 
-export { type KeelClient, type KeelGetParams, type KeelKey, KeelKeys, type KeelListParams, type KeelObjectBase, type KeelRealtimePlugin, type OmitKeelBuiltins, type SyncedKeelPropsBase, generateKeelId, syncedKeel };
+export { type KeelClient, type KeelErrorParams, type KeelGetParams, type KeelKey, KeelKeys, type KeelListParams, type KeelObjectBase, type KeelRealtimePlugin, type OmitKeelBuiltins, type SyncedKeelPropsBase, syncedKeel };