@legendapp/state 3.0.0-alpha.1 → 3.0.0-alpha.2

package/sync-plugins/keel.js

@@ -1,492 +1,260 @@
 'use strict';
 
-var require$$0 = require('crypto');
-var require$$1 = require('util');
+var ksuid = require('ksuid');
 var state = require('@legendapp/state');
 var sync = require('@legendapp/state/sync');
 var crud = require('@legendapp/state/sync-plugins/crud');
 
-var base62$1 = {};
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-const maxLength = (array, from, to) => Math.ceil(array.length * Math.log2(from) / Math.log2(to));
+var ksuid__default = /*#__PURE__*/_interopDefault(ksuid);
 
-function baseConvertIntArray$1 (array, {from, to, fixedLength = null}) {
-  const length = fixedLength === null ? maxLength(array, from, to) : fixedLength;
-  const result = new Array(length);
-
-  // Each iteration prepends the resulting value, so start the offset at the end.
-  let offset = length;
-  let input = array;
-  while (input.length > 0) {
-    if (offset === 0) {
-      throw new RangeError(`Fixed length of ${fixedLength} is too small, expected at least ${maxLength(array, from, to)}`)
-    }
-
-    const quotients = [];
-    let remainder = 0;
-
-    for (const digit of input) {
-      const acc = digit + remainder * from;
-      const q = Math.floor(acc / to);
-      remainder = acc % to;
-
-      if (quotients.length > 0 || q > 0) {
-        quotients.push(q);
-      }
-    }
-
-    result[--offset] = remainder;
-    input = quotients;
-  }
-
-  // Trim leading padding, unless length is fixed.
-  if (fixedLength === null) {
-    return offset > 0 ? result.slice(offset) : result
-  }
-
-  // Fill in any holes in the result array.
-  while (offset > 0) {
-    result[--offset] = 0;
-  }
-  return result
-}
-var baseConvertIntArray_1 = baseConvertIntArray$1;
-
-const baseConvertIntArray = baseConvertIntArray_1;
-
-const CHARS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
-
-function encode (buffer, fixedLength) {
-  return baseConvertIntArray(buffer, { from: 256, to: 62, fixedLength })
-    .map(value => CHARS[value])
-    .join('')
-}
-base62$1.encode = encode;
-
-function decode (string, fixedLength) {
-  // Optimization from https://github.com/andrew/base62.js/pull/31.
-  const input = Array.from(string, char => {
-    const charCode = char.charCodeAt(0);
-    if (charCode < 58) return charCode - 48
-    if (charCode < 91) return charCode - 55
-    return charCode - 61
-  });
-  return Buffer.from(baseConvertIntArray(input, { from: 62, to: 256, fixedLength }))
-}
-base62$1.decode = decode;
-
-const { randomBytes } = require$$0;
-const { inspect: { custom: customInspectSymbol }, promisify } = require$$1;
-const base62 = base62$1;
-
-const asyncRandomBytes = promisify(randomBytes);
-
-// KSUID's epoch starts more recently so that the 32-bit number space gives a
-// significantly higher useful lifetime of around 136 years from March 2014.
-// This number (14e11) was picked to be easy to remember.
-const EPOCH_IN_MS = 14e11;
-
-const MAX_TIME_IN_MS = 1e3 * (2 ** 32 - 1) + EPOCH_IN_MS;
-
-// Timestamp is a uint32
-const TIMESTAMP_BYTE_LENGTH = 4;
-
-// Payload is 16-bytes
-const PAYLOAD_BYTE_LENGTH = 16;
-
-// KSUIDs are 20 bytes when binary encoded
-const BYTE_LENGTH = TIMESTAMP_BYTE_LENGTH + PAYLOAD_BYTE_LENGTH;
-
-// The length of a KSUID when string (base62) encoded
-const STRING_ENCODED_LENGTH = 27;
-
-const TIME_IN_MS_ASSERTION = `Valid KSUID timestamps must be in milliseconds since ${new Date(0).toISOString()},
-  no earlier than ${new Date(EPOCH_IN_MS).toISOString()} and no later than ${new Date(MAX_TIME_IN_MS).toISOString()}
-`.trim().replace(/(\n|\s)+/g, ' ').replace(/\.000Z/g, 'Z');
-
-const VALID_ENCODING_ASSERTION = `Valid encoded KSUIDs are ${STRING_ENCODED_LENGTH} characters`;
-
-const VALID_BUFFER_ASSERTION = `Valid KSUID buffers are ${BYTE_LENGTH} bytes`;
-
-const VALID_PAYLOAD_ASSERTION = `Valid KSUID payloads are ${PAYLOAD_BYTE_LENGTH} bytes`;
-
-function fromParts (timeInMs, payload) {
-  const timestamp = Math.floor((timeInMs - EPOCH_IN_MS) / 1e3);
-  const timestampBuffer = Buffer.allocUnsafe(TIMESTAMP_BYTE_LENGTH);
-  timestampBuffer.writeUInt32BE(timestamp, 0);
-
-  return Buffer.concat([timestampBuffer, payload], BYTE_LENGTH)
-}
-
-const bufferLookup = new WeakMap();
-
-class KSUID {
-  constructor (buffer) {
-    if (!KSUID.isValid(buffer)) {
-      throw new TypeError(VALID_BUFFER_ASSERTION)
-    }
-
-    bufferLookup.set(this, buffer);
-    Object.defineProperty(this, 'buffer', {
-      enumerable: true,
-      get () { return Buffer.from(buffer) }
-    });
-  }
-
-  get raw () {
-    return Buffer.from(bufferLookup.get(this).slice(0))
-  }
-
-  get date () {
-    return new Date(1e3 * this.timestamp + EPOCH_IN_MS)
-  }
-
-  get timestamp () {
-    return bufferLookup.get(this).readUInt32BE(0)
-  }
-
-  get payload () {
-    const payload = bufferLookup.get(this).slice(TIMESTAMP_BYTE_LENGTH, BYTE_LENGTH);
-    return Buffer.from(payload)
-  }
-
-  get string () {
-    const encoded = base62.encode(bufferLookup.get(this), STRING_ENCODED_LENGTH);
-    return encoded.padStart(STRING_ENCODED_LENGTH, '0')
-  }
-
-  compare (other) {
-    if (!bufferLookup.has(other)) {
-      return 0
-    }
-
-    return bufferLookup.get(this).compare(bufferLookup.get(other), 0, BYTE_LENGTH)
-  }
-
-  equals (other) {
-    return this === other || (bufferLookup.has(other) && this.compare(other) === 0)
-  }
-
-  toString () {
-    return `${this[Symbol.toStringTag]} { ${this.string} }`
-  }
-
-  toJSON () {
-    return this.string
-  }
-
-  [customInspectSymbol] () {
-    return this.toString()
-  }
-
-  static async random (time = Date.now()) {
-    const payload = await asyncRandomBytes(PAYLOAD_BYTE_LENGTH);
-    return new KSUID(fromParts(Number(time), payload))
-  }
-
-  static randomSync (time = Date.now()) {
-    const payload = randomBytes(PAYLOAD_BYTE_LENGTH);
-    return new KSUID(fromParts(Number(time), payload))
-  }
-
-  static fromParts (timeInMs, payload) {
-    if (!Number.isInteger(timeInMs) || timeInMs < EPOCH_IN_MS || timeInMs > MAX_TIME_IN_MS) {
-      throw new TypeError(TIME_IN_MS_ASSERTION)
-    }
-    if (!Buffer.isBuffer(payload) || payload.byteLength !== PAYLOAD_BYTE_LENGTH) {
-      throw new TypeError(VALID_PAYLOAD_ASSERTION)
-    }
-
-    return new KSUID(fromParts(timeInMs, payload))
-  }
-
-  static isValid (buffer) {
-    return Buffer.isBuffer(buffer) && buffer.byteLength === BYTE_LENGTH
-  }
-
-  static parse (string) {
-    if (string.length !== STRING_ENCODED_LENGTH) {
-      throw new TypeError(VALID_ENCODING_ASSERTION)
-    }
-
-    const decoded = base62.decode(string, BYTE_LENGTH);
-    if (decoded.byteLength === BYTE_LENGTH) {
-      return new KSUID(decoded)
-    }
-
-    const buffer = Buffer.allocUnsafe(BYTE_LENGTH);
-    const padEnd = BYTE_LENGTH - decoded.byteLength;
-    buffer.fill(0, 0, padEnd);
-    decoded.copy(buffer, padEnd);
-    return new KSUID(buffer)
-  }
-}
-Object.defineProperty(KSUID.prototype, Symbol.toStringTag, { value: 'KSUID' });
-// A string-encoded maximum value for a KSUID
-Object.defineProperty(KSUID, 'MAX_STRING_ENCODED', { value: 'aWgEPTl1tmebfsQzFP4bxwgy80V' });
-// A string-encoded minimum value for a KSUID
-Object.defineProperty(KSUID, 'MIN_STRING_ENCODED', { value: '000000000000000000000000000' });
-
-var ksuid = KSUID;
-
-const { clone } = state.internal;
-const KeelKeys = ['createdAt', 'updatedAt'];
+// src/sync-plugins/keel.ts
+var { clone } = state.internal;
+var KeelKeys = ["createdAt", "updatedAt"];
 function generateKeelId() {
-    return ksuid.randomSync().string;
+  return ksuid__default.default.randomSync().string;
 }
-const keelConfig = {};
-const modifiedClients = new WeakSet();
-const isEnabled$ = state.observable(true);
+var keelConfig = {};
+var modifiedClients = /* @__PURE__ */ new WeakSet();
+var isEnabled$ = state.observable(true);
 async function ensureAuthToken() {
-    await state.when(isEnabled$.get());
-    let isAuthed = await keelConfig.client.auth.isAuthenticated();
-    if (!isAuthed) {
-        isAuthed = await keelConfig.client.auth.refresh();
-    }
-    return isAuthed;
+  await state.when(isEnabled$.get());
+  let isAuthed = await keelConfig.client.auth.isAuthenticated();
+  if (!isAuthed) {
+    isAuthed = await keelConfig.client.auth.refresh();
+  }
+  return isAuthed;
 }
 async function handleApiError(error, retry) {
-    if (error.type === 'unauthorized' || error.type === 'forbidden') {
-        console.warn('Keel token expired, refreshing...');
-        await ensureAuthToken();
-        // Retry
-        retry === null || retry === void 0 ? void 0 : retry();
-    }
+  if (error.type === "unauthorized" || error.type === "forbidden") {
+    console.warn("Keel token expired, refreshing...");
+    await ensureAuthToken();
+  }
 }
 function convertObjectToCreate(item) {
-    const cloned = clone(item);
-    Object.keys(cloned).forEach((key) => {
-        if (key.endsWith('Id')) {
-            if (cloned[key]) {
-                cloned[key.slice(0, -2)] = { id: cloned[key] };
-            }
-            delete cloned[key];
-        }
-    });
-    delete cloned.createdAt;
-    delete cloned.updatedAt;
-    return cloned;
+  const cloned = clone(item);
+  Object.keys(cloned).forEach((key) => {
+    if (key.endsWith("Id")) {
+      if (cloned[key]) {
+        cloned[key.slice(0, -2)] = { id: cloned[key] };
+      }
+      delete cloned[key];
+    }
+  });
+  delete cloned.createdAt;
+  delete cloned.updatedAt;
+  return cloned;
 }
 function getSyncedKeelConfiguration() {
-    return keelConfig;
+  return keelConfig;
 }
 function configureSyncedKeel(config) {
-    const { enabled, realtimePlugin, client, ...rest } = config;
-    Object.assign(keelConfig, sync.removeNullUndefined(rest));
-    if (enabled !== undefined) {
-        isEnabled$.set(enabled);
-    }
-    if (realtimePlugin) {
-        keelConfig.realtimePlugin = realtimePlugin;
-        if (client && !modifiedClients.has(client)) {
-            modifiedClients.add(client);
-            const queries = client.api.queries;
-            Object.keys(queries).forEach((key) => {
-                if (key.startsWith('list')) {
-                    const oldFn = queries[key];
-                    queries[key] = (i) => {
-                        const realtimeKey = [key, ...Object.values(i.where || {})]
-                            .filter((value) => value && typeof value !== 'object')
-                            .join('/');
-                        const subscribe = ({ refresh }) => {
-                            if (realtimeKey) {
-                                return realtimePlugin.subscribe(realtimeKey, refresh);
-                            }
-                        };
-                        return oldFn(i).then((ret) => {
-                            if (subscribe) {
-                                ret.subscribe = subscribe;
-                                ret.subscribeKey = realtimeKey;
-                            }
-                            return ret;
-                        });
-                    };
-                }
+  const { enabled, realtimePlugin, client, ...rest } = config;
+  Object.assign(keelConfig, sync.removeNullUndefined(rest));
+  if (enabled !== void 0) {
+    isEnabled$.set(enabled);
+  }
+  if (realtimePlugin) {
+    keelConfig.realtimePlugin = realtimePlugin;
+    if (client && !modifiedClients.has(client)) {
+      modifiedClients.add(client);
+      const queries = client.api.queries;
+      Object.keys(queries).forEach((key) => {
+        if (key.startsWith("list")) {
+          const oldFn = queries[key];
+          queries[key] = (i) => {
+            const realtimeKey = [key, ...Object.values(i.where || {})].filter((value) => value && typeof value !== "object").join("/");
+            const subscribe = ({ refresh }) => {
+              if (realtimeKey) {
+                return realtimePlugin.subscribe(realtimeKey, refresh);
+              }
+            };
+            return oldFn(i).then((ret) => {
+              if (subscribe) {
+                ret.subscribe = subscribe;
+                ret.subscribeKey = realtimeKey;
+              }
+              return ret;
             });
+          };
         }
+      });
     }
+  }
 }
-const NumPerPage = 200;
+var NumPerPage = 200;
 async function getAllPages(listFn, params) {
-    const allData = [];
-    let pageInfo = undefined;
-    let subscribe_;
-    let subscribeKey_;
-    const { first: firstParam } = params;
-    do {
-        const first = firstParam ? Math.min(firstParam - allData.length, NumPerPage) : NumPerPage;
-        if (first < 1) {
-            break;
-        }
-        const pageEndCursor = pageInfo === null || pageInfo === void 0 ? void 0 : pageInfo.endCursor;
-        const paramsWithCursor = pageEndCursor
-            ? { first, ...params, after: pageEndCursor }
-            : { first, ...params };
-        pageInfo = undefined;
-        const ret = await listFn(paramsWithCursor);
-        if (ret) {
-            // @ts-expect-error TODOKEEL
-            const { data, error, subscribe, subscribeKey } = ret;
-            if (subscribe) {
-                subscribe_ = subscribe;
-                subscribeKey_ = subscribeKey;
-            }
-            if (error) {
-                await handleApiError(error);
-                throw new Error(error.message);
-            }
-            else if (data) {
-                pageInfo = data.pageInfo;
-                allData.push(...data.results);
-            }
-        }
-    } while (pageInfo === null || pageInfo === void 0 ? void 0 : pageInfo.hasNextPage);
-    return { results: allData, subscribe: subscribe_, subscribeKey: subscribeKey_ };
+  const allData = [];
+  let pageInfo = void 0;
+  let subscribe_;
+  let subscribeKey_;
+  const { first: firstParam } = params;
+  do {
+    const first = firstParam ? Math.min(firstParam - allData.length, NumPerPage) : NumPerPage;
+    if (first < 1) {
+      break;
+    }
+    const pageEndCursor = pageInfo == null ? void 0 : pageInfo.endCursor;
+    const paramsWithCursor = pageEndCursor ? { first, ...params, after: pageEndCursor } : { first, ...params };
+    pageInfo = void 0;
+    const ret = await listFn(paramsWithCursor);
+    if (ret) {
+      const { data, error, subscribe, subscribeKey } = ret;
+      if (subscribe) {
+        subscribe_ = subscribe;
+        subscribeKey_ = subscribeKey;
+      }
+      if (error) {
+        await handleApiError(error);
+        throw new Error(error.message);
+      } else if (data) {
+        pageInfo = data.pageInfo;
+        allData.push(...data.results);
+      }
+    }
+  } while (pageInfo == null ? void 0 : pageInfo.hasNextPage);
+  return { results: allData, subscribe: subscribe_, subscribeKey: subscribeKey_ };
 }
 function syncedKeel(props) {
-    const { realtimePlugin } = keelConfig;
-    props = { ...keelConfig, ...props };
-    const { get: getParam, list: listParam, create: createParam, update: updateParam, delete: deleteParam, first, where: whereParam, waitFor, fieldDeleted, ...rest } = props;
-    const { changesSince } = props;
-    const asType = getParam ? 'value' : props.as;
-    let subscribeFn;
-    const subscribeFnKey$ = state.observable('');
-    const fieldCreatedAt = 'createdAt';
-    const fieldUpdatedAt = 'updatedAt';
-    const list = listParam
-        ? async (listParams) => {
-            const { lastSync, refresh } = listParams;
-            const queryBySync = !!lastSync && changesSince === 'last-sync';
-            // If querying with lastSync pass it to the "where" parameters
-            const where = Object.assign(queryBySync ? { updatedAt: { after: new Date(lastSync + 1) } } : {}, state.isFunction(whereParam) ? whereParam() : whereParam);
-            const params = { where, first };
-            // TODO: Error?
-            const { results, subscribe, subscribeKey } = await getAllPages(listParam, params);
-            if (subscribe) {
-                subscribeFn = () => subscribe({ refresh });
-                subscribeFnKey$.set(subscribeKey);
-            }
-            return results;
-        }
-        : undefined;
-    const get = getParam
-        ? async (getParams) => {
-            const { refresh } = getParams;
-            //   @ts-expect-error TODOKEEL
-            const { data, error, subscribe, subscribeKey } = await getParam({ refresh });
-            if (subscribe) {
-                subscribeFn = () => subscribe({ refresh });
-                subscribeFnKey$.set(subscribeKey);
-            }
-            if (error) {
-                throw new Error(error.message);
-            }
-            else {
-                return data;
-            }
-        }
-        : undefined;
-    const onSaved = ({ saved }) => {
-        if (saved) {
-            const updatedAt = saved[fieldUpdatedAt];
-            if (updatedAt && realtimePlugin) {
-                const subscribeFnKey = subscribeFnKey$.get();
-                if (subscribeFnKey) {
-                    realtimePlugin.setLatestChange(subscribeFnKey, updatedAt);
-                }
-            }
-        }
-    };
-    const handleSetError = async (error, params, isCreate) => {
-        var _a, _b, _c;
-        const { retryNum, cancelRetry, update } = params;
-        if (isCreate &&
-            ((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes('for the unique')) &&
-            ((_b = error.message) === null || _b === void 0 ? void 0 : _b.includes('must be unique'))) {
-            if (__DEV__) {
-                console.log('Creating duplicate data already saved, just ignore.');
-            }
-            // This has already been saved but didn't update pending changes, so just update with {} to clear the pending state
-            update({
-                value: {},
-                mode: 'assign',
-            });
-        }
-        else if (error.type === 'bad_request') {
-            (_c = keelConfig.onError) === null || _c === void 0 ? void 0 : _c.call(keelConfig, error);
-            if (retryNum > 4) {
-                cancelRetry();
-            }
-            throw new Error(error.message);
-        }
-        else {
-            await handleApiError(error);
-            throw new Error(error.message);
-        }
-    };
-    const create = createParam
-        ? async (input, params) => {
-            const { data, error } = await createParam(convertObjectToCreate(input));
-            if (error) {
-                handleSetError(error, params, true);
-            }
-            return data;
-        }
-        : undefined;
-    const update = updateParam
-        ? async (input, params) => {
-            const id = input.id;
-            const values = convertObjectToCreate(input);
-            delete values.id;
-            delete values.createdAt;
-            delete values.updatedAt;
-            if (!state.isEmpty(values)) {
-                const { data, error } = await updateParam({ where: { id }, values });
-                if (error) {
-                    handleSetError(error, params, false);
-                }
-                return data;
-            }
-        }
-        : undefined;
-    const deleteFn = deleteParam
-        ? async ({ id }, params) => {
-            const { data, error } = await deleteParam({ id });
-            if (error) {
-                handleSetError(error, params, false);
-            }
-            return data;
+  const { realtimePlugin } = keelConfig;
+  props = { ...keelConfig, ...props };
+  const {
+    get: getParam,
+    list: listParam,
+    create: createParam,
+    update: updateParam,
+    delete: deleteParam,
+    first,
+    where: whereParam,
+    waitFor,
+    fieldDeleted,
+    ...rest
+  } = props;
+  const { changesSince } = props;
+  const asType = getParam ? "value" : props.as;
+  let subscribeFn;
+  const subscribeFnKey$ = state.observable("");
+  const fieldCreatedAt = "createdAt";
+  const fieldUpdatedAt = "updatedAt";
+  const list = listParam ? async (listParams) => {
+    const { lastSync, refresh } = listParams;
+    const queryBySync = !!lastSync && changesSince === "last-sync";
+    const where = Object.assign(
+      queryBySync ? { updatedAt: { after: new Date(lastSync + 1) } } : {},
+      state.isFunction(whereParam) ? whereParam() : whereParam
+    );
+    const params = { where, first };
+    const { results, subscribe: subscribe2, subscribeKey } = await getAllPages(listParam, params);
+    if (subscribe2) {
+      subscribeFn = () => subscribe2({ refresh });
+      subscribeFnKey$.set(subscribeKey);
+    }
+    return results;
+  } : void 0;
+  const get = getParam ? async (getParams) => {
+    const { refresh } = getParams;
+    const { data, error, subscribe: subscribe2, subscribeKey } = await getParam({ refresh });
+    if (subscribe2) {
+      subscribeFn = () => subscribe2({ refresh });
+      subscribeFnKey$.set(subscribeKey);
+    }
+    if (error) {
+      throw new Error(error.message);
+    } else {
+      return data;
+    }
+  } : void 0;
+  const onSaved = ({ saved }) => {
+    if (saved) {
+      const updatedAt = saved[fieldUpdatedAt];
+      if (updatedAt && realtimePlugin) {
+        const subscribeFnKey = subscribeFnKey$.get();
+        if (subscribeFnKey) {
+          realtimePlugin.setLatestChange(subscribeFnKey, updatedAt);
         }
-        : undefined;
-    const subscribe = (params) => {
-        let unsubscribe = undefined;
-        state.when(subscribeFnKey$, () => {
-            unsubscribe = subscribeFn(params);
-        });
-        return () => {
-            unsubscribe === null || unsubscribe === void 0 ? void 0 : unsubscribe();
-        };
-    };
-    return crud.syncedCrud({
-        ...rest,
-        as: asType,
-        list,
-        create,
-        update,
-        delete: deleteFn,
-        waitFor: () => isEnabled$.get() && (waitFor ? state.computeSelector(waitFor) : true),
-        onSaved,
-        onSavedUpdate: 'createdUpdatedAt',
-        fieldCreatedAt,
-        fieldUpdatedAt,
-        fieldDeleted: fieldDeleted || 'deleted',
-        changesSince,
-        updatePartial: true,
-        subscribe,
-        generateId: generateKeelId,
-        // @ts-expect-error This errors because of the get/list union type
-        get,
+      }
+    }
+  };
+  const handleSetError = async (error, params, isCreate) => {
+    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"))) {
+      if (__DEV__) {
+        console.log("Creating duplicate data already saved, just ignore.");
+      }
+      update2({
+        value: {},
+        mode: "assign"
+      });
+    } else if (error.type === "bad_request") {
+      (_c = keelConfig.onError) == null ? void 0 : _c.call(keelConfig, error);
+      if (retryNum > 4) {
+        cancelRetry();
+      }
+      throw new Error(error.message);
+    } else {
+      await handleApiError(error);
+      throw new Error(error.message);
+    }
+  };
+  const create = createParam ? async (input, params) => {
+    const { data, error } = await createParam(convertObjectToCreate(input));
+    if (error) {
+      handleSetError(error, params, true);
+    }
+    return data;
+  } : void 0;
+  const update = updateParam ? async (input, params) => {
+    const id = input.id;
+    const values = convertObjectToCreate(input);
+    delete values.id;
+    delete values.createdAt;
+    delete values.updatedAt;
+    if (!state.isEmpty(values)) {
+      const { data, error } = await updateParam({ where: { id }, values });
+      if (error) {
+        handleSetError(error, params, false);
+      }
+      return data;
+    }
+  } : void 0;
+  const deleteFn = deleteParam ? async ({ id }, params) => {
+    const { data, error } = await deleteParam({ id });
+    if (error) {
+      handleSetError(error, params, false);
+    }
+    return data;
+  } : void 0;
+  const subscribe = (params) => {
+    let unsubscribe = void 0;
+    state.when(subscribeFnKey$, () => {
+      unsubscribe = subscribeFn(params);
     });
+    return () => {
+      unsubscribe == null ? void 0 : unsubscribe();
+    };
+  };
+  return crud.syncedCrud({
+    ...rest,
+    as: asType,
+    list,
+    create,
+    update,
+    delete: deleteFn,
+    waitFor: () => isEnabled$.get() && (waitFor ? state.computeSelector(waitFor) : true),
+    onSaved,
+    onSavedUpdate: "createdUpdatedAt",
+    fieldCreatedAt,
+    fieldUpdatedAt,
+    fieldDeleted: fieldDeleted || "deleted",
+    changesSince,
+    updatePartial: true,
+    subscribe,
+    generateId: generateKeelId,
+    // @ts-expect-error This errors because of the get/list union type
+    get
+  });
 }
 
 exports.KeelKeys = KeelKeys;
@@ -494,4 +262,3 @@ exports.configureSyncedKeel = configureSyncedKeel;
 exports.generateKeelId = generateKeelId;
 exports.getSyncedKeelConfiguration = getSyncedKeelConfiguration;
 exports.syncedKeel = syncedKeel;
-//# sourceMappingURL=keel.js.map