tinybase 5.4.0-beta.1 → 5.4.0-beta.3

package/umd/persisters/persister-cr-sqlite-wasm/with-schemas/index.js

@@ -17,8 +17,9 @@
   const UNDEFINED = '\uFFFC';
 
   const promise = Promise;
+  const THOUSAND = 1e3;
   const startInterval = (callback, sec, immediate) => {
-    return setInterval(callback, sec * 1e3);
+    return setInterval(callback, sec * THOUSAND);
   };
   const stopInterval = clearInterval;
   const isUndefined = (thing) => thing == void 0;
@@ -252,12 +253,16 @@
 
   const scheduleRunning = mapNew();
   const scheduleActions = mapNew();
-  const getStoreFunctions = (persist = 1 /* StoreOnly */, store) =>
+  const getStoreFunctions = (
+    persist = 1 /* StoreOnly */,
+    store,
+    isSynchronizer,
+  ) =>
     persist != 1 /* StoreOnly */ && store.isMergeable()
       ? [
           1,
           store.getMergeableContent,
-          store.getTransactionMergeableChanges,
+          () => store.getTransactionMergeableChanges(!isSynchronizer),
           ([[changedTables], [changedValues]]) =>
             !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
           store.setDefaultContent,
@@ -281,6 +286,7 @@
     onIgnoredError,
     persist,
     extra = {},
+    isSynchronizer = 0,
     scheduleId = [],
   ) => {
     let status = 0; /* Idle */
@@ -298,7 +304,7 @@
       getChanges,
       hasChanges,
       setDefaultContent,
-    ] = getStoreFunctions(persist, store);
+    ] = getStoreFunctions(persist, store, isSynchronizer);
     const [addListener, callListeners, delListenerImpl] = getListenerFunctions(
       () => persister,
     );
@@ -349,7 +355,7 @@
             } else if (initialContent) {
               setDefaultContent(initialContent);
             } else {
-              errorNew(`Content is not an array ${content}`);
+              errorNew(`Content is not an array: ${content}`);
             }
           } catch (error) {
             onIgnoredError?.(error);
@@ -363,7 +369,8 @@
       return persister;
     };
     const startAutoLoad = async (initialContent) => {
-      await stopAutoLoad().load(initialContent);
+      stopAutoLoad();
+      await load(initialContent);
       try {
         autoLoadHandle = await addPersisterListener(
           async (content, changes) => {
@@ -412,7 +419,8 @@
       return persister;
     };
     const startAutoSave = async () => {
-      await stopAutoSave().save();
+      stopAutoSave();
+      await save();
       autoSaveListenerId = store.addDidFinishTransactionListener(() => {
         const changes = getChanges();
         if (hasChanges(changes)) {
@@ -422,8 +430,10 @@
       return persister;
     };
     const stopAutoSave = () => {
-      ifNotUndefined(autoSaveListenerId, store.delListener);
-      autoSaveListenerId = void 0;
+      if (autoSaveListenerId) {
+        store.delListener(autoSaveListenerId);
+        autoSaveListenerId = void 0;
+      }
       return persister;
     };
     const isAutoSaving = () => !isUndefined(autoSaveListenerId);
@@ -782,6 +792,7 @@
       onIgnoredError,
       persist,
       {[getThing]: () => thing, destroy},
+      0,
       thing,
     );
     return persister;
@@ -908,6 +919,7 @@
       onIgnoredError,
       persist,
       {[getThing]: () => thing, destroy},
+      0,
       thing,
     );
     return persister;

package/umd/persisters/persister-durable-object-storage/index.js

@@ -0,0 +1,562 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined'
+    ? factory(exports)
+    : typeof define === 'function' && define.amd
+      ? define(['exports'], factory)
+      : ((global =
+          typeof globalThis !== 'undefined' ? globalThis : global || self),
+        factory((global.TinyBasePersisterDurableObjectStorage = {})));
+})(this, function (exports) {
+  'use strict';
+
+  const EMPTY_STRING = '';
+  const T = 't';
+  const V = 'v';
+  const UNDEFINED = '\uFFFC';
+  const strStartsWith = (str, prefix) => str.startsWith(prefix);
+
+  const isUndefined = (thing) => thing == void 0;
+  const ifNotUndefined = (value, then, otherwise) =>
+    isUndefined(value) ? otherwise?.() : then(value);
+  const isArray = (thing) => Array.isArray(thing);
+  const slice = (arrayOrString, start, end) => arrayOrString.slice(start, end);
+  const size = (arrayOrString) => arrayOrString.length;
+  const test = (regex, subject) => regex.test(subject);
+  const errorNew = (message) => {
+    throw new Error(message);
+  };
+
+  const arrayForEach = (array, cb) => array.forEach(cb);
+  const arrayClear = (array, to) => array.splice(0, to);
+  const arrayPush = (array, ...values) => array.push(...values);
+  const arrayShift = (array) => array.shift();
+
+  const object = Object;
+  const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
+  const objEntries = object.entries;
+  const isObject = (obj) =>
+    !isUndefined(obj) &&
+    ifNotUndefined(
+      getPrototypeOf(obj),
+      (objPrototype) =>
+        objPrototype == object.prototype ||
+        isUndefined(getPrototypeOf(objPrototype)),
+
+      /* istanbul ignore next */
+      () => true,
+    );
+  const objIds = object.keys;
+  const objFreeze = object.freeze;
+  const objHas = (obj, id) => id in obj;
+  const objForEach = (obj, cb) =>
+    arrayForEach(objEntries(obj), ([id, value]) => cb(value, id));
+  const objSize = (obj) => size(objIds(obj));
+  const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
+  const objEnsure = (obj, id, getDefaultValue) => {
+    if (!objHas(obj, id)) {
+      obj[id] = getDefaultValue();
+    }
+    return obj[id];
+  };
+
+  const collSize = (coll) => coll?.size ?? 0;
+  const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
+  const collIsEmpty = (coll) => isUndefined(coll) || collSize(coll) == 0;
+  const collForEach = (coll, cb) => coll?.forEach(cb);
+  const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
+
+  const mapNew = (entries) => new Map(entries);
+  const mapGet = (map, key) => map?.get(key);
+  const mapSet = (map, key, value) =>
+    isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
+  const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
+    if (!collHas(map, key)) {
+      mapSet(map, key, getDefaultValue());
+    } else {
+      hadExistingValue?.(mapGet(map, key));
+    }
+    return mapGet(map, key);
+  };
+  const mapToObj = (map, valueMapper, excludeMapValue, excludeObjValue) => {
+    const obj = {};
+    collForEach(map, (mapValue, id) => {
+      {
+        const objValue = mapValue;
+        {
+          obj[id] = objValue;
+        }
+      }
+    });
+    return obj;
+  };
+  const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
+    ifNotUndefined(
+      (ensureLeaf ? mapEnsure : mapGet)(
+        node,
+        path[p],
+        p > size(path) - 2 ? ensureLeaf : mapNew,
+      ),
+      (nodeOrLeaf) => {
+        if (p > size(path) - 2) {
+          if (pruneLeaf?.(nodeOrLeaf)) {
+            mapSet(node, path[p]);
+          }
+          return nodeOrLeaf;
+        }
+        const leaf = visitTree(nodeOrLeaf, path, ensureLeaf, pruneLeaf, p + 1);
+        if (collIsEmpty(nodeOrLeaf)) {
+          mapSet(node, path[p]);
+        }
+        return leaf;
+      },
+    );
+
+  const stampNewWithHash = (value, time, hash) => [value, time, hash];
+  const stampUpdate = (stamp, time, hash) => {
+    if (time > stamp[1]) {
+      stamp[1] = time;
+    }
+    stamp[2] = hash >>> 0;
+  };
+
+  const setNew = (entryOrEntries) =>
+    new Set(
+      isArray(entryOrEntries) || isUndefined(entryOrEntries)
+        ? entryOrEntries
+        : [entryOrEntries],
+    );
+  const setAdd = (set, value) => set?.add(value);
+
+  const INTEGER = /^\d+$/;
+  const getPoolFunctions = () => {
+    const pool = [];
+    let nextId = 0;
+    return [
+      (reuse) => (reuse ? arrayShift(pool) : null) ?? EMPTY_STRING + nextId++,
+      (id) => {
+        if (test(INTEGER, id) && size(pool) < 1e3) {
+          arrayPush(pool, id);
+        }
+      },
+    ];
+  };
+
+  const getWildcardedLeaves = (deepIdSet, path = [EMPTY_STRING]) => {
+    const leaves = [];
+    const deep = (node, p) =>
+      p == size(path)
+        ? arrayPush(leaves, node)
+        : path[p] === null
+          ? collForEach(node, (node2) => deep(node2, p + 1))
+          : arrayForEach([path[p], null], (id) =>
+              deep(mapGet(node, id), p + 1),
+            );
+    deep(deepIdSet, 0);
+    return leaves;
+  };
+  const getListenerFunctions = (getThing) => {
+    let thing;
+    const [getId, releaseId] = getPoolFunctions();
+    const allListeners = mapNew();
+    const addListener = (
+      listener,
+      idSetNode,
+      path,
+      pathGetters = [],
+      extraArgsGetter = () => [],
+    ) => {
+      thing ??= getThing();
+      const id = getId(1);
+      mapSet(allListeners, id, [
+        listener,
+        idSetNode,
+        path,
+        pathGetters,
+        extraArgsGetter,
+      ]);
+      setAdd(visitTree(idSetNode, path ?? [EMPTY_STRING], setNew), id);
+      return id;
+    };
+    const callListeners = (idSetNode, ids, ...extraArgs) =>
+      arrayForEach(getWildcardedLeaves(idSetNode, ids), (set) =>
+        collForEach(set, (id) =>
+          mapGet(allListeners, id)[0](thing, ...(ids ?? []), ...extraArgs),
+        ),
+      );
+    const delListener = (id) =>
+      ifNotUndefined(mapGet(allListeners, id), ([, idSetNode, idOrNulls]) => {
+        visitTree(idSetNode, idOrNulls ?? [EMPTY_STRING], void 0, (idSet) => {
+          collDel(idSet, id);
+          return collIsEmpty(idSet) ? 1 : 0;
+        });
+        mapSet(allListeners, id);
+        releaseId(id);
+        return idOrNulls;
+      });
+    const callListener = (id) =>
+      ifNotUndefined(
+        mapGet(allListeners, id),
+        ([listener, , path = [], pathGetters, extraArgsGetter]) => {
+          const callWithIds = (...ids) => {
+            const index = size(ids);
+            if (index == size(path)) {
+              listener(thing, ...ids, ...extraArgsGetter(ids));
+            } else if (isUndefined(path[index])) {
+              arrayForEach(pathGetters[index]?.(...ids) ?? [], (id2) =>
+                callWithIds(...ids, id2),
+              );
+            } else {
+              callWithIds(...ids, path[index]);
+            }
+          };
+          callWithIds();
+        },
+      );
+    return [addListener, callListeners, delListener, callListener];
+  };
+
+  const scheduleRunning = mapNew();
+  const scheduleActions = mapNew();
+  const getStoreFunctions = (
+    persist = 1 /* StoreOnly */,
+    store,
+    isSynchronizer,
+  ) =>
+    persist != 1 /* StoreOnly */ && store.isMergeable()
+      ? [
+          1,
+          store.getMergeableContent,
+          () => store.getTransactionMergeableChanges(!isSynchronizer),
+          ([[changedTables], [changedValues]]) =>
+            !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
+          store.setDefaultContent,
+        ]
+      : persist != 2 /* MergeableStoreOnly */
+        ? [
+            0,
+            store.getContent,
+            store.getTransactionChanges,
+            ([changedTables, changedValues]) =>
+              !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
+            store.setContent,
+          ]
+        : errorNew('Store type not supported by this Persister');
+  const createCustomPersister = (
+    store,
+    getPersisted,
+    setPersisted,
+    addPersisterListener,
+    delPersisterListener,
+    onIgnoredError,
+    persist,
+    extra = {},
+    isSynchronizer = 0,
+    scheduleId = [],
+  ) => {
+    let status = 0; /* Idle */
+    let loads = 0;
+    let saves = 0;
+    let action;
+    let autoLoadHandle;
+    let autoSaveListenerId;
+    mapEnsure(scheduleRunning, scheduleId, () => 0);
+    mapEnsure(scheduleActions, scheduleId, () => []);
+    const statusListeners = mapNew();
+    const [
+      isMergeableStore,
+      getContent,
+      getChanges,
+      hasChanges,
+      setDefaultContent,
+    ] = getStoreFunctions(persist, store, isSynchronizer);
+    const [addListener, callListeners, delListenerImpl] = getListenerFunctions(
+      () => persister,
+    );
+    const setStatus = (newStatus) => {
+      if (newStatus != status) {
+        status = newStatus;
+        callListeners(statusListeners, void 0, status);
+      }
+    };
+    const run = async () => {
+      /* istanbul ignore else */
+      if (!mapGet(scheduleRunning, scheduleId)) {
+        mapSet(scheduleRunning, scheduleId, 1);
+        while (
+          !isUndefined(
+            (action = arrayShift(mapGet(scheduleActions, scheduleId))),
+          )
+        ) {
+          try {
+            await action();
+          } catch (error) {
+            /* istanbul ignore next */
+            onIgnoredError?.(error);
+          }
+        }
+        mapSet(scheduleRunning, scheduleId, 0);
+      }
+    };
+    const setContentOrChanges = (contentOrChanges) => {
+      (isMergeableStore && isArray(contentOrChanges?.[0])
+        ? contentOrChanges?.[2] === 1
+          ? store.applyMergeableChanges
+          : store.setMergeableContent
+        : contentOrChanges?.[2] === 1
+          ? store.applyChanges
+          : store.setContent)(contentOrChanges);
+    };
+    const load = async (initialContent) => {
+      /* istanbul ignore else */
+      if (status != 2 /* Saving */) {
+        setStatus(1 /* Loading */);
+        loads++;
+        await schedule(async () => {
+          try {
+            const content = await getPersisted();
+            if (isArray(content)) {
+              setContentOrChanges(content);
+            } else if (initialContent) {
+              setDefaultContent(initialContent);
+            } else {
+              errorNew(`Content is not an array: ${content}`);
+            }
+          } catch (error) {
+            onIgnoredError?.(error);
+            if (initialContent) {
+              setDefaultContent(initialContent);
+            }
+          }
+          setStatus(0 /* Idle */);
+        });
+      }
+      return persister;
+    };
+    const startAutoLoad = async (initialContent) => {
+      stopAutoLoad();
+      await load(initialContent);
+      try {
+        autoLoadHandle = await addPersisterListener(
+          async (content, changes) => {
+            if (changes || content) {
+              /* istanbul ignore else */
+              if (status != 2 /* Saving */) {
+                setStatus(1 /* Loading */);
+                loads++;
+                setContentOrChanges(changes ?? content);
+                setStatus(0 /* Idle */);
+              }
+            } else {
+              await load();
+            }
+          },
+        );
+      } catch (error) {
+        /* istanbul ignore next */
+        onIgnoredError?.(error);
+      }
+      return persister;
+    };
+    const stopAutoLoad = () => {
+      if (autoLoadHandle) {
+        autoLoadHandle = void 0;
+      }
+      return persister;
+    };
+    const isAutoLoading = () => !isUndefined(autoLoadHandle);
+    const save = async (changes) => {
+      /* istanbul ignore else */
+      if (status != 1 /* Loading */) {
+        setStatus(2 /* Saving */);
+        saves++;
+        await schedule(async () => {
+          try {
+            await setPersisted(getContent, changes);
+          } catch (error) {
+            /* istanbul ignore next */
+            onIgnoredError?.(error);
+          }
+          setStatus(0 /* Idle */);
+        });
+      }
+      return persister;
+    };
+    const startAutoSave = async () => {
+      stopAutoSave();
+      await save();
+      autoSaveListenerId = store.addDidFinishTransactionListener(() => {
+        const changes = getChanges();
+        if (hasChanges(changes)) {
+          save(changes);
+        }
+      });
+      return persister;
+    };
+    const stopAutoSave = () => {
+      if (autoSaveListenerId) {
+        store.delListener(autoSaveListenerId);
+        autoSaveListenerId = void 0;
+      }
+      return persister;
+    };
+    const isAutoSaving = () => !isUndefined(autoSaveListenerId);
+    const getStatus = () => status;
+    const addStatusListener = (listener) =>
+      addListener(listener, statusListeners);
+    const delListener = (listenerId) => {
+      delListenerImpl(listenerId);
+      return store;
+    };
+    const schedule = async (...actions) => {
+      arrayPush(mapGet(scheduleActions, scheduleId), ...actions);
+      await run();
+      return persister;
+    };
+    const getStore = () => store;
+    const destroy = () => {
+      arrayClear(mapGet(scheduleActions, scheduleId));
+      return stopAutoLoad().stopAutoSave();
+    };
+    const getStats = () => ({loads, saves});
+    const persister = {
+      load,
+      startAutoLoad,
+      stopAutoLoad,
+      isAutoLoading,
+      save,
+      startAutoSave,
+      stopAutoSave,
+      isAutoSaving,
+      getStatus,
+      addStatusListener,
+      delListener,
+      schedule,
+      getStore,
+      destroy,
+      getStats,
+      ...extra,
+    };
+    return objFreeze(persister);
+  };
+
+  const jsonString = JSON.stringify;
+  const jsonStringWithUndefined = (obj) =>
+    jsonString(obj, (_key, value) => (value === void 0 ? UNDEFINED : value));
+
+  const stampNewObjectWithHash = () => stampNewWithHash({}, EMPTY_STRING, 0);
+  const createDurableObjectStoragePersister = (
+    store,
+    storage,
+    storagePrefix = EMPTY_STRING,
+    onIgnoredError,
+  ) => {
+    const constructKey = (type, ...ids) =>
+      storagePrefix + type + slice(jsonStringWithUndefined(ids), 1, -1);
+    const deconstructKey = (key) => {
+      if (strStartsWith(key, storagePrefix)) {
+        const type = slice(key, storagePrefix.length, 1);
+        return type == T || type == V
+          ? [
+              type,
+              ...JSON.parse('[' + slice(key, storagePrefix.length + 1) + ']'),
+            ]
+          : void 0;
+      }
+    };
+    const getPersisted = async () => {
+      const tables = stampNewObjectWithHash();
+      const values = stampNewObjectWithHash();
+      (await storage.list({prefix: storagePrefix})).forEach(
+        async ([zeroOrCellOrValue, time, hash], key) =>
+          ifNotUndefined(deconstructKey(key), ([type, ...ids]) =>
+            type == T
+              ? ifNotUndefined(
+                  ids[0],
+                  (tableId) => {
+                    const table = objEnsure(
+                      tables[0],
+                      tableId,
+                      stampNewObjectWithHash,
+                    );
+                    ifNotUndefined(
+                      ids[1],
+                      (rowId) => {
+                        const row = objEnsure(
+                          table[0],
+                          rowId,
+                          stampNewObjectWithHash,
+                        );
+                        ifNotUndefined(
+                          ids[2],
+                          (cellId) =>
+                            (row[0][cellId] = [zeroOrCellOrValue, time, hash]),
+                          () => stampUpdate(row, time, hash),
+                        );
+                      },
+                      () => stampUpdate(table, time, hash),
+                    );
+                  },
+                  () => stampUpdate(tables, time, hash),
+                )
+              : type == V
+                ? ifNotUndefined(
+                    ids[0],
+                    (valueId) =>
+                      (values[0][valueId] = [zeroOrCellOrValue, time, hash]),
+                    () => stampUpdate(values, time, hash),
+                  )
+                : 0,
+          ),
+      );
+      return [tables, values];
+    };
+    const setPersisted = async (
+      getContent,
+      [
+        [tablesObj, tablesTime, tablesHash],
+        [valuesObj, valuesTime, valuesHash],
+      ] = getContent(),
+    ) => {
+      const keysToSet = mapNew();
+      mapSet(keysToSet, constructKey(T), [0, tablesTime, tablesHash]);
+      objForEach(tablesObj, ([tableObj, tableTime, tableHash], tableId) => {
+        mapSet(keysToSet, constructKey(T, tableId), [0, tableTime, tableHash]);
+        objForEach(tableObj, ([rowObj, rowTime, rowHash], rowId) => {
+          mapSet(keysToSet, constructKey(T, tableId, rowId), [
+            0,
+            rowTime,
+            rowHash,
+          ]);
+          objForEach(rowObj, (cellStamp, cellId) =>
+            mapSet(
+              keysToSet,
+              constructKey(T, tableId, rowId, cellId),
+              cellStamp,
+            ),
+          );
+        });
+      });
+      mapSet(keysToSet, constructKey(V), [0, valuesTime, valuesHash]);
+      objForEach(valuesObj, (valueStamp, valueId) =>
+        mapSet(keysToSet, constructKey(V, valueId), valueStamp),
+      );
+      await storage.put(mapToObj(keysToSet));
+    };
+    const addPersisterListener = () => {};
+    const delPersisterListener = () => {};
+    return createCustomPersister(
+      store,
+      getPersisted,
+      setPersisted,
+      addPersisterListener,
+      delPersisterListener,
+      onIgnoredError,
+      2,
+      // MergeableStoreOnly,
+      {getDurableObjectStorage: () => storage},
+    );
+  };
+
+  exports.createDurableObjectStoragePersister =
+    createDurableObjectStoragePersister;
+});