tinybase 5.0.0-beta.2 → 5.0.0-beta.21

package/lib/debug/persisters/persister-partykit-client.js

@@ -1,284 +0,0 @@
-const getTypeOf = (thing) => typeof thing;
-const EMPTY_STRING = '';
-const STRING = getTypeOf(EMPTY_STRING);
-const strStartsWith = (str, prefix) => str.startsWith(prefix);
-
-const isInstanceOf = (thing, cls) => thing instanceof cls;
-const isUndefined = (thing) => thing == void 0;
-const ifNotUndefined = (value, then, otherwise) =>
-  isUndefined(value) ? otherwise?.() : then(value);
-const isString = (thing) => getTypeOf(thing) == STRING;
-const slice = (arrayOrString, start, end) => arrayOrString.slice(start, end);
-const size = (arrayOrString) => arrayOrString.length;
-
-const arrayPush = (array, ...values) => array.push(...values);
-const arrayShift = (array) => array.shift();
-
-const object = Object;
-const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
-const objIds = object.keys;
-const objFreeze = object.freeze;
-const isObject = (obj) =>
-  !isUndefined(obj) &&
-  ifNotUndefined(
-    getPrototypeOf(obj),
-    (objPrototype) =>
-      objPrototype == object.prototype ||
-      isUndefined(getPrototypeOf(objPrototype)),
-    /* istanbul ignore next */
-    () => true,
-  );
-const objSize = (obj) => size(objIds(obj));
-const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
-
-const jsonString = (obj) =>
-  JSON.stringify(obj, (_key, value) =>
-    isInstanceOf(value, Map) ? object.fromEntries([...value]) : value,
-  );
-const jsonParse = JSON.parse;
-
-const SET_CHANGES = 's';
-const STORE_PATH = '/store';
-const PUT = 'PUT';
-const construct = (prefix, type, payload) =>
-  prefix + type + (isString(payload) ? payload : jsonString(payload));
-const deconstruct = (prefix, message, stringified) => {
-  const prefixSize = size(prefix);
-  return strStartsWith(message, prefix)
-    ? [
-        message[prefixSize],
-        (stringified ? jsonParse : String)(slice(message, prefixSize + 1)),
-      ]
-    : void 0;
-};
-
-const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
-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) => {
-  if (!collHas(map, key)) {
-    mapSet(map, key, getDefaultValue());
-  }
-  return mapGet(map, key);
-};
-
-const scheduleRunning = mapNew();
-const scheduleActions = mapNew();
-const createCustomPersister = (
-  store,
-  getPersisted,
-  setPersisted,
-  addPersisterListener,
-  delPersisterListener,
-  onIgnoredError,
-  [getThing, thing] = [],
-  scheduleId = [],
-) => {
-  let listenerId;
-  let loadSave = 0;
-  let loads = 0;
-  let saves = 0;
-  let listening = 0;
-  let action;
-  let listeningHandle;
-  mapEnsure(scheduleRunning, scheduleId, () => 0);
-  mapEnsure(scheduleActions, scheduleId, () => []);
-  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 loadLock = async (actions) => {
-    /* istanbul ignore else */
-    if (loadSave != 2) {
-      loadSave = 1;
-      {
-        loads++;
-      }
-      await persister.schedule(async () => {
-        await actions();
-        loadSave = 0;
-      });
-    }
-    return persister;
-  };
-  const persister = {
-    load: async (initialTables, initialValues) =>
-      await loadLock(async () => {
-        try {
-          store.setContent(await getPersisted());
-        } catch {
-          store.setContent([initialTables, initialValues]);
-        }
-      }),
-    startAutoLoad: async (initialTables = {}, initialValues = {}) => {
-      persister.stopAutoLoad();
-      await persister.load(initialTables, initialValues);
-      listening = 1;
-      listeningHandle = addPersisterListener(
-        async (getContent, getTransactionChanges) => {
-          if (getTransactionChanges) {
-            const transactionChanges = getTransactionChanges();
-            await loadLock(async () =>
-              store.setTransactionChanges(transactionChanges),
-            );
-          } else {
-            await loadLock(async () => {
-              try {
-                store.setContent(getContent?.() ?? (await getPersisted()));
-              } catch (error) {
-                onIgnoredError?.(error);
-              }
-            });
-          }
-        },
-      );
-      return persister;
-    },
-    stopAutoLoad: () => {
-      if (listening) {
-        delPersisterListener(listeningHandle);
-        listeningHandle = void 0;
-        listening = 0;
-      }
-      return persister;
-    },
-    save: async (getTransactionChanges) => {
-      /* istanbul ignore else */
-      if (loadSave != 1) {
-        loadSave = 2;
-        {
-          saves++;
-        }
-        await persister.schedule(async () => {
-          try {
-            await setPersisted(store.getContent, getTransactionChanges);
-          } catch (error) {
-            /* istanbul ignore next */
-            onIgnoredError?.(error);
-          }
-          loadSave = 0;
-        });
-      }
-      return persister;
-    },
-    startAutoSave: async () => {
-      await persister.stopAutoSave().save();
-      listenerId = store.addDidFinishTransactionListener(
-        (_store, getTransactionChanges) => {
-          const [tableChanges, valueChanges] = getTransactionChanges();
-          if (!objIsEmpty(tableChanges) || !objIsEmpty(valueChanges)) {
-            persister.save(() => [tableChanges, valueChanges]);
-          }
-        },
-      );
-      return persister;
-    },
-    stopAutoSave: () => {
-      ifNotUndefined(listenerId, store.delListener);
-      listenerId = void 0;
-      return persister;
-    },
-    schedule: async (...actions) => {
-      arrayPush(mapGet(scheduleActions, scheduleId), ...actions);
-      await run();
-      return persister;
-    },
-    getStore: () => store,
-    destroy: () => persister.stopAutoLoad().stopAutoSave(),
-    getStats: () => ({loads, saves}),
-  };
-  if (getThing) {
-    persister[getThing] = () => thing;
-  }
-  return objFreeze(persister);
-};
-
-const MESSAGE = 'message';
-const createPartyKitPersister = (
-  store,
-  connection,
-  configOrStoreProtocol,
-  onIgnoredError,
-) => {
-  const {host, room} = connection.partySocketOptions;
-  const {
-    storeProtocol = 'https',
-    storePath = STORE_PATH,
-    messagePrefix = EMPTY_STRING,
-  } = {
-    ...(isString(configOrStoreProtocol)
-      ? {storeProtocol: configOrStoreProtocol}
-      : configOrStoreProtocol),
-  };
-  const storeUrl =
-    storeProtocol +
-    '://' +
-    host +
-    '/parties/' +
-    connection.name +
-    '/' +
-    room +
-    storePath;
-  const getOrSetStore = async (content) =>
-    await (
-      await fetch(storeUrl, {
-        ...(content ? {method: PUT, body: jsonString(content)} : {}),
-        mode: 'cors',
-        cache: 'no-store',
-      })
-    ).json();
-  const getPersisted = async () => await getOrSetStore();
-  const setPersisted = async (getContent, getTransactionChanges) => {
-    if (getTransactionChanges) {
-      connection.send(
-        construct(messagePrefix, SET_CHANGES, getTransactionChanges()),
-      );
-    } else {
-      await getOrSetStore(getContent());
-    }
-  };
-  const addPersisterListener = (listener) => {
-    const messageListener = (event) =>
-      ifNotUndefined(
-        deconstruct(messagePrefix, event.data, 1),
-        ([type, payload]) => {
-          if (type == SET_CHANGES) {
-            listener(void 0, () => payload);
-          }
-        },
-      );
-    connection.addEventListener(MESSAGE, messageListener);
-    return messageListener;
-  };
-  const delPersisterListener = (messageListener) => {
-    connection.removeEventListener(MESSAGE, messageListener);
-  };
-  return createCustomPersister(
-    store,
-    getPersisted,
-    setPersisted,
-    addPersisterListener,
-    delPersisterListener,
-    onIgnoredError,
-    ['getConnection', connection],
-  );
-};
-
-export {createPartyKitPersister};

package/lib/debug/persisters/persister-partykit-server.js

@@ -1,292 +0,0 @@
-const getTypeOf = (thing) => typeof thing;
-const EMPTY_STRING = '';
-const STRING = getTypeOf(EMPTY_STRING);
-const T = 't';
-const V = 'v';
-const strStartsWith = (str, prefix) => str.startsWith(prefix);
-
-const promise = Promise;
-const isInstanceOf = (thing, cls) => thing instanceof cls;
-const isUndefined = (thing) => thing == void 0;
-const ifNotUndefined = (value, then, otherwise) =>
-  isUndefined(value) ? otherwise?.() : then(value);
-const isString = (thing) => getTypeOf(thing) == STRING;
-const slice = (arrayOrString, start, end) => arrayOrString.slice(start, end);
-const size = (arrayOrString) => arrayOrString.length;
-const promiseAll = async (promises) => promise.all(promises);
-
-const arrayEvery = (array, cb) => array.every(cb);
-const arrayMap = (array, cb) => array.map(cb);
-const arrayIsEmpty = (array) => size(array) == 0;
-const arrayPush = (array, ...values) => array.push(...values);
-const arrayUnshift = (array, ...values) => array.unshift(...values);
-
-const object = Object;
-const objEntries = object.entries;
-const objNew = (entries = []) => object.fromEntries(entries);
-const objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
-const objHas = (obj, id) => !isUndefined(objGet(obj, id));
-const objToArray = (obj, cb) =>
-  arrayMap(objEntries(obj), ([id, value]) => cb(value, id));
-const objEnsure = (obj, id, getDefaultValue) => {
-  if (!objHas(obj, id)) {
-    obj[id] = getDefaultValue();
-  }
-  return obj[id];
-};
-
-const jsonString = (obj) =>
-  JSON.stringify(obj, (_key, value) =>
-    isInstanceOf(value, Map) ? object.fromEntries([...value]) : value,
-  );
-const jsonParse = JSON.parse;
-
-const SET_CHANGES = 's';
-const STORE_PATH = '/store';
-const PUT = 'PUT';
-const construct = (prefix, type, payload) =>
-  prefix + type + (isString(payload) ? payload : jsonString(payload));
-const deconstruct = (prefix, message, stringified) => {
-  const prefixSize = size(prefix);
-  return strStartsWith(message, prefix)
-    ? [
-        message[prefixSize],
-        (stringified ? jsonParse : String)(slice(message, prefixSize + 1)),
-      ]
-    : void 0;
-};
-
-const collForEach = (coll, cb) => coll?.forEach(cb);
-
-const mapForEach = (map, cb) =>
-  collForEach(map, (value, key) => cb(key, value));
-
-const HAS_STORE = 'hasStore';
-const RESPONSE_HEADERS = objNew(
-  arrayMap(['Origin', 'Methods', 'Headers'], (suffix) => [
-    'Access-Control-Allow-' + suffix,
-    '*',
-  ]),
-);
-const hasStoreInStorage = async (storage, storagePrefix = EMPTY_STRING) =>
-  !!(await storage.get(storagePrefix + HAS_STORE));
-const loadStoreFromStorage = async (storage, storagePrefix = EMPTY_STRING) => {
-  const tables = {};
-  const values = {};
-  mapForEach(await storage.list(), (key, cellOrValue) =>
-    ifNotUndefined(deconstruct(storagePrefix, key), ([type, ids]) => {
-      if (type == T) {
-        const [tableId, rowId, cellId] = jsonParse('[' + ids + ']');
-        objEnsure(objEnsure(tables, tableId, objNew), rowId, objNew)[cellId] =
-          cellOrValue;
-      } else if (type == V) {
-        values[ids] = cellOrValue;
-      }
-    }),
-  );
-  return [tables, values];
-};
-const broadcastTransactionChanges = async (
-  server,
-  transactionChanges,
-  without,
-) =>
-  server.party.broadcast(
-    construct(server.config.messagePrefix, SET_CHANGES, transactionChanges),
-    without,
-  );
-const saveStore = async (
-  that,
-  transactionChanges,
-  initialSave,
-  requestOrConnection,
-) => {
-  const storage = that.party.storage;
-  const storagePrefix = that.config.storagePrefix;
-  const keysToSet = {
-    [storagePrefix + HAS_STORE]: 1,
-  };
-  const keysToDel = [];
-  const keyPrefixesToDel = [];
-  await promiseAll(
-    objToArray(transactionChanges[0], async (table, tableId) =>
-      isUndefined(table)
-        ? !initialSave &&
-          (await that.canDelTable(tableId, requestOrConnection)) &&
-          arrayUnshift(
-            keyPrefixesToDel,
-            constructStorageKey(storagePrefix, T, tableId),
-          )
-        : (await that.canSetTable(tableId, initialSave, requestOrConnection)) &&
-          (await promiseAll(
-            objToArray(table, async (row, rowId) =>
-              isUndefined(row)
-                ? !initialSave &&
-                  (await that.canDelRow(tableId, rowId, requestOrConnection)) &&
-                  arrayPush(
-                    keyPrefixesToDel,
-                    constructStorageKey(storagePrefix, T, tableId, rowId),
-                  )
-                : (await that.canSetRow(
-                    tableId,
-                    rowId,
-                    initialSave,
-                    requestOrConnection,
-                  )) &&
-                  (await promiseAll(
-                    objToArray(row, async (cell, cellId) => {
-                      const ids = [tableId, rowId, cellId];
-                      const key = constructStorageKey(storagePrefix, T, ...ids);
-                      isUndefined(cell)
-                        ? !initialSave &&
-                          (await that.canDelCell(
-                            ...ids,
-                            requestOrConnection,
-                          )) &&
-                          arrayPush(keysToDel, key)
-                        : (await that.canSetCell(
-                            ...ids,
-                            cell,
-                            initialSave,
-                            requestOrConnection,
-                            await storage.get(key),
-                          )) && (keysToSet[key] = cell);
-                    }),
-                  )),
-            ),
-          )),
-    ),
-  );
-  await promiseAll(
-    objToArray(transactionChanges[1], async (value, valueId) => {
-      const key = storagePrefix + V + valueId;
-      isUndefined(value)
-        ? !initialSave &&
-          (await that.canDelValue(valueId, requestOrConnection)) &&
-          arrayPush(keysToDel, key)
-        : (await that.canSetValue(
-            valueId,
-            value,
-            initialSave,
-            requestOrConnection,
-            await storage.get(key),
-          )) && (keysToSet[key] = value);
-    }),
-  );
-  if (!arrayIsEmpty(keyPrefixesToDel)) {
-    mapForEach(await storage.list(), (key) =>
-      arrayEvery(
-        keyPrefixesToDel,
-        (keyPrefixToDelete) =>
-          !strStartsWith(key, keyPrefixToDelete) ||
-          (arrayPush(keysToDel, key) && 0),
-      ),
-    );
-  }
-  await storage.delete(keysToDel);
-  await storage.put(keysToSet);
-};
-const constructStorageKey = (storagePrefix, type, ...ids) =>
-  construct(storagePrefix, type, slice(jsonString(ids), 1, -1));
-const createResponse = async (that, status, body = null) =>
-  new Response(body, {
-    status,
-    headers: that.config.responseHeaders,
-  });
-class TinyBasePartyKitServer {
-  constructor(party) {
-    this.party = party;
-    this.config = {};
-    this.config.storePath ??= STORE_PATH;
-    this.config.messagePrefix ??= EMPTY_STRING;
-    this.config.storagePrefix ??= EMPTY_STRING;
-    this.config.responseHeaders ??= RESPONSE_HEADERS;
-  }
-  async onRequest(request) {
-    const {
-      party: {storage},
-      config: {storePath, storagePrefix},
-    } = this;
-    if (new URL(request.url).pathname.endsWith(storePath)) {
-      const hasExistingStore = await hasStoreInStorage(storage, storagePrefix);
-      const text = await request.text();
-      if (request.method == PUT) {
-        if (hasExistingStore) {
-          return createResponse(this, 205);
-        }
-        await saveStore(this, jsonParse(text), true, request);
-        return createResponse(this, 201);
-      }
-      return createResponse(
-        this,
-        200,
-        hasExistingStore
-          ? jsonString(await loadStoreFromStorage(storage, storagePrefix))
-          : EMPTY_STRING,
-      );
-    }
-    return createResponse(this, 404);
-  }
-  async onMessage(message, connection) {
-    const {
-      config: {messagePrefix, storagePrefix},
-    } = this;
-    await ifNotUndefined(
-      deconstruct(messagePrefix, message, 1),
-      async ([type, payload]) => {
-        if (
-          type == SET_CHANGES &&
-          (await hasStoreInStorage(this.party.storage, storagePrefix))
-        ) {
-          await saveStore(this, payload, false, connection);
-          broadcastTransactionChanges(this, payload, [connection.id]);
-        }
-      },
-    );
-  }
-  async canSetTable(_tableId, _initialSave, _requestOrConnection) {
-    return true;
-  }
-  async canDelTable(_tableId, _connection) {
-    return true;
-  }
-  async canSetRow(_tableId, _rowId, _initialSave, _requestOrConnection) {
-    return true;
-  }
-  async canDelRow(_tableId, _rowId, _connection) {
-    return true;
-  }
-  async canSetCell(
-    _tableId,
-    _rowId,
-    _cellId,
-    _cell,
-    _initialSave,
-    _requestOrConnection,
-    _oldCell,
-  ) {
-    return true;
-  }
-  async canDelCell(_tableId, _rowId, _cellId, _connection) {
-    return true;
-  }
-  async canSetValue(
-    _valueId,
-    _value,
-    _initialSave,
-    _requestOrConnection,
-    _oldValue,
-  ) {
-    return true;
-  }
-  async canDelValue(_valueId, _connection) {
-    return true;
-  }
-}
-
-export {
-  TinyBasePartyKitServer,
-  broadcastTransactionChanges,
-  hasStoreInStorage,
-  loadStoreFromStorage,
-};