tinybase 5.0.0-beta.17 → 5.0.0-beta.19

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

@@ -1,324 +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 isArray = (thing) => Array.isArray(thing);
-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 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 objSize = (obj) => size(objIds(obj));
-const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
-
-const jsonStringWithMap = (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 : jsonStringWithMap(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, hadExistingValue) => {
-  if (!collHas(map, key)) {
-    mapSet(map, key, getDefaultValue());
-  }
-  return mapGet(map, key);
-};
-
-const scheduleRunning = mapNew();
-const scheduleActions = mapNew();
-const getStoreFunctions = (supportedStoreType = 1, store) =>
-  supportedStoreType > 1 && 'merge' in store
-    ? [
-        1,
-        store.getMergeableContent,
-        store.getTransactionMergeableChanges,
-        ([[changedTables], [changedValues]]) =>
-          !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
-        store.setDefaultContent,
-      ]
-    : supportedStoreType != 2
-      ? [
-          0,
-          store.getContent,
-          store.getTransactionChanges,
-          ([changedTables, changedValues]) =>
-            !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
-          store.setContent,
-        ]
-      : /* istanbul ignore next */
-        0;
-const createCustomPersister = (
-  store,
-  getPersisted,
-  setPersisted,
-  addPersisterListener,
-  delPersisterListener,
-  onIgnoredError,
-  supportedStoreType,
-  extra = {},
-  scheduleId = [],
-) => {
-  let loadSave = 0;
-  let loads = 0;
-  let saves = 0;
-  let action;
-  let autoLoadHandle;
-  let autoSaveListenerId;
-  mapEnsure(scheduleRunning, scheduleId, () => 0);
-  mapEnsure(scheduleActions, scheduleId, () => []);
-  const [
-    isMergeableStore,
-    getContent,
-    getChanges,
-    hasChanges,
-    setDefaultContent,
-  ] = getStoreFunctions(supportedStoreType, store);
-  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 (loadSave != 2) {
-      loadSave = 1;
-      {
-        loads++;
-      }
-      await schedule(async () => {
-        try {
-          setContentOrChanges(await getPersisted());
-        } catch (error) {
-          onIgnoredError?.(error);
-          if (initialContent) {
-            setDefaultContent(initialContent);
-          }
-        }
-        loadSave = 0;
-      });
-    }
-    return persister;
-  };
-  const startAutoLoad = async (initialContent) => {
-    await stopAutoLoad().load(initialContent);
-    autoLoadHandle = addPersisterListener(async (content, changes) => {
-      if (changes || content) {
-        /* istanbul ignore else */
-        if (loadSave != 2) {
-          loadSave = 1;
-          {
-            loads++;
-          }
-          setContentOrChanges(changes ?? content);
-          loadSave = 0;
-        }
-      } else {
-        await load();
-      }
-    });
-    return persister;
-  };
-  const stopAutoLoad = () => {
-    if (autoLoadHandle) {
-      delPersisterListener(autoLoadHandle);
-      autoLoadHandle = void 0;
-    }
-    return persister;
-  };
-  const isAutoLoading = () => !isUndefined(autoLoadHandle);
-  const save = async (changes) => {
-    /* istanbul ignore else */
-    if (loadSave != 1) {
-      loadSave = 2;
-      {
-        saves++;
-      }
-      await schedule(async () => {
-        try {
-          await setPersisted(getContent, changes);
-        } catch (error) {
-          /* istanbul ignore next */
-          onIgnoredError?.(error);
-        }
-        loadSave = 0;
-      });
-    }
-    return persister;
-  };
-  const startAutoSave = async () => {
-    await stopAutoSave().save();
-    autoSaveListenerId = store.addDidFinishTransactionListener(() => {
-      const changes = getChanges();
-      if (hasChanges(changes)) {
-        save(changes);
-      }
-    });
-    return persister;
-  };
-  const stopAutoSave = () => {
-    ifNotUndefined(autoSaveListenerId, store.delListener);
-    autoSaveListenerId = void 0;
-    return persister;
-  };
-  const isAutoSaving = () => !isUndefined(autoSaveListenerId);
-  const schedule = async (...actions) => {
-    arrayPush(mapGet(scheduleActions, scheduleId), ...actions);
-    await run();
-    return persister;
-  };
-  const getStore = () => store;
-  const destroy = () => stopAutoLoad().stopAutoSave();
-  const getStats = () => ({loads, saves});
-  const persister = {
-    load,
-    startAutoLoad,
-    stopAutoLoad,
-    isAutoLoading,
-    save,
-    startAutoSave,
-    stopAutoSave,
-    isAutoSaving,
-    schedule,
-    getStore,
-    destroy,
-    getStats,
-    ...extra,
-  };
-  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: jsonStringWithMap(content)} : {}),
-        mode: 'cors',
-        cache: 'no-store',
-      })
-    ).json();
-  const getPersisted = async () => await getOrSetStore();
-  const setPersisted = async (getContent, changes) => {
-    if (changes) {
-      connection.send(construct(messagePrefix, SET_CHANGES, changes));
-    } 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,
-    1,
-    {getConnection: () => connection},
-  );
-};
-
-export {createPartyKitPersister};

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

@@ -1,284 +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 objHas = (obj, id) => id in obj;
-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 jsonStringWithMap = (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 : jsonStringWithMap(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 broadcastChanges = async (server, changes, without) =>
-  server.party.broadcast(
-    construct(server.config.messagePrefix, SET_CHANGES, changes),
-    without,
-  );
-const saveStore = async (that, changes, 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(changes[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(changes[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(jsonStringWithMap(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
-          ? jsonStringWithMap(
-              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);
-          broadcastChanges(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,
-  broadcastChanges,
-  hasStoreInStorage,
-  loadStoreFromStorage,
-};