@legendapp/state 3.0.0-alpha.3 → 3.0.0-alpha.30

package/sync-plugins/firebase.mjs

@@ -0,0 +1,368 @@
+import { observable, symbolDelete, isString, isArray, isObject, computeSelector, isFunction, isNullOrUndefined, isPromise, isNumber, when } from '@legendapp/state';
+import { syncedCrud } from '@legendapp/state/sync-plugins/crud';
+import { getAuth } from 'firebase/auth';
+import { ref, getDatabase, query, orderByChild, startAt, update, onValue, onChildAdded, onChildChanged, onChildRemoved, serverTimestamp, remove, push } from 'firebase/database';
+
+// src/sync-plugins/firebase.ts
+var validateMap;
+function transformObjectFields(dataIn, map) {
+  if (process.env.NODE_ENV === "development") {
+    validateMap(map);
+  }
+  let ret = dataIn;
+  if (dataIn) {
+    if (dataIn === symbolDelete)
+      return dataIn;
+    if (isString(dataIn)) {
+      return map[dataIn];
+    }
+    ret = {};
+    const dict = Object.keys(map).length === 1 && map["_dict"];
+    for (const key in dataIn) {
+      let v = dataIn[key];
+      if (dict) {
+        ret[key] = transformObjectFields(v, dict);
+      } else {
+        const mapped = map[key];
+        if (mapped === void 0) {
+          if (key !== "@") {
+            ret[key] = v;
+            if (process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") {
+              console.error("A fatal field transformation error has occurred", key, dataIn, map);
+            }
+          }
+        } else if (mapped !== null) {
+          if (v !== void 0 && v !== null) {
+            if (map[key + "_val"]) {
+              const mapChild = map[key + "_val"];
+              if (isArray(v)) {
+                v = v.map((vChild) => mapChild[vChild]);
+              } else {
+                v = mapChild[v];
+              }
+            } else if (map[key + "_arr"] && isArray(v)) {
+              const mapChild = map[key + "_arr"];
+              v = v.map((vChild) => transformObjectFields(vChild, mapChild));
+            } else if (isObject(v)) {
+              if (map[key + "_obj"]) {
+                v = transformObjectFields(v, map[key + "_obj"]);
+              } else if (map[key + "_dict"]) {
+                const mapChild = map[key + "_dict"];
+                const out = {};
+                for (const keyChild in v) {
+                  out[keyChild] = transformObjectFields(v[keyChild], mapChild);
+                }
+                v = out;
+              }
+            }
+          }
+          ret[mapped] = v;
+        }
+      }
+    }
+  }
+  return ret;
+}
+var invertedMaps = /* @__PURE__ */ new WeakMap();
+function invertFieldMap(obj) {
+  const existing = invertedMaps.get(obj);
+  if (existing)
+    return existing;
+  const target = {};
+  for (const key in obj) {
+    const val = obj[key];
+    if (key === "_dict") {
+      target[key] = invertFieldMap(val);
+    } else if (key.endsWith("_obj") || key.endsWith("_dict") || key.endsWith("_arr") || key.endsWith("_val")) {
+      const keyMapped = obj[key.replace(/_obj|_dict|_arr|_val$/, "")];
+      const suffix = key.match(/_obj|_dict|_arr|_val$/)[0];
+      target[keyMapped + suffix] = invertFieldMap(val);
+    } else if (typeof val === "string") {
+      target[val] = key;
+    }
+  }
+  invertedMaps.set(obj, target);
+  return target;
+}
+if (process.env.NODE_ENV === "development") {
+  validateMap = function(record) {
+    const values = Object.values(record).filter((value) => {
+      if (isObject(value)) {
+        validateMap(value);
+      } else {
+        return isString(value);
+      }
+    });
+    const uniques = Array.from(new Set(values));
+    if (values.length !== uniques.length) {
+      console.error("Field transform map has duplicate values", record, values.length, uniques.length);
+    }
+    return record;
+  };
+}
+
+// src/sync-plugins/firebase.ts
+var isEnabled$ = observable(true);
+var firebaseConfig = {};
+function configureSyncedFirebase(config) {
+  const { enabled, ...rest } = config;
+  Object.assign(firebaseConfig, rest);
+  if (enabled !== void 0) {
+    isEnabled$.set(enabled);
+  }
+}
+function joinPaths(str1, str2) {
+  return str2 ? [str1, str2].join("/").replace(/\/\//g, "/") : str1;
+}
+var fns = {
+  isInitialized: () => {
+    try {
+      return !!getAuth().app;
+    } catch (e) {
+      return false;
+    }
+  },
+  getCurrentUser: () => {
+    var _a;
+    return (_a = getAuth().currentUser) == null ? void 0 : _a.uid;
+  },
+  ref: (path) => ref(getDatabase(), path),
+  orderByChild: (ref, child, start) => query(ref, orderByChild(child), startAt(start)),
+  update: (ref, object) => update(ref, object),
+  once: (ref, callback, callbackError) => {
+    let unsubscribe;
+    const cb = (snap) => {
+      if (unsubscribe) {
+        unsubscribe();
+        unsubscribe = void 0;
+      }
+      callback(snap);
+    };
+    unsubscribe = onValue(ref, cb, callbackError);
+    return unsubscribe;
+  },
+  onChildAdded,
+  onChildChanged,
+  onChildRemoved,
+  onValue,
+  serverTimestamp,
+  remove: remove,
+  onAuthStateChanged: (cb) => getAuth().onAuthStateChanged(cb),
+  generateId: () => push(ref(getDatabase())).key
+};
+function syncedFirebase(props) {
+  props = { ...firebaseConfig, ...props };
+  const saving$ = observable({});
+  const pendingOutgoing$ = observable({});
+  const pendingIncoming$ = observable({});
+  let didList = false;
+  const {
+    refPath,
+    query,
+    fieldId,
+    realtime,
+    requireAuth,
+    readonly,
+    transform: transformProp,
+    fieldTransforms,
+    waitFor,
+    waitForSet,
+    ...rest
+  } = props;
+  const { fieldCreatedAt, changesSince } = props;
+  const asType = props.as || "value";
+  const fieldUpdatedAt = props.fieldUpdatedAt || "@";
+  const computeRef = (lastSync) => {
+    const pathFirebase = refPath(fns.getCurrentUser());
+    let ref = fns.ref(pathFirebase);
+    if (query) {
+      ref = query(ref);
+    }
+    if (changesSince === "last-sync" && lastSync && fieldUpdatedAt && isNumber(lastSync)) {
+      ref = fns.orderByChild(ref, fieldUpdatedAt, lastSync + 1);
+    }
+    return ref;
+  };
+  const list = async ({ lastSync, onError }) => {
+    const ref = computeRef(lastSync);
+    return new Promise((resolve) => {
+      fns.once(
+        ref,
+        async (snap) => {
+          const val = snap.val();
+          let values = [];
+          if (!isNullOrUndefined(val)) {
+            values = asType === "value" ? [val] : Object.entries(val).map(([key, value]) => {
+              if (fieldId && !value[fieldId]) {
+                value[fieldId] = key;
+              }
+              return value;
+            });
+          }
+          didList = true;
+          resolve(values);
+        },
+        onError
+      );
+    });
+  };
+  const subscribe = realtime ? ({ lastSync, update: update2, onError }) => {
+    const ref = computeRef(lastSync);
+    let unsubscribes;
+    if (asType === "value") {
+      const onValue2 = (snap) => {
+        if (!didList)
+          return;
+        const val = snap.val();
+        if (saving$[""].get()) {
+          pendingIncoming$[""].set(val);
+        } else {
+          update2({
+            value: [val],
+            mode: "set"
+          });
+        }
+      };
+      unsubscribes = [fns.onValue(ref, onValue2, onError)];
+    } else {
+      const onChildChange = (snap) => {
+        if (!didList)
+          return;
+        const key = snap.key;
+        const val = snap.val();
+        if (fieldId && !val[fieldId]) {
+          val[fieldId] = key;
+        }
+        if (saving$[key].get()) {
+          pendingIncoming$[key].set(val);
+        } else {
+          update2({
+            value: [val],
+            mode: "assign"
+          });
+        }
+      };
+      const onChildDelete = (snap) => {
+        if (!didList)
+          return;
+        const key = snap.key;
+        const val = snap.val();
+        if (fieldId && !val[fieldId]) {
+          val[fieldId] = key;
+        }
+        val[symbolDelete] = true;
+        update2({
+          value: [val],
+          mode: "assign"
+        });
+      };
+      unsubscribes = [
+        fns.onChildAdded(ref, onChildChange, onError),
+        fns.onChildChanged(ref, onChildChange, onError),
+        fns.onChildRemoved(ref, onChildDelete, onError)
+      ];
+    }
+    return () => {
+      unsubscribes.forEach((fn) => fn());
+    };
+  } : void 0;
+  const addUpdatedAt = (input) => {
+    if (fieldUpdatedAt) {
+      input[fieldUpdatedAt] = serverTimestamp();
+    }
+  };
+  const addCreatedAt = (input) => {
+    if (fieldCreatedAt && !input[fieldCreatedAt]) {
+      input[fieldCreatedAt] = serverTimestamp();
+    }
+    return addUpdatedAt(input);
+  };
+  const upsert = async (input) => {
+    const id = fieldId ? input[fieldId] : "";
+    if (saving$[id].get()) {
+      pendingOutgoing$[id].set(input);
+    } else {
+      saving$[id].set(true);
+      const path = joinPaths(refPath(fns.getCurrentUser()), fieldId ? id : "");
+      await fns.update(fns.ref(path), input);
+      saving$[id].set(false);
+      flushAfterSave();
+    }
+    return when(
+      () => !pendingOutgoing$[id].get(),
+      () => {
+        const value = pendingIncoming$[id].get();
+        if (value) {
+          pendingIncoming$[id].delete();
+          return value;
+        }
+      }
+    );
+  };
+  const flushAfterSave = () => {
+    const outgoing = pendingOutgoing$.get();
+    Object.values(outgoing).forEach((value) => {
+      upsert(value);
+    });
+    pendingOutgoing$.set({});
+  };
+  const create = readonly ? void 0 : (input) => {
+    addCreatedAt(input);
+    return upsert(input);
+  };
+  const update = readonly ? void 0 : (input) => {
+    addUpdatedAt(input);
+    return upsert(input);
+  };
+  const deleteFn = readonly ? void 0 : (input) => {
+    const path = joinPaths(
+      refPath(fns.getCurrentUser()),
+      fieldId && asType !== "value" ? input[fieldId] : ""
+    );
+    return fns.remove(fns.ref(path));
+  };
+  let isAuthedIfRequired$;
+  if (requireAuth) {
+    if (fns.isInitialized()) {
+      isAuthedIfRequired$ = observable(false);
+      fns.onAuthStateChanged((user) => {
+        isAuthedIfRequired$.set(!!user);
+      });
+    }
+  }
+  let transform = transformProp;
+  if (fieldTransforms) {
+    const inverted = invertFieldMap(fieldTransforms);
+    transform = {
+      load(value, method) {
+        const fieldTransformed = transformObjectFields(value, inverted);
+        return (transformProp == null ? void 0 : transformProp.load) ? transformProp.load(fieldTransformed, method) : fieldTransformed;
+      },
+      save(value) {
+        const transformed = (transformProp == null ? void 0 : transformProp.save) ? transformProp.save(value) : value;
+        if (isPromise(transformed)) {
+          return transformed.then((transformedValue) => {
+            return transformObjectFields(transformedValue, fieldTransforms);
+          });
+        } else {
+          return transformObjectFields(transformed, fieldTransforms);
+        }
+      }
+    };
+  }
+  return syncedCrud({
+    ...rest,
+    list,
+    subscribe,
+    create,
+    update,
+    delete: deleteFn,
+    waitFor: () => isEnabled$.get() && (isAuthedIfRequired$ ? isAuthedIfRequired$.get() : true) && (waitFor ? computeSelector(waitFor) : true),
+    waitForSet: (params) => isEnabled$.get() && (isAuthedIfRequired$ ? isAuthedIfRequired$.get() : true) && (waitForSet ? isFunction(waitForSet) ? waitForSet(params) : waitForSet : true),
+    generateId: fns.generateId,
+    transform,
+    as: asType
+  });
+}
+
+export { configureSyncedFirebase, invertFieldMap, syncedFirebase, transformObjectFields };

package/sync-plugins/keel.d.mts

@@ -1,4 +1,4 @@
-import { SyncedOptions } from '@legendapp/state/sync';
+import { SyncedGetSetSubscribeBaseParams, SyncedOptions, SyncedSetParams } from '@legendapp/state/sync';
 import { SyncedCrudPropsBase, CrudAsOption, SyncedCrudReturnType, SyncedCrudPropsSingle, CrudResult, SyncedCrudPropsMany } from '@legendapp/state/sync-plugins/crud';
 
 interface KeelObjectBase {
@@ -39,14 +39,14 @@ interface KeelListParams<Where = {}> {
     before?: string;
 }
 interface KeelRealtimePlugin {
-    subscribe: (realtimeKey: string, refresh: () => void) => void;
+    subscribe: (realtimeKey: string, params: SyncedGetSetSubscribeBaseParams) => void;
     setLatestChange: (realtimeKey: string, time: Date) => void;
 }
 interface SyncedKeelConfiguration extends Omit<SyncedCrudPropsBase<any>, keyof SyncedOptions | 'create' | 'update' | 'delete' | 'onSaved' | 'updatePartial' | 'fieldCreatedAt' | 'fieldUpdatedAt' | 'generateId'> {
     client: {
         auth: {
-            refresh: () => Promise<boolean>;
-            isAuthenticated: () => Promise<boolean>;
+            refresh: () => Promise<APIResult<boolean>>;
+            isAuthenticated: () => Promise<APIResult<boolean>>;
         };
         api: {
             queries: Record<string, (i: any) => Promise<any>>;
@@ -55,20 +55,33 @@ interface SyncedKeelConfiguration extends Omit<SyncedCrudPropsBase<any>, keyof S
     realtimePlugin?: KeelRealtimePlugin;
     as?: Exclude<CrudAsOption, 'value'>;
     enabled?: boolean;
-    onError?: (params: APIResult<any>['error']) => void;
+    onError?: (params: {
+        type: 'create' | 'update' | 'delete';
+        params: SyncedSetParams<any>;
+        input: any;
+        action: string;
+        error: APIResult<any>['error'];
+    }) => void;
+    refreshAuth?: () => void | Promise<void>;
 }
-interface SyncedKeelPropsManyBase<TRemote, TLocal, AOption extends CrudAsOption> extends Omit<SyncedCrudPropsMany<TRemote, TLocal, AOption>, 'list'> {
+interface SyncedKeelPropsManyBase<TRemote extends {
+    id: string;
+}, TLocal, AOption extends CrudAsOption> extends Omit<SyncedCrudPropsMany<TRemote, TLocal, AOption>, 'list'> {
     first?: number;
     get?: never;
 }
-interface SyncedKeelPropsManyWhere<TRemote, TLocal, AOption extends CrudAsOption, Where extends Record<string, any>> extends SyncedKeelPropsManyBase<TRemote, TLocal, AOption> {
+interface SyncedKeelPropsManyWhere<TRemote extends {
+    id: string;
+}, 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;
     }>>>;
     where?: Where | (() => Where);
 }
-interface SyncedKeelPropsManyNoWhere<TRemote, TLocal, AOption extends CrudAsOption> extends SyncedKeelPropsManyBase<TRemote, TLocal, AOption> {
+interface SyncedKeelPropsManyNoWhere<TRemote extends {
+    id: string;
+}, TLocal, AOption extends CrudAsOption> extends SyncedKeelPropsManyBase<TRemote, TLocal, AOption> {
     list?: (params: KeelListParams<{}>) => Promise<CrudResult<APIResult<{
         results: TRemote[];
         pageInfo: any;
@@ -76,8 +89,12 @@ interface SyncedKeelPropsManyNoWhere<TRemote, TLocal, AOption extends CrudAsOpti
     where?: never | {};
 }
 type HasAnyKeys<T> = keyof T extends never ? false : true;
-type SyncedKeelPropsMany<TRemote, TLocal, AOption extends CrudAsOption, Where extends Record<string, any>> = HasAnyKeys<Where> extends true ? SyncedKeelPropsManyWhere<TRemote, TLocal, AOption, Where> : SyncedKeelPropsManyNoWhere<TRemote, TLocal, AOption>;
-interface SyncedKeelPropsSingle<TRemote, TLocal> extends Omit<SyncedCrudPropsSingle<TRemote, TLocal>, 'get'> {
+type SyncedKeelPropsMany<TRemote extends {
+    id: string;
+}, TLocal, AOption extends CrudAsOption, Where extends Record<string, any>> = HasAnyKeys<Where> extends true ? SyncedKeelPropsManyWhere<TRemote, TLocal, AOption, Where> : SyncedKeelPropsManyNoWhere<TRemote, TLocal, AOption>;
+interface SyncedKeelPropsSingle<TRemote extends {
+    id: string;
+}, TLocal> extends Omit<SyncedCrudPropsSingle<TRemote, TLocal>, 'get'> {
     get?: (params: KeelGetParams) => Promise<APIResult<TRemote>>;
     first?: never;
     where?: never;

package/sync-plugins/keel.d.ts

@@ -1,4 +1,4 @@
-import { SyncedOptions } from '@legendapp/state/sync';
+import { SyncedGetSetSubscribeBaseParams, SyncedOptions, SyncedSetParams } from '@legendapp/state/sync';
 import { SyncedCrudPropsBase, CrudAsOption, SyncedCrudReturnType, SyncedCrudPropsSingle, CrudResult, SyncedCrudPropsMany } from '@legendapp/state/sync-plugins/crud';
 
 interface KeelObjectBase {
@@ -39,14 +39,14 @@ interface KeelListParams<Where = {}> {
     before?: string;
 }
 interface KeelRealtimePlugin {
-    subscribe: (realtimeKey: string, refresh: () => void) => void;
+    subscribe: (realtimeKey: string, params: SyncedGetSetSubscribeBaseParams) => void;
     setLatestChange: (realtimeKey: string, time: Date) => void;
 }
 interface SyncedKeelConfiguration extends Omit<SyncedCrudPropsBase<any>, keyof SyncedOptions | 'create' | 'update' | 'delete' | 'onSaved' | 'updatePartial' | 'fieldCreatedAt' | 'fieldUpdatedAt' | 'generateId'> {
     client: {
         auth: {
-            refresh: () => Promise<boolean>;
-            isAuthenticated: () => Promise<boolean>;
+            refresh: () => Promise<APIResult<boolean>>;
+            isAuthenticated: () => Promise<APIResult<boolean>>;
         };
         api: {
             queries: Record<string, (i: any) => Promise<any>>;
@@ -55,20 +55,33 @@ interface SyncedKeelConfiguration extends Omit<SyncedCrudPropsBase<any>, keyof S
     realtimePlugin?: KeelRealtimePlugin;
     as?: Exclude<CrudAsOption, 'value'>;
     enabled?: boolean;
-    onError?: (params: APIResult<any>['error']) => void;
+    onError?: (params: {
+        type: 'create' | 'update' | 'delete';
+        params: SyncedSetParams<any>;
+        input: any;
+        action: string;
+        error: APIResult<any>['error'];
+    }) => void;
+    refreshAuth?: () => void | Promise<void>;
 }
-interface SyncedKeelPropsManyBase<TRemote, TLocal, AOption extends CrudAsOption> extends Omit<SyncedCrudPropsMany<TRemote, TLocal, AOption>, 'list'> {
+interface SyncedKeelPropsManyBase<TRemote extends {
+    id: string;
+}, TLocal, AOption extends CrudAsOption> extends Omit<SyncedCrudPropsMany<TRemote, TLocal, AOption>, 'list'> {
     first?: number;
     get?: never;
 }
-interface SyncedKeelPropsManyWhere<TRemote, TLocal, AOption extends CrudAsOption, Where extends Record<string, any>> extends SyncedKeelPropsManyBase<TRemote, TLocal, AOption> {
+interface SyncedKeelPropsManyWhere<TRemote extends {
+    id: string;
+}, 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;
     }>>>;
     where?: Where | (() => Where);
 }
-interface SyncedKeelPropsManyNoWhere<TRemote, TLocal, AOption extends CrudAsOption> extends SyncedKeelPropsManyBase<TRemote, TLocal, AOption> {
+interface SyncedKeelPropsManyNoWhere<TRemote extends {
+    id: string;
+}, TLocal, AOption extends CrudAsOption> extends SyncedKeelPropsManyBase<TRemote, TLocal, AOption> {
     list?: (params: KeelListParams<{}>) => Promise<CrudResult<APIResult<{
         results: TRemote[];
         pageInfo: any;
@@ -76,8 +89,12 @@ interface SyncedKeelPropsManyNoWhere<TRemote, TLocal, AOption extends CrudAsOpti
     where?: never | {};
 }
 type HasAnyKeys<T> = keyof T extends never ? false : true;
-type SyncedKeelPropsMany<TRemote, TLocal, AOption extends CrudAsOption, Where extends Record<string, any>> = HasAnyKeys<Where> extends true ? SyncedKeelPropsManyWhere<TRemote, TLocal, AOption, Where> : SyncedKeelPropsManyNoWhere<TRemote, TLocal, AOption>;
-interface SyncedKeelPropsSingle<TRemote, TLocal> extends Omit<SyncedCrudPropsSingle<TRemote, TLocal>, 'get'> {
+type SyncedKeelPropsMany<TRemote extends {
+    id: string;
+}, TLocal, AOption extends CrudAsOption, Where extends Record<string, any>> = HasAnyKeys<Where> extends true ? SyncedKeelPropsManyWhere<TRemote, TLocal, AOption, Where> : SyncedKeelPropsManyNoWhere<TRemote, TLocal, AOption>;
+interface SyncedKeelPropsSingle<TRemote extends {
+    id: string;
+}, TLocal> extends Omit<SyncedCrudPropsSingle<TRemote, TLocal>, 'get'> {
     get?: (params: KeelGetParams) => Promise<APIResult<TRemote>>;
     first?: never;
     where?: never;

package/sync-plugins/keel.js

@@ -20,6 +20,9 @@ var modifiedClients = /* @__PURE__ */ new WeakSet();
 var isEnabled$ = state.observable(true);
 async function ensureAuthToken() {
   await state.when(isEnabled$.get());
+  if (keelConfig.refreshAuth) {
+    await keelConfig.refreshAuth();
+  }
   let isAuthed = await keelConfig.client.auth.isAuthenticated();
   if (!isAuthed) {
     isAuthed = await keelConfig.client.auth.refresh();
@@ -65,9 +68,9 @@ function configureSyncedKeel(config) {
           const oldFn = queries[key];
           queries[key] = (i) => {
             const realtimeKey = [key, ...Object.values(i.where || {})].filter((value) => value && typeof value !== "object").join("/");
-            const subscribe = ({ refresh }) => {
+            const subscribe = (params) => {
               if (realtimeKey) {
-                return realtimePlugin.subscribe(realtimeKey, refresh);
+                return realtimePlugin.subscribe(realtimeKey, params);
               }
             };
             return oldFn(i).then((ret) => {
@@ -128,7 +131,9 @@ function syncedKeel(props) {
     first,
     where: whereParam,
     waitFor,
+    waitForSet,
     fieldDeleted,
+    mode,
     ...rest
   } = props;
   const { changesSince } = props;
@@ -137,8 +142,15 @@ function syncedKeel(props) {
   const subscribeFnKey$ = state.observable("");
   const fieldCreatedAt = "createdAt";
   const fieldUpdatedAt = "updatedAt";
+  const setupSubscribe = (doSubscribe, subscribeKey, lastSync) => {
+    subscribeFn = doSubscribe;
+    subscribeFnKey$.set(subscribeKey);
+    if (realtimePlugin && lastSync) {
+      realtimePlugin.setLatestChange(subscribeKey, new Date(lastSync));
+    }
+  };
   const list = listParam ? async (listParams) => {
-    const { lastSync, refresh } = listParams;
+    const { lastSync } = listParams;
     const queryBySync = !!lastSync && changesSince === "last-sync";
     const where = Object.assign(
       queryBySync ? { updatedAt: { after: new Date(lastSync + 1) } } : {},
@@ -147,8 +159,7 @@ function syncedKeel(props) {
     const params = { where, first };
     const { results, subscribe: subscribe2, subscribeKey } = await getAllPages(listParam, params);
     if (subscribe2) {
-      subscribeFn = () => subscribe2({ refresh });
-      subscribeFnKey$.set(subscribeKey);
+      setupSubscribe(() => subscribe2(listParams), subscribeKey, lastSync);
     }
     return results;
   } : void 0;
@@ -156,8 +167,7 @@ function syncedKeel(props) {
     const { refresh } = getParams;
     const { data, error, subscribe: subscribe2, subscribeKey } = await getParam({ refresh });
     if (subscribe2) {
-      subscribeFn = () => subscribe2({ refresh });
-      subscribeFnKey$.set(subscribeKey);
+      setupSubscribe(() => subscribe2(getParams), subscribeKey);
     }
     if (error) {
       throw new Error(error.message);
@@ -176,32 +186,40 @@ function syncedKeel(props) {
       }
     }
   };
-  const handleSetError = async (error, params, isCreate) => {
+  const handleSetError = async (error, params, input, fn, from) => {
     var _a, _b, _c;
-    const { retryNum, cancelRetry, update: update2 } = params;
-    if (isCreate && ((_a = error.message) == null ? void 0 : _a.includes("for the unique")) && ((_b = error.message) == null ? void 0 : _b.includes("must be unique"))) {
+    const { retryNum, update: update2 } = params;
+    if (from === "create" && ((_a = error.message) == null ? void 0 : _a.includes("for the unique")) && ((_b = error.message) == null ? void 0 : _b.includes("must be unique"))) {
       if (__DEV__) {
         console.log("Creating duplicate data already saved, just ignore.");
       }
+      params.cancelRetry = true;
       update2({
         value: {},
         mode: "assign"
       });
+    } else if (from === "delete") {
+      if (error.message === "record not found") {
+        if (__DEV__) {
+          console.log("Deleting non-existing data, just ignore.");
+        }
+        params.cancelRetry = true;
+      }
     } else if (error.type === "bad_request") {
-      (_c = keelConfig.onError) == null ? void 0 : _c.call(keelConfig, error);
+      (_c = keelConfig.onError) == null ? void 0 : _c.call(keelConfig, { error, params, input, type: from, action: fn.name || fn.toString() });
       if (retryNum > 4) {
-        cancelRetry();
+        params.cancelRetry = true;
       }
-      throw new Error(error.message);
+      throw new Error(error.message, { cause: { input } });
     } else {
       await handleApiError(error);
-      throw new Error(error.message);
+      throw new Error(error.message, { cause: { input } });
     }
   };
   const create = createParam ? async (input, params) => {
     const { data, error } = await createParam(convertObjectToCreate(input));
     if (error) {
-      handleSetError(error, params, true);
+      await handleSetError(error, params, input, createParam, "create");
     }
     return data;
   } : void 0;
@@ -214,15 +232,15 @@ function syncedKeel(props) {
     if (!state.isEmpty(values)) {
       const { data, error } = await updateParam({ where: { id }, values });
       if (error) {
-        handleSetError(error, params, false);
+        await handleSetError(error, params, input, updateParam, "update");
       }
       return data;
     }
   } : void 0;
-  const deleteFn = deleteParam ? async ({ id }, params) => {
-    const { data, error } = await deleteParam({ id });
+  const deleteFn = deleteParam ? async (value, params) => {
+    const { data, error } = await deleteParam({ id: value.id });
     if (error) {
-      handleSetError(error, params, false);
+      await handleSetError(error, params, value, deleteParam, "delete");
     }
     return data;
   } : void 0;
@@ -238,16 +256,17 @@ function syncedKeel(props) {
   return crud.syncedCrud({
     ...rest,
     as: asType,
+    mode: mode || "merge",
     list,
     create,
     update,
     delete: deleteFn,
     waitFor: () => isEnabled$.get() && (waitFor ? state.computeSelector(waitFor) : true),
+    waitForSet: (params) => isEnabled$.get() && (waitForSet ? state.isFunction(waitForSet) ? waitForSet(params) : waitForSet : true),
     onSaved,
-    onSavedUpdate: "createdUpdatedAt",
     fieldCreatedAt,
     fieldUpdatedAt,
-    fieldDeleted: fieldDeleted || "deleted",
+    fieldDeleted,
     changesSince,
     updatePartial: true,
     subscribe,