json-fs-query 3.1.4 → 3.3.0

package/dist/data/storage/listFiles.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.listFiles = void 0;
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.map.js");
+var _storagePath = require("./storagePath");
+var _nodeFiles = require("./nodeFiles");
+var _writeSet = require("./writeSet");
+/**
+ * The files in `folder` and the folders inside it, as paths relative to the database (`base` is the folder's own).
+ * Walks one folder at a time with a plain readdir, so it needs no `recursive` option (which older Node versions
+ * ignore without an error, listing only the top folder) and no `Dirent.parentPath`.
+ * @param base - The folder's path inside the database, ending in `/` (empty for the database itself).
+ */
+const walk = async base => {
+  let entries;
+  try {
+    entries = await (0, _nodeFiles.nodeFiles)().readdir((0, _storagePath.storagePath)(base), {
+      withFileTypes: true
+    });
+  } catch (error) {
+    if (error?.code === 'ENOENT') {
+      return [];
+    }
+    throw error;
+  }
+  const paths = [];
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      paths.push(...(await walk(`${base}${entry.name}/`)));
+    } else if (entry.isFile()) {
+      paths.push(`${base}${entry.name}`);
+    }
+  }
+  return paths;
+};
+/**
+ * Every file in a folder of the database and the folders inside it, as paths inside the database (such as
+ * `users/1.json`), sorted. During a statement it counts what the statement has written or deleted (see withWriteSet).
+ * A folder that doesn't exist has no files. Node only.
+ * @param path - A path inside the database, such as `users`. Empty for the whole database.
+ */
+const listFiles = async (path = '') => {
+  const base = path ? `${path.replace(/\/+$/, '')}/` : '';
+  const onDisk = (await walk(base)).map(file => (0, _storagePath.storagePath)(file));
+  const root = (0, _storagePath.storagePath)();
+  return (0, _writeSet.pendingListing)((0, _storagePath.storagePath)(path), onDisk).map(location => location.slice(root.length)).sort();
+};
+exports.listFiles = listFiles;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.listFiles=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.map.js");var _storagePath=require("./storagePath"),_nodeFiles=require("./nodeFiles"),_writeSet=require("./writeSet");const walk=async e=>{let t;try{t=await(0,_nodeFiles.nodeFiles)().readdir((0,_storagePath.storagePath)(e),{withFileTypes:!0})}catch(e){if("ENOENT"===e?.code)return[];throw e}const r=[];for(const s of t)s.isDirectory()?r.push(...await walk(`${e}${s.name}/`)):s.isFile()&&r.push(`${e}${s.name}`);return r},listFiles=async(e="")=>{const t=e?`${e.replace(/\/+$/,"")}/`:"",r=(await walk(t)).map((e=>(0,_storagePath.storagePath)(e))),s=(0,_storagePath.storagePath)();return(0,_writeSet.pendingListing)((0,_storagePath.storagePath)(e),r).map((e=>e.slice(s.length))).sort()};exports.listFiles=listFiles;

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

@@ -0,0 +1,7 @@
+/**
+ * Create a folder of the database, and any missing folders above it (doing nothing if it already exists). During a
+ * statement it's created with the statement's other changes (see withWriteSet). Node only.
+ * @param path - A path inside the database, such as `users`. Empty for the database folder itself.
+ */
+export declare const makeDirectory: (path?: string) => Promise<void>;
+//# sourceMappingURL=makeDirectory.d.ts.map

package/dist/data/storage/makeDirectory.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeDirectory = void 0;
+var _storagePath = require("./storagePath");
+var _nodeFiles = require("./nodeFiles");
+var _writeSet = require("./writeSet");
+/**
+ * Create a folder of the database, and any missing folders above it (doing nothing if it already exists). During a
+ * statement it's created with the statement's other changes (see withWriteSet). Node only.
+ * @param path - A path inside the database, such as `users`. Empty for the database folder itself.
+ */
+const makeDirectory = async (path = '') => {
+  const location = (0, _storagePath.storagePath)(path);
+  if ((0, _writeSet.stageMakeDirectory)(location)) {
+    return;
+  }
+  await (0, _nodeFiles.nodeFiles)().mkdir(location, {
+    recursive: true
+  });
+};
+exports.makeDirectory = makeDirectory;

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

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

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

@@ -0,0 +1,6 @@
+/**
+ * Node's `fs/promises`, loaded when a storage function runs rather than when the module is imported, so the browser
+ * bundle (which leaves `fs` out) can still import the storage module.
+ */
+export declare const nodeFiles: () => any;
+//# sourceMappingURL=nodeFiles.d.ts.map

package/dist/data/storage/nodeFiles.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.nodeFiles = void 0;
+/**
+ * Node's `fs/promises`, loaded when a storage function runs rather than when the module is imported, so the browser
+ * bundle (which leaves `fs` out) can still import the storage module.
+ */
+const nodeFiles = () => require('fs/promises');
+exports.nodeFiles = nodeFiles;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.nodeFiles=void 0;const nodeFiles=()=>require("fs/promises");exports.nodeFiles=nodeFiles;

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

@@ -0,0 +1,37 @@
+/**
+ * Run `task` with a read cache for the configured database: while it runs, each file is read from storage once and
+ * later reads of it are answered from memory, so a join no longer reads the joined record's files again for every row.
+ * Writes and deletes made during the task update the cache (see cacheWrite, cacheRemove), so a query reads its own
+ * writes. Outside any task nothing is cached and every read goes to storage, as before.
+ *
+ * The cache holds text, not parsed objects: every read parses its own copy, so a caller changing what it read (a join
+ * attaches rows to the rows it read) never changes what the next reader gets.
+ *
+ * withDatabaseLock runs every public call (query, create, drop, describe) inside one, so the cache lasts one call. In
+ * Node calls on one database never overlap (the lock queues them). In a browser they can, and a read can't tell which
+ * call it belongs to, so each call that starts empties the cache: calls still running carry on (only reading their
+ * files again), and nothing is older than the newest call, however long calls keep overlapping.
+ * @param task
+ */
+export declare const withReadCache: <T>(task: () => Promise<T>) => Promise<T>;
+/**
+ * The text of the file at `location`: from the cache when a call is running and the file was read (or written) during
+ * it, otherwise from `read`, kept for the rest of the call. A failed read isn't kept, so it fails (or succeeds) afresh
+ * the next time.
+ * @param location - The file's full location (see storagePath).
+ * @param read - Reads the file's text from storage.
+ */
+export declare const cachedRead: (location: string, read: () => Promise<string>) => Promise<string>;
+/**
+ * Keep the text just written to `location`, so the rest of the call reads it without going back to storage.
+ * @param location - The file's full location (see storagePath).
+ * @param text
+ */
+export declare const cacheWrite: (location: string, text: string) => void;
+/**
+ * Forget a removed file, or (with `folder`) everything under a removed folder.
+ * @param location - The full location (see storagePath) of the file or folder.
+ * @param folder - Whether `location` is a folder.
+ */
+export declare const cacheRemove: (location: string, folder?: boolean) => void;
+//# sourceMappingURL=readCache.d.ts.map

package/dist/data/storage/readCache.js

@@ -0,0 +1,117 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withReadCache = exports.cachedRead = exports.cacheWrite = exports.cacheRemove = 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 _storagePath = require("./storagePath");
+const scopes = new Map();
+/**
+ * The scope of the database configured now (by its location, see storagePath), if a call on it is running.
+ */
+const currentScope = () => scopes.get((0, _storagePath.storagePath)());
+/**
+ * Run `task` with a read cache for the configured database: while it runs, each file is read from storage once and
+ * later reads of it are answered from memory, so a join no longer reads the joined record's files again for every row.
+ * Writes and deletes made during the task update the cache (see cacheWrite, cacheRemove), so a query reads its own
+ * writes. Outside any task nothing is cached and every read goes to storage, as before.
+ *
+ * The cache holds text, not parsed objects: every read parses its own copy, so a caller changing what it read (a join
+ * attaches rows to the rows it read) never changes what the next reader gets.
+ *
+ * withDatabaseLock runs every public call (query, create, drop, describe) inside one, so the cache lasts one call. In
+ * Node calls on one database never overlap (the lock queues them). In a browser they can, and a read can't tell which
+ * call it belongs to, so each call that starts empties the cache: calls still running carry on (only reading their
+ * files again), and nothing is older than the newest call, however long calls keep overlapping.
+ * @param task
+ */
+const withReadCache = async task => {
+  const database = (0, _storagePath.storagePath)();
+  const scope = scopes.get(database) || {
+    calls: 0,
+    files: new Map()
+  };
+  scopes.set(database, scope);
+  scope.calls++;
+  if (scope.calls > 1) {
+    scope.files = new Map();
+  }
+  try {
+    return await task();
+  } finally {
+    scope.calls--;
+    if (!scope.calls && scopes.get(database) === scope) {
+      scopes.delete(database);
+    }
+  }
+};
+/**
+ * The text of the file at `location`: from the cache when a call is running and the file was read (or written) during
+ * it, otherwise from `read`, kept for the rest of the call. A failed read isn't kept, so it fails (or succeeds) afresh
+ * the next time.
+ * @param location - The file's full location (see storagePath).
+ * @param read - Reads the file's text from storage.
+ */
+exports.withReadCache = withReadCache;
+const cachedRead = (location, read) => {
+  const scope = currentScope();
+  if (!scope) {
+    return read();
+  }
+  const cached = scope.files.get(location);
+  if (cached) {
+    return cached;
+  }
+  const reading = read();
+  scope.files.set(location, reading);
+  reading.catch(() => {
+    if (scope.files.get(location) === reading) {
+      scope.files.delete(location);
+    }
+  });
+  return reading;
+};
+/**
+ * Keep the text just written to `location`, so the rest of the call reads it without going back to storage.
+ * @param location - The file's full location (see storagePath).
+ * @param text
+ */
+exports.cachedRead = cachedRead;
+const cacheWrite = (location, text) => {
+  currentScope()?.files.set(location, Promise.resolve(text));
+};
+/**
+ * Forget a removed file, or (with `folder`) everything under a removed folder.
+ * @param location - The full location (see storagePath) of the file or folder.
+ * @param folder - Whether `location` is a folder.
+ */
+exports.cacheWrite = cacheWrite;
+const cacheRemove = (location, folder = false) => {
+  const scope = currentScope();
+  if (!scope) {
+    return;
+  }
+  scope.files.delete(location);
+  if (folder) {
+    const prefix = location.endsWith('/') ? location : `${location}/`;
+    for (const cachedLocation of [...scope.files.keys()]) {
+      if (cachedLocation.startsWith(prefix)) {
+        scope.files.delete(cachedLocation);
+      }
+    }
+  }
+};
+exports.cacheRemove = cacheRemove;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.withReadCache=exports.cachedRead=exports.cacheWrite=exports.cacheRemove=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 _storagePath=require("./storagePath");const scopes=new Map,currentScope=()=>scopes.get((0,_storagePath.storagePath)()),withReadCache=async e=>{const s=(0,_storagePath.storagePath)(),r=scopes.get(s)||{calls:0,files:new Map};scopes.set(s,r),r.calls++,r.calls>1&&(r.files=new Map);try{return await e()}finally{r.calls--,r.calls||scopes.get(s)!==r||scopes.delete(s)}};exports.withReadCache=withReadCache;const cachedRead=(e,s)=>{const r=currentScope();if(!r)return s();const t=r.files.get(e);if(t)return t;const c=s();return r.files.set(e,c),c.catch((()=>{r.files.get(e)===c&&r.files.delete(e)})),c};exports.cachedRead=cachedRead;const cacheWrite=(e,s)=>{currentScope()?.files.set(e,Promise.resolve(s))};exports.cacheWrite=cacheWrite;const cacheRemove=(e,s=!1)=>{const r=currentScope();if(r&&(r.files.delete(e),s)){const s=e.endsWith("/")?e:`${e}/`;for(const e of[...r.files.keys()])e.startsWith(s)&&r.files.delete(e)}};exports.cacheRemove=cacheRemove;

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

@@ -0,0 +1,16 @@
+/**
+ * Read one file of the database as text, from wherever readJson would read it (the statement's write set, the read
+ * cache, then storage).
+ * @param path - A path inside the database, such as `users.json`.
+ * @throws {Error} When the file can't be read.
+ */
+export declare const readText: (path: string) => Promise<string>;
+/**
+ * Read and parse one JSON file of the database: from disk in Node, over `fetch()` in a browser (see storagePath for
+ * where it's looked for). During a statement, a file it has written or deleted is answered from its write set (see
+ * withWriteSet); otherwise, during a call, a file already read is answered from the read cache (see withReadCache).
+ * @param path - A path inside the database, such as `users.json`.
+ * @throws {Error} When the file can't be read or isn't valid JSON (the error from the file system, fetch or JSON.parse).
+ */
+export declare const readJson: (path: string) => Promise<any>;
+//# sourceMappingURL=readJson.d.ts.map

package/dist/data/storage/readJson.js

@@ -0,0 +1,38 @@
+"use strict";
+
+require("core-js/modules/esnext.weak-map.delete-all.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readText = exports.readJson = void 0;
+var jsEnv = _interopRequireWildcard(require("browser-or-node"));
+var _storagePath = require("./storagePath");
+var _nodeFiles = require("./nodeFiles");
+var _readCache = require("./readCache");
+var _writeSet = require("./writeSet");
+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; }
+/**
+ * Read one file of the database as text, from wherever readJson would read it (the statement's write set, the read
+ * cache, then storage).
+ * @param path - A path inside the database, such as `users.json`.
+ * @throws {Error} When the file can't be read.
+ */
+const readText = async path => {
+  const location = (0, _storagePath.storagePath)(path);
+  const pending = (0, _writeSet.pendingFile)(location);
+  if (pending === null) {
+    throw new Error(`ENOENT: no such file or directory, open '${location}' (deleted by this statement)`);
+  }
+  return typeof pending === 'string' ? pending : (0, _readCache.cachedRead)(location, () => jsEnv.isNode ? (0, _nodeFiles.nodeFiles)().readFile(location, 'utf8') : fetch(location).then(response => response.text()));
+};
+/**
+ * Read and parse one JSON file of the database: from disk in Node, over `fetch()` in a browser (see storagePath for
+ * where it's looked for). During a statement, a file it has written or deleted is answered from its write set (see
+ * withWriteSet); otherwise, during a call, a file already read is answered from the read cache (see withReadCache).
+ * @param path - A path inside the database, such as `users.json`.
+ * @throws {Error} When the file can't be read or isn't valid JSON (the error from the file system, fetch or JSON.parse).
+ */
+exports.readText = readText;
+const readJson = async path => JSON.parse(await readText(path));
+exports.readJson = readJson;

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

@@ -0,0 +1 @@
+"use strict";require("core-js/modules/esnext.weak-map.delete-all.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.readText=exports.readJson=void 0;var e,jsEnv=_interopRequireWildcard(require("browser-or-node")),_storagePath=require("./storagePath"),_nodeFiles=require("./nodeFiles"),_readCache=require("./readCache"),_writeSet=require("./writeSet");function _interopRequireWildcard(r,t){if(!t&&r&&r.__esModule)return r;var a,o,n=Object.defineProperty,s={__proto__:null,default:r};if(Object(r)!==r)return s;if(e||"function"!=typeof WeakMap||(e=new WeakMap),e){if(e.has(r))return e.get(r);e.set(r,s)}for(o in r)"default"!==o&&{}.hasOwnProperty.call(r,o)&&((a=n&&Object.getOwnPropertyDescriptor(r,o))&&(a.get||a.set)?n(s,o,a):s[o]=r[o]);return s}const readText=async e=>{const r=(0,_storagePath.storagePath)(e),t=(0,_writeSet.pendingFile)(r);if(null===t)throw new Error(`ENOENT: no such file or directory, open '${r}' (deleted by this statement)`);return"string"==typeof t?t:(0,_readCache.cachedRead)(r,(()=>jsEnv.isNode?(0,_nodeFiles.nodeFiles)().readFile(r,"utf8"):fetch(r).then((e=>e.text()))))};exports.readText=readText;const readJson=async e=>JSON.parse(await readText(e));exports.readJson=readJson;

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

@@ -0,0 +1,8 @@
+/**
+ * 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`.
+ */
+export declare const removeDirectory: (path: string) => Promise<void>;
+//# sourceMappingURL=removeDirectory.d.ts.map

package/dist/data/storage/removeDirectory.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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. 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, {
+    recursive: true,
+    force: true
+  });
+  (0, _readCache.cacheRemove)(location, true);
+};
+exports.removeDirectory = removeDirectory;

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

@@ -0,0 +1 @@
+"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

@@ -0,0 +1,8 @@
+/**
+ * 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.
+ */
+export declare const removeFile: (path: string) => Promise<void>;
+//# sourceMappingURL=removeFile.d.ts.map

package/dist/data/storage/removeFile.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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. 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);
+  (0, _readCache.cacheRemove)(location);
+};
+exports.removeFile = removeFile;

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

@@ -0,0 +1 @@
+"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.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Turn a path inside the database (such as `users.json` or `__indexes/users/name.json`) into the location the files
+ * backend uses: the configured databasePath in front of it, and in a browser also the relativePath (the URL prefix the
+ * database is served from).
+ *
+ * Every other part of json-fs-query names files by their path inside the database only; this is the one place that
+ * knows where the database is.
+ * @param path - A path inside the database, without a leading slash. Empty for the database folder itself.
+ */
+export declare const storagePath: (path?: string) => string;
+//# sourceMappingURL=storagePath.d.ts.map

package/dist/data/storage/storagePath.js

@@ -0,0 +1,25 @@
+"use strict";
+
+require("core-js/modules/esnext.weak-map.delete-all.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.storagePath = void 0;
+var jsEnv = _interopRequireWildcard(require("browser-or-node"));
+var _config = require("../utilities/config");
+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; }
+/**
+ * Turn a path inside the database (such as `users.json` or `__indexes/users/name.json`) into the location the files
+ * backend uses: the configured databasePath in front of it, and in a browser also the relativePath (the URL prefix the
+ * database is served from).
+ *
+ * Every other part of json-fs-query names files by their path inside the database only; this is the one place that
+ * knows where the database is.
+ * @param path - A path inside the database, without a leading slash. Empty for the database folder itself.
+ */
+const storagePath = (path = '') => {
+  const relativePath = jsEnv.isBrowser ? (0, _config.getSetting)('relativePath', '') : '';
+  return `${relativePath}${(0, _config.activeDatabasePath)()}${path}`;
+};
+exports.storagePath = storagePath;

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

@@ -0,0 +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 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

@@ -0,0 +1,17 @@
+/**
+ * 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, format?: "compact" | "pretty") => Promise<void>;
+//# sourceMappingURL=writeJson.d.ts.map

package/dist/data/storage/writeJson.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.writeJson = exports.jsonText = void 0;
+require("core-js/modules/es.json.stringify.js");
+var _storagePath = require("./storagePath");
+var _readCache = require("./readCache");
+var _writeSet = require("./writeSet");
+var _config = require("../utilities/config");
+/**
+ * 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).
+ */
+exports.jsonText = jsonText;
+const writeJson = async (path, content, format) => {
+  const location = (0, _storagePath.storagePath)(path);
+  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

@@ -0,0 +1 @@
+"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