json-fs-query 3.1.4 → 3.3.0

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/compareAs.d.ts

@@ -8,6 +8,7 @@
  * @param value
  */
 export declare const compareAs: (type: string | undefined, value: any) => any;
+export declare const comparableTypes: string[];
 /**
  * Whether two values are equal for a field of the given declared type: both are normalized to
  * that type (see compareAs) and compared strictly. A field with no declared type, or one that

package/dist/data/utilities/compareAs.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.sameValue = exports.compareAs = void 0;
+exports.sameValue = exports.compareAs = exports.comparableTypes = void 0;
 require("core-js/modules/es.array.includes.js");
 /**
  * Normalize a value to a field's declared type for an equality comparison - never written back,
@@ -39,7 +39,7 @@ const compareAs = (type, value) => {
   }
 };
 exports.compareAs = compareAs;
-const comparableTypes = ['string', 'int', 'boolean'];
+const comparableTypes = exports.comparableTypes = ['string', 'int', 'boolean'];
 /**
  * Whether two values are equal for a field of the given declared type: both are normalized to
  * that type (see compareAs) and compared strictly. A field with no declared type, or one that

package/dist/data/utilities/compareAs.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.sameValue=exports.compareAs=void 0,require("core-js/modules/es.array.includes.js");const compareAs=(e,r)=>{if(null==r)return r;switch(e){case"string":return"object"==typeof r?r:String(r);case"int":{const e=Number(r);return Number.isNaN(e)?r:e}case"boolean":return"true"===r||"false"!==r&&r;default:return r}};exports.compareAs=compareAs;const comparableTypes=["string","int","boolean"],sameValue=(e,r,s)=>comparableTypes.includes(e)?compareAs(e,r)===compareAs(e,s):r==s;exports.sameValue=sameValue;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.sameValue=exports.compareAs=exports.comparableTypes=void 0,require("core-js/modules/es.array.includes.js");const compareAs=(e,r)=>{if(null==r)return r;switch(e){case"string":return"object"==typeof r?r:String(r);case"int":{const e=Number(r);return Number.isNaN(e)?r:e}case"boolean":return"true"===r||"false"!==r&&r;default:return r}};exports.compareAs=compareAs;const comparableTypes=exports.comparableTypes=["string","int","boolean"],sameValue=(e,r,s)=>comparableTypes.includes(e)?compareAs(e,r)===compareAs(e,s):r==s;exports.sameValue=sameValue;

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;
 /**

package/dist/data/utilities/config.js

@@ -3,21 +3,61 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.trackDatabaseCall = exports.resolveDatabasePath = exports.getSetting = exports.configure = void 0;
+exports.trackDatabaseCall = exports.switchDatabase = exports.resolveDatabasePath = exports.lockPath = exports.getSetting = exports.databasesFolder = exports.configure = exports.activeDatabasePath = void 0;
+require("core-js/modules/es.json.stringify.js");
 const defaults = {
   databasePath: 'database/',
   relativePath: '',
-  enforceForeignKeys: true
+  enforceForeignKeys: true,
+  readConcurrency: 16,
+  format: 'compact'
 };
 let settings = {
   ...defaults
 };
 let activeCalls = 0;
+const databaseNameMatch = /^[a-z0-9_-]+$/i;
+const withSlash = path => path.endsWith('/') ? path : `${path}/`;
+/**
+ * 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.
+ */
+const activeDatabasePath = () => settings.databasesPath && settings.database ? `${withSlash(settings.databasesPath)}${settings.database}/` : getSetting('databasePath', 'database/');
+/**
+ * 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.
+ */
+exports.activeDatabasePath = activeDatabasePath;
+const lockPath = () => settings.databasesPath ? withSlash(settings.databasesPath) : activeDatabasePath();
+/**
+ * The folder holding the databases, for create database, drop database, use and show databases.
+ * @throws {Error} When databasesPath isn't configured.
+ */
+exports.lockPath = lockPath;
+const databasesFolder = () => {
+  if (!settings.databasesPath) {
+    throw new Error("Several databases need a folder to hold them: configure({ databasesPath: 'databases/' }) first");
+  }
+  return withSlash(settings.databasesPath);
+};
+/**
+ * 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
+ */
+exports.databasesFolder = databasesFolder;
+const switchDatabase = name => {
+  settings = {
+    ...settings,
+    database: name
+  };
+};
 /**
  * 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).
  * @param databasePath
  */
+exports.switchDatabase = switchDatabase;
 const resolveDatabasePath = databasePath => require('path').resolve(databasePath);
 /**
  * Count a database call (taken by withDatabaseLock as soon as a call is queued) until the returned function is called.
@@ -46,19 +86,51 @@ const trackDatabaseCall = () => {
  * 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'.
  */
 exports.trackDatabaseCall = trackDatabaseCall;
 const configure = newSettings => {
-  if (activeCalls > 0 && typeof newSettings.databasePath !== 'undefined' && resolveDatabasePath(newSettings.databasePath) !== resolveDatabasePath(settings.databasePath)) {
-    throw new Error(`Can't change databasePath while ${activeCalls} database call(s) are still running or queued: await them first`);
+  if (typeof newSettings.format !== 'undefined' && newSettings.format !== 'compact' && newSettings.format !== 'pretty') {
+    throw new Error(`Unknown format "${newSettings.format}": use 'compact' or 'pretty'`);
   }
-  settings = {
+  if (typeof newSettings.database !== 'undefined' && newSettings.database !== null && !databaseNameMatch.test(newSettings.database)) {
+    throw new Error(`Invalid database name ${JSON.stringify(newSettings.database)}: names use letters, digits, _ and - only`);
+  }
+  const next = {
     ...settings,
     ...newSettings
   };
+  if (next.database && !next.databasesPath) {
+    throw new Error("A database name needs the folder that holds the databases: configure({ databasesPath: 'databases/', database: '...' })");
+  }
+  if (activeCalls > 0) {
+    const before = {
+      active: resolveDatabasePath(activeDatabasePath()),
+      lock: resolveDatabasePath(lockPath())
+    };
+    const previous = settings;
+    settings = next;
+    const changed = resolveDatabasePath(activeDatabasePath()) !== before.active || resolveDatabasePath(lockPath()) !== before.lock;
+    settings = previous;
+    if (changed) {
+      const named = ['databasePath', 'databasesPath', 'database'].filter(key => typeof newSettings[key] !== 'undefined').join(' / ');
+      throw new Error(`Can't change ${named} while ${activeCalls} database call(s) are still running or queued: await them first`);
+    }
+  }
+  settings = next;
 };
 /**
  * Read one runtime setting, falling back to the given default if it was never configured. This is

package/dist/data/utilities/config.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.trackDatabaseCall=exports.resolveDatabasePath=exports.getSetting=exports.configure=void 0;const defaults={databasePath:"database/",relativePath:"",enforceForeignKeys:!0};let settings={...defaults},activeCalls=0;const resolveDatabasePath=t=>require("path").resolve(t);exports.resolveDatabasePath=resolveDatabasePath;const trackDatabaseCall=()=>{activeCalls++;let t=!1;return()=>{t||(t=!0,activeCalls--)}};exports.trackDatabaseCall=trackDatabaseCall;const configure=t=>{if(activeCalls>0&&void 0!==t.databasePath&&resolveDatabasePath(t.databasePath)!==resolveDatabasePath(settings.databasePath))throw new Error(`Can't change databasePath while ${activeCalls} database call(s) are still running or queued: await them first`);settings={...settings,...t}};exports.configure=configure;const getSetting=(t,a)=>void 0!==settings[t]?settings[t]:a;exports.getSetting=getSetting;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.trackDatabaseCall=exports.switchDatabase=exports.resolveDatabasePath=exports.lockPath=exports.getSetting=exports.databasesFolder=exports.configure=exports.activeDatabasePath=void 0,require("core-js/modules/es.json.stringify.js");const defaults={databasePath:"database/",relativePath:"",enforceForeignKeys:!0,readConcurrency:16,format:"compact"};let settings={...defaults},activeCalls=0;const databaseNameMatch=/^[a-z0-9_-]+$/i,withSlash=a=>a.endsWith("/")?a:`${a}/`,activeDatabasePath=()=>settings.databasesPath&&settings.database?`${withSlash(settings.databasesPath)}${settings.database}/`:getSetting("databasePath","database/");exports.activeDatabasePath=activeDatabasePath;const lockPath=()=>settings.databasesPath?withSlash(settings.databasesPath):activeDatabasePath();exports.lockPath=lockPath;const databasesFolder=()=>{if(!settings.databasesPath)throw new Error("Several databases need a folder to hold them: configure({ databasesPath: 'databases/' }) first");return withSlash(settings.databasesPath)};exports.databasesFolder=databasesFolder;const switchDatabase=a=>{settings={...settings,database:a}};exports.switchDatabase=switchDatabase;const resolveDatabasePath=a=>require("path").resolve(a);exports.resolveDatabasePath=resolveDatabasePath;const trackDatabaseCall=()=>{activeCalls++;let a=!1;return()=>{a||(a=!0,activeCalls--)}};exports.trackDatabaseCall=trackDatabaseCall;const configure=a=>{if(void 0!==a.format&&"compact"!==a.format&&"pretty"!==a.format)throw new Error(`Unknown format "${a.format}": use 'compact' or 'pretty'`);if(void 0!==a.database&&null!==a.database&&!databaseNameMatch.test(a.database))throw new Error(`Invalid database name ${JSON.stringify(a.database)}: names use letters, digits, _ and - only`);const t={...settings,...a};if(t.database&&!t.databasesPath)throw new Error("A database name needs the folder that holds the databases: configure({ databasesPath: 'databases/', database: '...' })");if(activeCalls>0){const e={active:resolveDatabasePath(activeDatabasePath()),lock:resolveDatabasePath(lockPath())},s=settings;settings=t;const o=resolveDatabasePath(activeDatabasePath())!==e.active||resolveDatabasePath(lockPath())!==e.lock;if(settings=s,o){const t=["databasePath","databasesPath","database"].filter((t=>void 0!==a[t])).join(" / ");throw new Error(`Can't change ${t} while ${activeCalls} database call(s) are still running or queued: await them first`)}}settings=t};exports.configure=configure;const getSetting=(a,t)=>void 0!==settings[a]?settings[a]:t;exports.getSetting=getSetting;

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

@@ -1,3 +1,8 @@
+/**
+ * How many calls are running in this browser page right now (they aren't queued there, see withDatabaseLock): `use`
+ * refuses to switch the database while any other call is, as that call would carry on in the other database.
+ */
+export declare const browserCallsRunning: () => number;
 /**
  * Run `task` once every earlier task on the same database (the configured databasePath) has finished, so that calls
  * never interleave. Every write is several files in turn (an entry, the record's entry list, each index), each read and
@@ -8,6 +13,8 @@
  * Only the public functions (query, create, drop, describe) take the lock; what they call inside doesn't take it
  * again, so it can't deadlock. In the browser nothing can be written, so tasks just run.
  *
+ * Each task also runs with a read cache (see withReadCache): the files it reads are read once for the whole call.
+ *
  * The queue is per folder (`database/` and `./database` share one). Every step of a task reads databasePath when it
  * runs, so configure() refuses to change it while tasks are queued or running (see trackDatabaseCall).
  * @param task

package/dist/data/utilities/databaseLock.js

@@ -4,7 +4,7 @@ require("core-js/modules/esnext.weak-map.delete-all.js");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.withDatabaseLock = void 0;
+exports.withDatabaseLock = exports.browserCallsRunning = void 0;
 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");
@@ -20,9 +20,16 @@ require("core-js/modules/esnext.map.some.js");
 require("core-js/modules/esnext.map.update.js");
 var jsEnv = _interopRequireWildcard(require("browser-or-node"));
 var _config = require("./config");
+var _storage = require("../storage");
 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 queues = new Map();
+let browserCalls = 0;
+/**
+ * How many calls are running in this browser page right now (they aren't queued there, see withDatabaseLock): `use`
+ * refuses to switch the database while any other call is, as that call would carry on in the other database.
+ */
+const browserCallsRunning = () => browserCalls;
 /**
  * Run `task` once every earlier task on the same database (the configured databasePath) has finished, so that calls
  * never interleave. Every write is several files in turn (an entry, the record's entry list, each index), each read and
@@ -33,15 +40,23 @@ const queues = new Map();
  * Only the public functions (query, create, drop, describe) take the lock; what they call inside doesn't take it
  * again, so it can't deadlock. In the browser nothing can be written, so tasks just run.
  *
+ * Each task also runs with a read cache (see withReadCache): the files it reads are read once for the whole call.
+ *
  * The queue is per folder (`database/` and `./database` share one). Every step of a task reads databasePath when it
  * runs, so configure() refuses to change it while tasks are queued or running (see trackDatabaseCall).
  * @param task
  */
+exports.browserCallsRunning = browserCallsRunning;
 const withDatabaseLock = async task => {
   if (!jsEnv.isNode) {
-    return task();
+    browserCalls++;
+    try {
+      return await (0, _storage.withReadCache)(task);
+    } finally {
+      browserCalls--;
+    }
   }
-  const database = (0, _config.resolveDatabasePath)((0, _config.getSetting)('databasePath', 'database/'));
+  const database = (0, _config.resolveDatabasePath)((0, _config.lockPath)());
   const ended = (0, _config.trackDatabaseCall)();
   const previous = queues.get(database) || Promise.resolve();
   let release;
@@ -52,7 +67,7 @@ const withDatabaseLock = async task => {
   queues.set(database, queued);
   await previous;
   try {
-    return await task();
+    return await (0, _storage.withReadCache)(task);
   } finally {
     ended();
     release();

package/dist/data/utilities/databaseLock.min.js

@@ -1 +1 @@
-"use strict";require("core-js/modules/esnext.weak-map.delete-all.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.withDatabaseLock=void 0,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");var e,jsEnv=_interopRequireWildcard(require("browser-or-node")),_config=require("./config");function _interopRequireWildcard(s,r){if(!r&&s&&s.__esModule)return s;var t,a,o=Object.defineProperty,u={__proto__:null,default:s};if(Object(s)!==s)return u;if(e||"function"!=typeof WeakMap||(e=new WeakMap),e){if(e.has(s))return e.get(s);e.set(s,u)}for(a in s)"default"!==a&&{}.hasOwnProperty.call(s,a)&&((t=o&&Object.getOwnPropertyDescriptor(s,a))&&(t.get||t.set)?o(u,a,t):u[a]=s[a]);return u}const queues=new Map,withDatabaseLock=async e=>{if(!jsEnv.isNode)return e();const s=(0,_config.resolveDatabasePath)((0,_config.getSetting)("databasePath","database/")),r=(0,_config.trackDatabaseCall)(),t=queues.get(s)||Promise.resolve();let a;const o=new Promise((e=>{a=e})),u=t.then((()=>o));queues.set(s,u),await t;try{return await e()}finally{r(),a(),queues.get(s)===u&&queues.delete(s)}};exports.withDatabaseLock=withDatabaseLock;
+"use strict";require("core-js/modules/esnext.weak-map.delete-all.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.withDatabaseLock=exports.browserCallsRunning=void 0,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");var e,jsEnv=_interopRequireWildcard(require("browser-or-node")),_config=require("./config"),_storage=require("../storage");function _interopRequireWildcard(r,s){if(!s&&r&&r.__esModule)return r;var t,o,a=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=a&&Object.getOwnPropertyDescriptor(r,o))&&(t.get||t.set)?a(n,o,t):n[o]=r[o]);return n}const queues=new Map;let browserCalls=0;const browserCallsRunning=()=>browserCalls;exports.browserCallsRunning=browserCallsRunning;const withDatabaseLock=async e=>{if(!jsEnv.isNode){browserCalls++;try{return await(0,_storage.withReadCache)(e)}finally{browserCalls--}}const r=(0,_config.resolveDatabasePath)((0,_config.lockPath)()),s=(0,_config.trackDatabaseCall)(),t=queues.get(r)||Promise.resolve();let o;const a=new Promise((e=>{o=e})),n=t.then((()=>a));queues.set(r,n),await t;try{return await(0,_storage.withReadCache)(e)}finally{s(),o(),queues.get(r)===n&&queues.delete(r)}};exports.withDatabaseLock=withDatabaseLock;