json-fs-query 3.2.0 → 3.3.1

package/dist/data/storage/removeDirectory.js

@@ -7,12 +7,18 @@ exports.removeDirectory = void 0;
 var _storagePath = require("./storagePath");
 var _nodeFiles = require("./nodeFiles");
 var _readCache = require("./readCache");
+var _writeSet = require("./writeSet");
 /**
- * Delete a folder of the database and everything in it; a folder that doesn't exist is left alone. Node only.
+ * Delete a folder of the database and everything in it; a folder that doesn't exist is left alone. During a statement
+ * it's removed with the statement's other changes (see withWriteSet), and reads in the statement already find
+ * everything in it gone. Node only.
  * @param path - A path inside the database, such as `__indexes/users`.
  */
 const removeDirectory = async path => {
   const location = (0, _storagePath.storagePath)(path);
+  if ((0, _writeSet.stageRemoveDirectory)(location)) {
+    return;
+  }
   // Forgotten before and after: a read that starts while rm runs would otherwise keep a removed file's old text
   (0, _readCache.cacheRemove)(location, true);
   await (0, _nodeFiles.nodeFiles)().rm(location, {

package/dist/data/storage/removeDirectory.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.removeDirectory=void 0;var _storagePath=require("./storagePath"),_nodeFiles=require("./nodeFiles"),_readCache=require("./readCache");const removeDirectory=async e=>{const r=(0,_storagePath.storagePath)(e);(0,_readCache.cacheRemove)(r,!0),await(0,_nodeFiles.nodeFiles)().rm(r,{recursive:!0,force:!0}),(0,_readCache.cacheRemove)(r,!0)};exports.removeDirectory=removeDirectory;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.removeDirectory=void 0;var _storagePath=require("./storagePath"),_nodeFiles=require("./nodeFiles"),_readCache=require("./readCache"),_writeSet=require("./writeSet");const removeDirectory=async e=>{const r=(0,_storagePath.storagePath)(e);(0,_writeSet.stageRemoveDirectory)(r)||((0,_readCache.cacheRemove)(r,!0),await(0,_nodeFiles.nodeFiles)().rm(r,{recursive:!0,force:!0}),(0,_readCache.cacheRemove)(r,!0))};exports.removeDirectory=removeDirectory;

package/dist/data/storage/removeFile.d.ts

@@ -1,5 +1,6 @@
 /**
- * Delete one file of the database. Node only.
+ * Delete one file of the database. During a statement the delete waits in its write set until the statement succeeds
+ * (see withWriteSet), and reads in the statement already find the file gone. Node only.
  * @param path - A path inside the database, such as `users/1.json`.
  * @throws {Error} When the file doesn't exist.
  */

package/dist/data/storage/removeFile.js

@@ -7,13 +7,22 @@ exports.removeFile = void 0;
 var _storagePath = require("./storagePath");
 var _nodeFiles = require("./nodeFiles");
 var _readCache = require("./readCache");
+var _writeSet = require("./writeSet");
 /**
- * Delete one file of the database. Node only.
+ * Delete one file of the database. During a statement the delete waits in its write set until the statement succeeds
+ * (see withWriteSet), and reads in the statement already find the file gone. Node only.
  * @param path - A path inside the database, such as `users/1.json`.
  * @throws {Error} When the file doesn't exist.
  */
 const removeFile = async path => {
   const location = (0, _storagePath.storagePath)(path);
+  const pending = (0, _writeSet.pendingFile)(location);
+  if (pending === null || pending === undefined && !require('fs').existsSync(location)) {
+    throw new Error(`ENOENT: no such file or directory, rm '${location}'`);
+  }
+  if ((0, _writeSet.stageRemove)(location)) {
+    return;
+  }
   // Forgotten before and after: a read that starts while rm runs would otherwise keep the file's old text
   (0, _readCache.cacheRemove)(location);
   await (0, _nodeFiles.nodeFiles)().rm(location);

package/dist/data/storage/removeFile.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.removeFile=void 0;var _storagePath=require("./storagePath"),_nodeFiles=require("./nodeFiles"),_readCache=require("./readCache");const removeFile=async e=>{const r=(0,_storagePath.storagePath)(e);(0,_readCache.cacheRemove)(r),await(0,_nodeFiles.nodeFiles)().rm(r),(0,_readCache.cacheRemove)(r)};exports.removeFile=removeFile;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.removeFile=void 0;var _storagePath=require("./storagePath"),_nodeFiles=require("./nodeFiles"),_readCache=require("./readCache"),_writeSet=require("./writeSet");const removeFile=async e=>{const r=(0,_storagePath.storagePath)(e),t=(0,_writeSet.pendingFile)(r);if(null===t||void 0===t&&!require("fs").existsSync(r))throw new Error(`ENOENT: no such file or directory, rm '${r}'`);(0,_writeSet.stageRemove)(r)||((0,_readCache.cacheRemove)(r),await(0,_nodeFiles.nodeFiles)().rm(r),(0,_readCache.cacheRemove)(r))};exports.removeFile=removeFile;

package/dist/data/storage/storagePath.js

@@ -20,6 +20,6 @@ function _interopRequireWildcard(t, r) { if (!r && t && t.__esModule) return t;
  */
 const storagePath = (path = '') => {
   const relativePath = jsEnv.isBrowser ? (0, _config.getSetting)('relativePath', '') : '';
-  return `${relativePath}${(0, _config.getSetting)('databasePath', 'database/')}${path}`;
+  return `${relativePath}${(0, _config.activeDatabasePath)()}${path}`;
 };
 exports.storagePath = storagePath;

package/dist/data/storage/storagePath.min.js

@@ -1 +1 @@
-"use strict";require("core-js/modules/esnext.weak-map.delete-all.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.storagePath=void 0;var e,jsEnv=_interopRequireWildcard(require("browser-or-node")),_config=require("../utilities/config");function _interopRequireWildcard(t,r){if(!r&&t&&t.__esModule)return t;var a,o,i=Object.defineProperty,s={__proto__:null,default:t};if(Object(t)!==t)return s;if(e||"function"!=typeof WeakMap||(e=new WeakMap),e){if(e.has(t))return e.get(t);e.set(t,s)}for(o in t)"default"!==o&&{}.hasOwnProperty.call(t,o)&&((a=i&&Object.getOwnPropertyDescriptor(t,o))&&(a.get||a.set)?i(s,o,a):s[o]=t[o]);return s}const storagePath=(e="")=>`${jsEnv.isBrowser?(0,_config.getSetting)("relativePath",""):""}${(0,_config.getSetting)("databasePath","database/")}${e}`;exports.storagePath=storagePath;
+"use strict";require("core-js/modules/esnext.weak-map.delete-all.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.storagePath=void 0;var e,jsEnv=_interopRequireWildcard(require("browser-or-node")),_config=require("../utilities/config");function _interopRequireWildcard(t,r){if(!r&&t&&t.__esModule)return t;var o,a,i=Object.defineProperty,s={__proto__:null,default:t};if(Object(t)!==t)return s;if(e||"function"!=typeof WeakMap||(e=new WeakMap),e){if(e.has(t))return e.get(t);e.set(t,s)}for(a in t)"default"!==a&&{}.hasOwnProperty.call(t,a)&&((o=i&&Object.getOwnPropertyDescriptor(t,a))&&(o.get||o.set)?i(s,a,o):s[a]=t[a]);return s}const storagePath=(e="")=>`${jsEnv.isBrowser?(0,_config.getSetting)("relativePath",""):""}${(0,_config.activeDatabasePath)()}${e}`;exports.storagePath=storagePath;

package/dist/data/storage/writeJson.d.ts

@@ -1,8 +1,17 @@
 /**
- * Write `content` to one file of the database as JSON (indented by 2 spaces), replacing the file if it exists. Its
- * folder must already exist (see makeDirectory). Node only.
+ * The text a file of the database holds for `content`: compact JSON, or indented by 2 spaces for `pretty`.
+ * @param content - Anything JSON.stringify accepts.
+ * @param format - Defaults to the configured format (see configure).
+ */
+export declare const jsonText: (content: any, format?: "compact" | "pretty") => string;
+/**
+ * Write `content` to one file of the database as JSON in the configured format (see jsonText), replacing the file if it
+ * exists. Its folder must already exist (see makeDirectory). The file is replaced whole or not at all (see
+ * writeAtomically). During a statement the write waits in its write set until the statement succeeds (see
+ * withWriteSet). Node only.
  * @param path - A path inside the database, such as `users.json`.
  * @param content - Anything JSON.stringify accepts.
+ * @param format - Defaults to the configured format (see configure).
  */
-export declare const writeJson: (path: string, content: any) => Promise<void>;
+export declare const writeJson: (path: string, content: any, format?: "compact" | "pretty") => Promise<void>;
 //# sourceMappingURL=writeJson.d.ts.map

package/dist/data/storage/writeJson.js

@@ -3,21 +3,35 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.writeJson = void 0;
+exports.writeJson = exports.jsonText = void 0;
 require("core-js/modules/es.json.stringify.js");
 var _storagePath = require("./storagePath");
-var _nodeFiles = require("./nodeFiles");
 var _readCache = require("./readCache");
+var _writeSet = require("./writeSet");
+var _config = require("../utilities/config");
 /**
- * Write `content` to one file of the database as JSON (indented by 2 spaces), replacing the file if it exists. Its
- * folder must already exist (see makeDirectory). Node only.
+ * The text a file of the database holds for `content`: compact JSON, or indented by 2 spaces for `pretty`.
+ * @param content - Anything JSON.stringify accepts.
+ * @param format - Defaults to the configured format (see configure).
+ */
+const jsonText = (content, format = (0, _config.getSetting)('format', 'compact')) => format === 'pretty' ? JSON.stringify(content, null, 2) : JSON.stringify(content);
+/**
+ * Write `content` to one file of the database as JSON in the configured format (see jsonText), replacing the file if it
+ * exists. Its folder must already exist (see makeDirectory). The file is replaced whole or not at all (see
+ * writeAtomically). During a statement the write waits in its write set until the statement succeeds (see
+ * withWriteSet). Node only.
  * @param path - A path inside the database, such as `users.json`.
  * @param content - Anything JSON.stringify accepts.
+ * @param format - Defaults to the configured format (see configure).
  */
-const writeJson = async (path, content) => {
+exports.jsonText = jsonText;
+const writeJson = async (path, content, format) => {
   const location = (0, _storagePath.storagePath)(path);
-  const text = JSON.stringify(content, null, 2);
-  await (0, _nodeFiles.nodeFiles)().writeFile(location, text);
+  const text = jsonText(content, format);
+  if ((0, _writeSet.stageWrite)(location, text)) {
+    return;
+  }
+  await (0, _writeSet.writeAtomically)(location, text);
   (0, _readCache.cacheWrite)(location, text);
 };
 exports.writeJson = writeJson;

package/dist/data/storage/writeJson.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.writeJson=void 0,require("core-js/modules/es.json.stringify.js");var _storagePath=require("./storagePath"),_nodeFiles=require("./nodeFiles"),_readCache=require("./readCache");const writeJson=async(e,r)=>{const s=(0,_storagePath.storagePath)(e),t=JSON.stringify(r,null,2);await(0,_nodeFiles.nodeFiles)().writeFile(s,t),(0,_readCache.cacheWrite)(s,t)};exports.writeJson=writeJson;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.writeJson=exports.jsonText=void 0,require("core-js/modules/es.json.stringify.js");var _storagePath=require("./storagePath"),_readCache=require("./readCache"),_writeSet=require("./writeSet"),_config=require("../utilities/config");const jsonText=(e,t=(0,_config.getSetting)("format","compact"))=>"pretty"===t?JSON.stringify(e,null,2):JSON.stringify(e);exports.jsonText=jsonText;const writeJson=async(e,t,r)=>{const s=(0,_storagePath.storagePath)(e),i=jsonText(t,r);(0,_writeSet.stageWrite)(s,i)||(await(0,_writeSet.writeAtomically)(s,i),(0,_readCache.cacheWrite)(s,i))};exports.writeJson=writeJson;

package/dist/data/storage/writeSet.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Write `text` to `location` so that the file is always either its old or its new content, never half of one: the
+ * text goes to a temporary file next to it, which then replaces it (a rename is atomic within one folder). That holds
+ * when the process stops part way (a crash, a kill); there's no fsync, so after a power cut the file system may still
+ * lose a recent write. When the write or rename fails, the temporary file is removed and the original error thrown.
+ * @param location
+ * @param text
+ */
+export declare const writeAtomically: (location: string, text: string) => Promise<void>;
+/**
+ * Run one statement's `task` with a write set for the configured database: its writes and deletes are collected in
+ * memory, and reads during the task see them (see pendingFile). When the task finishes, everything it changed is put in
+ * storage at once, each file written once however many times the task changed it. When it throws, nothing it changed
+ * reaches storage: a multi-row insert or update whose third row fails leaves the first two unwritten too.
+ *
+ * A task inside another (a public call made from inside a statement) joins the outer write set. Node only: in a
+ * browser nothing can be written, so the task just runs.
+ * @param task
+ */
+export declare const withWriteSet: <T>(task: () => Promise<T>) => Promise<T>;
+/**
+ * What the running statement has done to the file at `location`: its pending text, `null` if the statement deleted it
+ * (or a folder it was in), or `undefined` when the statement hasn't touched it (or no statement is running).
+ * @param location - The file's full location (see storagePath).
+ */
+export declare const pendingFile: (location: string) => string | null | undefined;
+/**
+ * Whether the file or folder at `location` exists as far as the running statement knows: true for a file it wrote, a
+ * folder it made, or a folder holding something it wrote or made; false for a file it deleted or anything in a folder
+ * it removed; `undefined` when the statement hasn't touched it (or no statement is running), so storage decides.
+ * @param location - The full location (see storagePath).
+ */
+export declare const pendingExists: (location: string) => boolean | undefined;
+/**
+ * The files under `folder` as the running statement sees them: `onDisk` (full locations) without what it deleted or
+ * removed, plus what it wrote there. `onDisk` as it is when no statement is running.
+ * @param folder - The folder's full location (see storagePath).
+ * @param onDisk - The full locations of the files under it in storage.
+ */
+export declare const pendingListing: (folder: string, onDisk: string[]) => string[];
+/**
+ * Keep `text` as the new content of `location` in the running statement's write set. False when no statement is
+ * running, so the caller writes to storage itself.
+ * @param location
+ * @param text
+ */
+export declare const stageWrite: (location: string, text: string) => boolean;
+/**
+ * Mark `location` deleted in the running statement's write set. False when no statement is running.
+ * @param location
+ */
+export declare const stageRemove: (location: string) => boolean;
+/**
+ * Note a folder to create in the running statement's write set. False when no statement is running.
+ * @param location
+ */
+export declare const stageMakeDirectory: (location: string) => boolean;
+/**
+ * Mark a folder and everything in it removed in the running statement's write set: what the statement wrote or
+ * created inside it so far is dropped with it. False when no statement is running.
+ * @param location
+ */
+export declare const stageRemoveDirectory: (location: string) => boolean;
+//# sourceMappingURL=writeSet.d.ts.map

package/dist/data/storage/writeSet.js

@@ -0,0 +1,306 @@
+"use strict";
+
+require("core-js/modules/esnext.weak-map.delete-all.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.writeAtomically = exports.withWriteSet = exports.stageWrite = exports.stageRemoveDirectory = exports.stageRemove = exports.stageMakeDirectory = exports.pendingListing = exports.pendingFile = exports.pendingExists = void 0;
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.filter.js");
+require("core-js/modules/esnext.map.delete-all.js");
+require("core-js/modules/esnext.map.every.js");
+require("core-js/modules/esnext.map.filter.js");
+require("core-js/modules/esnext.map.find.js");
+require("core-js/modules/esnext.map.find-key.js");
+require("core-js/modules/esnext.map.includes.js");
+require("core-js/modules/esnext.map.key-of.js");
+require("core-js/modules/esnext.map.map-keys.js");
+require("core-js/modules/esnext.map.map-values.js");
+require("core-js/modules/esnext.map.merge.js");
+require("core-js/modules/esnext.map.reduce.js");
+require("core-js/modules/esnext.map.some.js");
+require("core-js/modules/esnext.map.update.js");
+require("core-js/modules/esnext.set.add-all.js");
+require("core-js/modules/esnext.set.delete-all.js");
+require("core-js/modules/esnext.set.difference.js");
+require("core-js/modules/esnext.set.every.js");
+require("core-js/modules/esnext.set.filter.js");
+require("core-js/modules/esnext.set.find.js");
+require("core-js/modules/esnext.set.intersection.js");
+require("core-js/modules/esnext.set.is-disjoint-from.js");
+require("core-js/modules/esnext.set.is-subset-of.js");
+require("core-js/modules/esnext.set.is-superset-of.js");
+require("core-js/modules/esnext.set.join.js");
+require("core-js/modules/esnext.set.map.js");
+require("core-js/modules/esnext.set.reduce.js");
+require("core-js/modules/esnext.set.some.js");
+require("core-js/modules/esnext.set.symmetric-difference.js");
+require("core-js/modules/esnext.set.union.js");
+var jsEnv = _interopRequireWildcard(require("browser-or-node"));
+var _storagePath = require("./storagePath");
+var _nodeFiles = require("./nodeFiles");
+var _readCache = require("./readCache");
+var e;
+function _interopRequireWildcard(t, r) { if (!r && t && t.__esModule) return t; var n, a, o = Object.defineProperty, f = { __proto__: null, default: t }; if (Object(t) !== t) return f; if (e || "function" != typeof WeakMap || (e = new WeakMap()), e) { if (e.has(t)) return e.get(t); e.set(t, f); } for (a in t) "default" !== a && {}.hasOwnProperty.call(t, a) && ((n = o && Object.getOwnPropertyDescriptor(t, a)) && (n.get || n.set) ? o(f, a, n) : f[a] = t[a]); return f; }
+const writeSets = new Map();
+/**
+ * The write set of the database configured now (by its location, see storagePath), if a statement on it is running.
+ */
+const currentWriteSet = () => writeSets.get((0, _storagePath.storagePath)());
+const folderPrefix = location => location.endsWith('/') ? location : `${location}/`;
+/**
+ * Whether `location` is inside one of the folders `folders` (or is one of them).
+ * @param location
+ * @param folders
+ */
+const insideAny = (location, folders) => {
+  for (const folder of folders) {
+    if (location === folder || location.startsWith(folderPrefix(folder))) {
+      return true;
+    }
+  }
+  return false;
+};
+/**
+ * Write `text` to `location` so that the file is always either its old or its new content, never half of one: the
+ * text goes to a temporary file next to it, which then replaces it (a rename is atomic within one folder). That holds
+ * when the process stops part way (a crash, a kill); there's no fsync, so after a power cut the file system may still
+ * lose a recent write. When the write or rename fails, the temporary file is removed and the original error thrown.
+ * @param location
+ * @param text
+ */
+const writeAtomically = async (location, text) => {
+  const temporary = `${location}.${crypto.randomUUID()}.tmp`;
+  const files = (0, _nodeFiles.nodeFiles)();
+  try {
+    await files.writeFile(temporary, text);
+    await files.rename(temporary, location);
+  } catch (error) {
+    // Cleaning up is best effort: its own failure must not hide why the write failed
+    await files.rm(temporary, {
+      force: true
+    }).catch(() => undefined);
+    throw error;
+  }
+};
+/**
+ * Remove a folder from storage and from the read cache.
+ * @param location
+ */
+exports.writeAtomically = writeAtomically;
+const removeFolder = async location => {
+  (0, _readCache.cacheRemove)(location, true);
+  await (0, _nodeFiles.nodeFiles)().rm(location, {
+    recursive: true,
+    force: true
+  });
+  (0, _readCache.cacheRemove)(location, true);
+};
+/**
+ * Put a write set's changes in storage, in an order where a stop part way leaves at worst an unlisted file or folder
+ * behind, never a record file or index that lists something missing:
+ * - folders the statement removed and then wrote into again (none today), so the new content survives;
+ * - new folders;
+ * - every written file once, in the order each was last written (a record's entry list and indexes come after the
+ *   entries they list);
+ * - deleted files (a delete has already rewritten the record file and indexes; `drop` removes its record file here);
+ * - the other removed folders (`drop`'s entries and indexes, after its record file is gone).
+ * Each change also goes into the read cache, which holds what's in storage.
+ * @param writeSet
+ */
+const commit = async writeSet => {
+  const files = (0, _nodeFiles.nodeFiles)();
+  const writtenInto = folder => {
+    const prefix = folderPrefix(folder);
+    return [...writeSet.madeFolders].some(made => made === folder || made.startsWith(prefix)) || [...writeSet.files].some(([location, text]) => text !== null && location.startsWith(prefix));
+  };
+  const removedFolders = [...writeSet.removedFolders];
+  for (const folder of removedFolders.filter(writtenInto)) {
+    await removeFolder(folder);
+  }
+  for (const folder of writeSet.madeFolders) {
+    await files.mkdir(folder, {
+      recursive: true
+    });
+  }
+  for (const [location, text] of writeSet.files) {
+    if (text !== null) {
+      await writeAtomically(location, text);
+      (0, _readCache.cacheWrite)(location, text);
+    }
+  }
+  for (const [location, text] of writeSet.files) {
+    if (text === null) {
+      (0, _readCache.cacheRemove)(location);
+      await files.rm(location, {
+        force: true
+      });
+      (0, _readCache.cacheRemove)(location);
+    }
+  }
+  for (const folder of removedFolders.filter(folder => !writtenInto(folder))) {
+    await removeFolder(folder);
+  }
+};
+/**
+ * Run one statement's `task` with a write set for the configured database: its writes and deletes are collected in
+ * memory, and reads during the task see them (see pendingFile). When the task finishes, everything it changed is put in
+ * storage at once, each file written once however many times the task changed it. When it throws, nothing it changed
+ * reaches storage: a multi-row insert or update whose third row fails leaves the first two unwritten too.
+ *
+ * A task inside another (a public call made from inside a statement) joins the outer write set. Node only: in a
+ * browser nothing can be written, so the task just runs.
+ * @param task
+ */
+const withWriteSet = async task => {
+  const database = (0, _storagePath.storagePath)();
+  if (!jsEnv.isNode || writeSets.has(database)) {
+    return task();
+  }
+  const writeSet = {
+    files: new Map(),
+    madeFolders: new Set(),
+    removedFolders: new Set()
+  };
+  writeSets.set(database, writeSet);
+  let result;
+  try {
+    result = await task();
+  } finally {
+    writeSets.delete(database);
+  }
+  await commit(writeSet);
+  return result;
+};
+/**
+ * What the running statement has done to the file at `location`: its pending text, `null` if the statement deleted it
+ * (or a folder it was in), or `undefined` when the statement hasn't touched it (or no statement is running).
+ * @param location - The file's full location (see storagePath).
+ */
+exports.withWriteSet = withWriteSet;
+const pendingFile = location => {
+  const writeSet = currentWriteSet();
+  if (!writeSet) {
+    return undefined;
+  }
+  if (writeSet.files.has(location)) {
+    return writeSet.files.get(location);
+  }
+  return insideAny(location, writeSet.removedFolders) ? null : undefined;
+};
+/**
+ * Whether the file or folder at `location` exists as far as the running statement knows: true for a file it wrote, a
+ * folder it made, or a folder holding something it wrote or made; false for a file it deleted or anything in a folder
+ * it removed; `undefined` when the statement hasn't touched it (or no statement is running), so storage decides.
+ * @param location - The full location (see storagePath).
+ */
+exports.pendingFile = pendingFile;
+const pendingExists = location => {
+  const writeSet = currentWriteSet();
+  if (!writeSet) {
+    return undefined;
+  }
+  if (writeSet.files.has(location)) {
+    return writeSet.files.get(location) !== null;
+  }
+  const prefix = folderPrefix(location);
+  const madeInside = path => path === location || path.startsWith(prefix);
+  if ([...writeSet.madeFolders].some(madeInside) || [...writeSet.files].some(([path, text]) => text !== null && path.startsWith(prefix))) {
+    return true;
+  }
+  return insideAny(location, writeSet.removedFolders) ? false : undefined;
+};
+/**
+ * The files under `folder` as the running statement sees them: `onDisk` (full locations) without what it deleted or
+ * removed, plus what it wrote there. `onDisk` as it is when no statement is running.
+ * @param folder - The folder's full location (see storagePath).
+ * @param onDisk - The full locations of the files under it in storage.
+ */
+exports.pendingExists = pendingExists;
+const pendingListing = (folder, onDisk) => {
+  const writeSet = currentWriteSet();
+  if (!writeSet) {
+    return onDisk;
+  }
+  const prefix = folderPrefix(folder);
+  const listed = new Set(onDisk.filter(location => !insideAny(location, writeSet.removedFolders)));
+  for (const [location, text] of writeSet.files) {
+    if (location.startsWith(prefix)) {
+      if (text === null) {
+        listed.delete(location);
+      } else {
+        listed.add(location);
+      }
+    }
+  }
+  return [...listed];
+};
+/**
+ * Keep `text` as the new content of `location` in the running statement's write set. False when no statement is
+ * running, so the caller writes to storage itself.
+ * @param location
+ * @param text
+ */
+exports.pendingListing = pendingListing;
+const stageWrite = (location, text) => {
+  const writeSet = currentWriteSet();
+  if (!writeSet) {
+    return false;
+  }
+  // Moved to the end, so files are written in the order they were last changed
+  writeSet.files.delete(location);
+  writeSet.files.set(location, text);
+  return true;
+};
+/**
+ * Mark `location` deleted in the running statement's write set. False when no statement is running.
+ * @param location
+ */
+exports.stageWrite = stageWrite;
+const stageRemove = location => {
+  const writeSet = currentWriteSet();
+  if (!writeSet) {
+    return false;
+  }
+  writeSet.files.delete(location);
+  writeSet.files.set(location, null);
+  return true;
+};
+/**
+ * Note a folder to create in the running statement's write set. False when no statement is running.
+ * @param location
+ */
+exports.stageRemove = stageRemove;
+const stageMakeDirectory = location => {
+  const writeSet = currentWriteSet();
+  if (!writeSet) {
+    return false;
+  }
+  writeSet.madeFolders.add(location);
+  return true;
+};
+/**
+ * Mark a folder and everything in it removed in the running statement's write set: what the statement wrote or
+ * created inside it so far is dropped with it. False when no statement is running.
+ * @param location
+ */
+exports.stageMakeDirectory = stageMakeDirectory;
+const stageRemoveDirectory = location => {
+  const writeSet = currentWriteSet();
+  if (!writeSet) {
+    return false;
+  }
+  for (const file of [...writeSet.files.keys()]) {
+    if (insideAny(file, new Set([location]))) {
+      writeSet.files.delete(file);
+    }
+  }
+  for (const folder of [...writeSet.madeFolders]) {
+    if (insideAny(folder, new Set([location]))) {
+      writeSet.madeFolders.delete(folder);
+    }
+  }
+  writeSet.removedFolders.add(location);
+  return true;
+};
+exports.stageRemoveDirectory = stageRemoveDirectory;

package/dist/data/storage/writeSet.min.js

@@ -0,0 +1 @@
+"use strict";require("core-js/modules/esnext.weak-map.delete-all.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.writeAtomically=exports.withWriteSet=exports.stageWrite=exports.stageRemoveDirectory=exports.stageRemove=exports.stageMakeDirectory=exports.pendingListing=exports.pendingFile=exports.pendingExists=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.js"),require("core-js/modules/esnext.map.delete-all.js"),require("core-js/modules/esnext.map.every.js"),require("core-js/modules/esnext.map.filter.js"),require("core-js/modules/esnext.map.find.js"),require("core-js/modules/esnext.map.find-key.js"),require("core-js/modules/esnext.map.includes.js"),require("core-js/modules/esnext.map.key-of.js"),require("core-js/modules/esnext.map.map-keys.js"),require("core-js/modules/esnext.map.map-values.js"),require("core-js/modules/esnext.map.merge.js"),require("core-js/modules/esnext.map.reduce.js"),require("core-js/modules/esnext.map.some.js"),require("core-js/modules/esnext.map.update.js"),require("core-js/modules/esnext.set.add-all.js"),require("core-js/modules/esnext.set.delete-all.js"),require("core-js/modules/esnext.set.difference.js"),require("core-js/modules/esnext.set.every.js"),require("core-js/modules/esnext.set.filter.js"),require("core-js/modules/esnext.set.find.js"),require("core-js/modules/esnext.set.intersection.js"),require("core-js/modules/esnext.set.is-disjoint-from.js"),require("core-js/modules/esnext.set.is-subset-of.js"),require("core-js/modules/esnext.set.is-superset-of.js"),require("core-js/modules/esnext.set.join.js"),require("core-js/modules/esnext.set.map.js"),require("core-js/modules/esnext.set.reduce.js"),require("core-js/modules/esnext.set.some.js"),require("core-js/modules/esnext.set.symmetric-difference.js"),require("core-js/modules/esnext.set.union.js");var e,jsEnv=_interopRequireWildcard(require("browser-or-node")),_storagePath=require("./storagePath"),_nodeFiles=require("./nodeFiles"),_readCache=require("./readCache");function _interopRequireWildcard(r,s){if(!s&&r&&r.__esModule)return r;var t,o,i=Object.defineProperty,n={__proto__:null,default:r};if(Object(r)!==r)return n;if(e||"function"!=typeof WeakMap||(e=new WeakMap),e){if(e.has(r))return e.get(r);e.set(r,n)}for(o in r)"default"!==o&&{}.hasOwnProperty.call(r,o)&&((t=i&&Object.getOwnPropertyDescriptor(r,o))&&(t.get||t.set)?i(n,o,t):n[o]=r[o]);return n}const writeSets=new Map,currentWriteSet=()=>writeSets.get((0,_storagePath.storagePath)()),folderPrefix=e=>e.endsWith("/")?e:`${e}/`,insideAny=(e,r)=>{for(const s of r)if(e===s||e.startsWith(folderPrefix(s)))return!0;return!1},writeAtomically=async(e,r)=>{const s=`${e}.${crypto.randomUUID()}.tmp`,t=(0,_nodeFiles.nodeFiles)();try{await t.writeFile(s,r),await t.rename(s,e)}catch(e){throw await t.rm(s,{force:!0}).catch((()=>{})),e}};exports.writeAtomically=writeAtomically;const removeFolder=async e=>{(0,_readCache.cacheRemove)(e,!0),await(0,_nodeFiles.nodeFiles)().rm(e,{recursive:!0,force:!0}),(0,_readCache.cacheRemove)(e,!0)},commit=async e=>{const r=(0,_nodeFiles.nodeFiles)(),s=r=>{const s=folderPrefix(r);return[...e.madeFolders].some((e=>e===r||e.startsWith(s)))||[...e.files].some((([e,r])=>null!==r&&e.startsWith(s)))},t=[...e.removedFolders];for(const e of t.filter(s))await removeFolder(e);for(const s of e.madeFolders)await r.mkdir(s,{recursive:!0});for(const[r,s]of e.files)null!==s&&(await writeAtomically(r,s),(0,_readCache.cacheWrite)(r,s));for(const[s,t]of e.files)null===t&&((0,_readCache.cacheRemove)(s),await r.rm(s,{force:!0}),(0,_readCache.cacheRemove)(s));for(const e of t.filter((e=>!s(e))))await removeFolder(e)},withWriteSet=async e=>{const r=(0,_storagePath.storagePath)();if(!jsEnv.isNode||writeSets.has(r))return e();const s={files:new Map,madeFolders:new Set,removedFolders:new Set};let t;writeSets.set(r,s);try{t=await e()}finally{writeSets.delete(r)}return await commit(s),t};exports.withWriteSet=withWriteSet;const pendingFile=e=>{const r=currentWriteSet();if(r)return r.files.has(e)?r.files.get(e):insideAny(e,r.removedFolders)?null:void 0};exports.pendingFile=pendingFile;const pendingExists=e=>{const r=currentWriteSet();if(!r)return;if(r.files.has(e))return null!==r.files.get(e);const s=folderPrefix(e);return!(![...r.madeFolders].some((r=>r===e||r.startsWith(s)))&&![...r.files].some((([e,r])=>null!==r&&e.startsWith(s))))||!insideAny(e,r.removedFolders)&&void 0};exports.pendingExists=pendingExists;const pendingListing=(e,r)=>{const s=currentWriteSet();if(!s)return r;const t=folderPrefix(e),o=new Set(r.filter((e=>!insideAny(e,s.removedFolders))));for(const[e,r]of s.files)e.startsWith(t)&&(null===r?o.delete(e):o.add(e));return[...o]};exports.pendingListing=pendingListing;const stageWrite=(e,r)=>{const s=currentWriteSet();return!!s&&(s.files.delete(e),s.files.set(e,r),!0)};exports.stageWrite=stageWrite;const stageRemove=e=>{const r=currentWriteSet();return!!r&&(r.files.delete(e),r.files.set(e,null),!0)};exports.stageRemove=stageRemove;const stageMakeDirectory=e=>{const r=currentWriteSet();return!!r&&(r.madeFolders.add(e),!0)};exports.stageMakeDirectory=stageMakeDirectory;const stageRemoveDirectory=e=>{const r=currentWriteSet();if(!r)return!1;for(const s of[...r.files.keys()])insideAny(s,new Set([e]))&&r.files.delete(s);for(const s of[...r.madeFolders])insideAny(s,new Set([e]))&&r.madeFolders.delete(s);return r.removedFolders.add(e),!0};exports.stageRemoveDirectory=stageRemoveDirectory;

package/dist/data/utilities/config.d.ts

@@ -2,7 +2,33 @@ export type RuntimeSettings = {
     databasePath: string;
     relativePath: string;
     enforceForeignKeys: boolean;
+    readConcurrency: number;
+    format: 'compact' | 'pretty';
+    packedReads?: boolean;
+    databasesPath?: string;
+    database?: string;
 };
+/**
+ * The folder of the database in use: `<databasesPath>/<database>/` once both are configured (see configure and the
+ * `use` statement), otherwise databasePath, as before there could be several.
+ */
+export declare const activeDatabasePath: () => string;
+/**
+ * The folder whose calls are queued together (see withDatabaseLock): with several databases, all of them, since a
+ * call can switch between them (`use`) part way; otherwise the one database.
+ */
+export declare const lockPath: () => string;
+/**
+ * The folder holding the databases, for create database, drop database, use and show databases.
+ * @throws {Error} When databasesPath isn't configured.
+ */
+export declare const databasesFolder: () => string;
+/**
+ * Switch the database in use, from inside a call (the `use` statement, which holds the lock for every database in
+ * databasesPath, so no other call is running): configure() refuses to while calls run.
+ * @param name
+ */
+export declare const switchDatabase: (name: string) => void;
 /**
  * The folder a databasePath points to, so that `database/`, `./database` and its absolute path count as one database.
  * Node only (only Node calls are counted, see trackDatabaseCall).
@@ -26,9 +52,20 @@ export declare const trackDatabaseCall: () => (() => void);
  * mirroring MySQL's own foreign_key_checks setting, which is also toggleable rather than always
  * on, since strict enforcement isn't always what every consumer wants.
  *
+ * readConcurrency (default 16) is how many entry files a read has in flight at once (see retrieveFiles): in a browser,
+ * how many requests run together.
+ *
+ * format (default 'compact') is how files are written: 'compact' (no whitespace: smaller files that parse faster) or
+ * 'pretty' (indented by 2 spaces, for reading data in diffs). Either is read; formatDatabase rewrites a whole database
+ * in one.
+ *
+ * packedReads (default: true in a browser, false in Node) is whether reads use a record's packed file (see
+ * packDatabase) when it has one that matches the record, instead of reading each entry file.
+ *
  * Changing databasePath while calls are still running or queued throws (see trackDatabaseCall): await them first.
  * @param newSettings
  * @throws {Error} When databasePath would point to another folder while database calls are in progress.
+ * @throws {Error} When format is neither 'compact' nor 'pretty'.
  */
 export declare const configure: (newSettings: Partial<RuntimeSettings>) => void;
 /**