json-fs-query 3.1.4 → 3.3.0

package/dist/data/utilities/parsers/parseDatabaseStatement.d.ts

@@ -0,0 +1,17 @@
+export type ParsedDatabaseStatement = {
+    command: 'create database' | 'drop database' | 'use' | 'show databases';
+    entity: string;
+    ifExists: boolean;
+    ifNotExists: boolean;
+};
+/**
+ * The statements about databases rather than records. `create database (...)` and a bare `drop database` stay a record
+ * named "database": these need a database name after the keyword.
+ */
+export declare const databaseStatementMatch: RegExp;
+/**
+ * Read `create database [if not exists] <name>`, `drop database [if exists] <name>`, `use <name>` or `show databases`.
+ * @param query - The statement, with its strings and arrays masked (see maskStrings).
+ */
+export declare const parseDatabaseStatement: (query: string) => ParsedDatabaseStatement;
+//# sourceMappingURL=parseDatabaseStatement.d.ts.map

package/dist/data/utilities/parsers/parseDatabaseStatement.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseDatabaseStatement = exports.databaseStatementMatch = void 0;
+var _maskStrings = require("./maskStrings");
+var _startsQuery = require("./startsQuery");
+/**
+ * The statements about databases rather than records. `create database (...)` and a bare `drop database` stay a record
+ * named "database": these need a database name after the keyword.
+ */
+const databaseStatementMatch = exports.databaseStatementMatch = /^\s*(?:(?:create|drop)\s+database\s+(?!\()[a-z0-9_-]|show\s+databases(?![a-z0-9_-])|use(?![a-z0-9_.-]))/i;
+const createMatch = /^\s*create\s+database\s+(if\s+not\s+exists\s+)?([a-z0-9_-]+)/i;
+const dropMatch = /^\s*drop\s+database\s+(if\s+exists\s+)?([a-z0-9_-]+)/i;
+const useMatch = /^\s*use\s+([a-z0-9_-]+)/i;
+const showMatch = /^\s*show\s+databases/i;
+/**
+ * Nothing may follow a database statement but the end of the query.
+ * @param rest
+ */
+const assertNothingAfter = rest => {
+  const after = rest.trim();
+  if (!after) {
+    return;
+  }
+  const shown = (0, _maskStrings.unmaskStrings)(after, '\'');
+  if (_startsQuery.startsQueryMatch.test(after)) {
+    throw new Error(`Missing ; before: ${shown}`);
+  }
+  throw new Error(`Unrecognized query value: ${shown}`);
+};
+/**
+ * Read `create database [if not exists] <name>`, `drop database [if exists] <name>`, `use <name>` or `show databases`.
+ * @param query - The statement, with its strings and arrays masked (see maskStrings).
+ */
+const parseDatabaseStatement = query => {
+  const statement = {
+    ifExists: false,
+    ifNotExists: false
+  };
+  let found = query.match(createMatch);
+  if (found) {
+    assertNothingAfter(query.slice(found[0].length));
+    return {
+      ...statement,
+      command: 'create database',
+      entity: found[2],
+      ifNotExists: Boolean(found[1])
+    };
+  }
+  found = query.match(dropMatch);
+  if (found) {
+    assertNothingAfter(query.slice(found[0].length));
+    return {
+      ...statement,
+      command: 'drop database',
+      entity: found[2],
+      ifExists: Boolean(found[1])
+    };
+  }
+  found = query.match(showMatch);
+  if (found) {
+    assertNothingAfter(query.slice(found[0].length));
+    return {
+      ...statement,
+      command: 'show databases',
+      entity: '__DATABASES'
+    };
+  }
+  found = query.match(useMatch);
+  if (!found) {
+    throw new Error('Expected: use <database>');
+  }
+  assertNothingAfter(query.slice(found[0].length));
+  return {
+    ...statement,
+    command: 'use',
+    entity: found[1]
+  };
+};
+exports.parseDatabaseStatement = parseDatabaseStatement;

package/dist/data/utilities/parsers/parseDatabaseStatement.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.parseDatabaseStatement=exports.databaseStatementMatch=void 0;var _maskStrings=require("./maskStrings"),_startsQuery=require("./startsQuery");const databaseStatementMatch=exports.databaseStatementMatch=/^\s*(?:(?:create|drop)\s+database\s+(?!\()[a-z0-9_-]|show\s+databases(?![a-z0-9_-])|use(?![a-z0-9_.-]))/i,createMatch=/^\s*create\s+database\s+(if\s+not\s+exists\s+)?([a-z0-9_-]+)/i,dropMatch=/^\s*drop\s+database\s+(if\s+exists\s+)?([a-z0-9_-]+)/i,useMatch=/^\s*use\s+([a-z0-9_-]+)/i,showMatch=/^\s*show\s+databases/i,assertNothingAfter=t=>{const e=t.trim();if(!e)return;const s=(0,_maskStrings.unmaskStrings)(e,"'");if(_startsQuery.startsQueryMatch.test(e))throw new Error(`Missing ; before: ${s}`);throw new Error(`Unrecognized query value: ${s}`)},parseDatabaseStatement=t=>{const e={ifExists:!1,ifNotExists:!1};let s=t.match(createMatch);if(s)return assertNothingAfter(t.slice(s[0].length)),{...e,command:"create database",entity:s[2],ifNotExists:Boolean(s[1])};if(s=t.match(dropMatch),s)return assertNothingAfter(t.slice(s[0].length)),{...e,command:"drop database",entity:s[2],ifExists:Boolean(s[1])};if(s=t.match(showMatch),s)return assertNothingAfter(t.slice(s[0].length)),{...e,command:"show databases",entity:"__DATABASES"};if(s=t.match(useMatch),!s)throw new Error("Expected: use <database>");return assertNothingAfter(t.slice(s[0].length)),{...e,command:"use",entity:s[1]}};exports.parseDatabaseStatement=parseDatabaseStatement;

package/dist/data/utilities/parsers/parseQuery.d.ts

@@ -11,6 +11,7 @@ import { ParsedGroupBy } from './findGroupBy';
 import { ParsedLimit } from './findLimit';
 import { ParsedOffset } from './findOffset';
 import { ParsedCreate } from './parseCreate';
+import { ParsedAlter } from './parseAlter';
 export type ParsedQuery = {
     command: ParsedCommand | undefined;
     entity: ParsedEntity | undefined;
@@ -26,6 +27,8 @@ export type ParsedQuery = {
     limit: ParsedLimit | undefined;
     offset: ParsedOffset | undefined;
     create: ParsedCreate | undefined;
+    alter?: ParsedAlter;
+    ifNotExists?: boolean;
     ifExists: boolean | undefined;
 };
 /**

package/dist/data/utilities/parsers/parseQuery.js

@@ -20,6 +20,8 @@ var _findOffset = require("./findOffset");
 var _maskStrings = require("./maskStrings");
 var _parseCreate = require("./parseCreate");
 var _parseSchemaStatement = require("./parseSchemaStatement");
+var _parseAlter = require("./parseAlter");
+var _parseDatabaseStatement = require("./parseDatabaseStatement");
 var _splitClauses = require("./splitClauses");
 var _startsQuery = require("./startsQuery");
 // Each clause's own step, and what its body must start with (for the error when it doesn't)
@@ -101,6 +103,11 @@ const parseQuery = query => {
   };
   // No find* step may see inside a string or an array: each one becomes a placeholder holding its value
   query = (0, _maskStrings.maskArrays)((0, _maskStrings.maskStrings)(query));
+  // Statements about databases (create / drop database, use, show databases) come first: they share their first words
+  // with the record statements
+  if (_parseDatabaseStatement.databaseStatementMatch.test(query)) {
+    return Object.assign(parsedQuery, (0, _parseDatabaseStatement.parseDatabaseStatement)(query));
+  }
   // A create statement has its own shape (a bracketed list of fields and keys), so it gets its own parser
   if (_parseCreate.createMatch.test(query)) {
     const {
@@ -116,6 +123,18 @@ const parseQuery = query => {
   if (_parseSchemaStatement.schemaStatementMatch.test(query)) {
     return Object.assign(parsedQuery, (0, _parseSchemaStatement.parseSchemaStatement)(query));
   }
+  // So does alter: one change to a record's fields
+  if (_parseAlter.alterMatch.test(query)) {
+    const {
+      entity,
+      alter
+    } = (0, _parseAlter.parseAlter)(query);
+    return Object.assign(parsedQuery, {
+      command: 'alter',
+      entity,
+      alter
+    });
+  }
   // Clauses come at most once each, in a fixed order (see clauseOrder); each step reads only its own clause's body
   const split = (0, _splitClauses.splitClauses)(query);
   if (!split) {
@@ -146,6 +165,11 @@ const parseQuery = query => {
       throw leftoverError(rest, `${keyword} ${body.slice(0, body.length - rest.length).trim()}`);
     }
   }
+  // `on` joins the record named after the queried one: without it there's nothing to join (this used to fail later,
+  // reading a record with no name, as "Could not read .json")
+  if ((parsedQuery.joinClauses || []).length && !parsedQuery.joinEntity) {
+    throw new Error(`"on" needs the record to join, after the one read: ${parsedQuery.command} ${parsedQuery.entity}.<record> on ...`);
+  }
   return parsedQuery;
 };
 exports.parseQuery = parseQuery;

package/dist/data/utilities/parsers/parseQuery.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.parseQuery=void 0;var _findCommand=require("./findCommand"),_findInsertValues=require("./findInsertValues"),_findUpdateValues=require("./findUpdateValues"),_findJoinEntity=require("./findJoinEntity"),_findSelects=require("./findSelects"),_findConditions=require("./findConditions"),_conditionTree=require("../conditionTree"),_findJoinClauses=require("./findJoinClauses"),_findMergeJoins=require("./findMergeJoins"),_findSortClauses=require("./findSortClauses"),_findGroupBy=require("./findGroupBy"),_findLimit=require("./findLimit"),_findOffset=require("./findOffset"),_maskStrings=require("./maskStrings"),_parseCreate=require("./parseCreate"),_parseSchemaStatement=require("./parseSchemaStatement"),_splitClauses=require("./splitClauses"),_startsQuery=require("./startsQuery");const clauseSteps={values:{step:_findInsertValues.findInsertValues,expected:"an assignment (field = value)"},set:{step:_findUpdateValues.findUpdateValues,expected:"an assignment (field = value)"},select:{step:_findSelects.findSelects,expected:"a field"},on:{step:_findJoinClauses.findJoinClauses,expected:"a join condition (a.x = b.y)"},merge:{step:_findMergeJoins.findMergeJoins,expected:"a merge (a.x with b.y)"},where:{step:_findConditions.findConditions,expected:"a condition"},"group by":{step:_findGroupBy.findGroupBy,expected:"a field"},sort:{step:_findSortClauses.findSortClauses,expected:"a field"},limit:{step:_findLimit.findLimit,expected:"a whole number"},offset:{step:_findOffset.findOffset,expected:"a whole number"}},leftoverError=(e,t)=>{const i=e=>(0,_maskStrings.unmaskStrings)(e,"'");return _startsQuery.startsQueryMatch.test(e)?new Error(`Missing ; before: ${i(e)}`):new Error(`Unexpected "${i(e)}" after "${i(t)}"`)},parseQuery=e=>{const t={command:void 0,entity:void 0,joinEntity:void 0,selectClauses:[],insertValues:[],updateValues:{},where:void 0,joinClauses:[],mergeJoins:[],sortClauses:[],groupBy:void 0,limit:void 0,offset:void 0,create:void 0,ifExists:void 0};if(e=(0,_maskStrings.maskArrays)((0,_maskStrings.maskStrings)(e)),_parseCreate.createMatch.test(e)){const{entity:i,create:r}=(0,_parseCreate.parseCreate)(e);return Object.assign(t,{command:"create",entity:i,create:r})}if(_parseSchemaStatement.schemaStatementMatch.test(e))return Object.assign(t,(0,_parseSchemaStatement.parseSchemaStatement)(e));const i=(0,_splitClauses.splitClauses)(e);if(!i){if(e=e.trim(),_startsQuery.startsQueryMatch.test(e))throw new Error(`Missing ; before: ${(0,_maskStrings.unmaskStrings)(e,"'")}`);throw new Error(`Unrecognized query value: ${(0,_maskStrings.unmaskStrings)(e,"'")}`)}if((0,_findJoinEntity.findJoinEntity)(t,(0,_findCommand.findCommand)(t,i.head)),t.where=(0,_conditionTree.allOf)([]),i.leading)throw leftoverError(i.leading,i.head);for(const{keyword:e,body:r}of i.clauses){const{step:i,expected:s}=clauseSteps[e],n=i(t,r);if(n===r)throw new Error(`Missing ${s} after ${e}${r?`: ${(0,_maskStrings.unmaskStrings)(r,"'")}`:""}`);if(n)throw leftoverError(n,`${e} ${r.slice(0,r.length-n.length).trim()}`)}return t};exports.parseQuery=parseQuery;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.parseQuery=void 0;var _findCommand=require("./findCommand"),_findInsertValues=require("./findInsertValues"),_findUpdateValues=require("./findUpdateValues"),_findJoinEntity=require("./findJoinEntity"),_findSelects=require("./findSelects"),_findConditions=require("./findConditions"),_conditionTree=require("../conditionTree"),_findJoinClauses=require("./findJoinClauses"),_findMergeJoins=require("./findMergeJoins"),_findSortClauses=require("./findSortClauses"),_findGroupBy=require("./findGroupBy"),_findLimit=require("./findLimit"),_findOffset=require("./findOffset"),_maskStrings=require("./maskStrings"),_parseCreate=require("./parseCreate"),_parseSchemaStatement=require("./parseSchemaStatement"),_parseAlter=require("./parseAlter"),_parseDatabaseStatement=require("./parseDatabaseStatement"),_splitClauses=require("./splitClauses"),_startsQuery=require("./startsQuery");const clauseSteps={values:{step:_findInsertValues.findInsertValues,expected:"an assignment (field = value)"},set:{step:_findUpdateValues.findUpdateValues,expected:"an assignment (field = value)"},select:{step:_findSelects.findSelects,expected:"a field"},on:{step:_findJoinClauses.findJoinClauses,expected:"a join condition (a.x = b.y)"},merge:{step:_findMergeJoins.findMergeJoins,expected:"a merge (a.x with b.y)"},where:{step:_findConditions.findConditions,expected:"a condition"},"group by":{step:_findGroupBy.findGroupBy,expected:"a field"},sort:{step:_findSortClauses.findSortClauses,expected:"a field"},limit:{step:_findLimit.findLimit,expected:"a whole number"},offset:{step:_findOffset.findOffset,expected:"a whole number"}},leftoverError=(e,t)=>{const r=e=>(0,_maskStrings.unmaskStrings)(e,"'");return _startsQuery.startsQueryMatch.test(e)?new Error(`Missing ; before: ${r(e)}`):new Error(`Unexpected "${r(e)}" after "${r(t)}"`)},parseQuery=e=>{const t={command:void 0,entity:void 0,joinEntity:void 0,selectClauses:[],insertValues:[],updateValues:{},where:void 0,joinClauses:[],mergeJoins:[],sortClauses:[],groupBy:void 0,limit:void 0,offset:void 0,create:void 0,ifExists:void 0};if(e=(0,_maskStrings.maskArrays)((0,_maskStrings.maskStrings)(e)),_parseDatabaseStatement.databaseStatementMatch.test(e))return Object.assign(t,(0,_parseDatabaseStatement.parseDatabaseStatement)(e));if(_parseCreate.createMatch.test(e)){const{entity:r,create:s}=(0,_parseCreate.parseCreate)(e);return Object.assign(t,{command:"create",entity:r,create:s})}if(_parseSchemaStatement.schemaStatementMatch.test(e))return Object.assign(t,(0,_parseSchemaStatement.parseSchemaStatement)(e));if(_parseAlter.alterMatch.test(e)){const{entity:r,alter:s}=(0,_parseAlter.parseAlter)(e);return Object.assign(t,{command:"alter",entity:r,alter:s})}const r=(0,_splitClauses.splitClauses)(e);if(!r){if(e=e.trim(),_startsQuery.startsQueryMatch.test(e))throw new Error(`Missing ; before: ${(0,_maskStrings.unmaskStrings)(e,"'")}`);throw new Error(`Unrecognized query value: ${(0,_maskStrings.unmaskStrings)(e,"'")}`)}if((0,_findJoinEntity.findJoinEntity)(t,(0,_findCommand.findCommand)(t,r.head)),t.where=(0,_conditionTree.allOf)([]),r.leading)throw leftoverError(r.leading,r.head);for(const{keyword:e,body:s}of r.clauses){const{step:r,expected:i}=clauseSteps[e],n=r(t,s);if(n===s)throw new Error(`Missing ${i} after ${e}${s?`: ${(0,_maskStrings.unmaskStrings)(s,"'")}`:""}`);if(n)throw leftoverError(n,`${e} ${s.slice(0,s.length-n.length).trim()}`)}if((t.joinClauses||[]).length&&!t.joinEntity)throw new Error(`"on" needs the record to join, after the one read: ${t.command} ${t.entity}.<record> on ...`);return t};exports.parseQuery=parseQuery;

package/dist/data/utilities/parsers/startsQuery.js

@@ -7,4 +7,4 @@ exports.startsQueryMatch = void 0;
 /**
  * Matches text that starts with a command word, for the "Missing ; before" error when a query runs on into the next.
  */
-const startsQueryMatch = exports.startsQueryMatch = /^\s*(create|delete|describe|drop|insert|read|show|update)(?![a-z0-9_-])/i;
+const startsQueryMatch = exports.startsQueryMatch = /^\s*(alter|create|delete|describe|drop|insert|read|show|update|use)(?![a-z0-9_-])/i;

package/dist/data/utilities/parsers/startsQuery.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.startsQueryMatch=void 0;const startsQueryMatch=exports.startsQueryMatch=/^\s*(create|delete|describe|drop|insert|read|show|update)(?![a-z0-9_-])/i;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.startsQueryMatch=void 0;const startsQueryMatch=exports.startsQueryMatch=/^\s*(alter|create|delete|describe|drop|insert|read|show|update|use)(?![a-z0-9_-])/i;

package/dist/data/utilities/recordExists.js

@@ -4,15 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.recordExists = void 0;
-var _config = require("./config");
+var _storage = require("../storage");
 /**
  * Whether a record (its `<name>.json` file) exists in the database. Node only, like the schema statements that use it.
  * @param entity
  */
-const recordExists = entity => {
-  const {
-    existsSync
-  } = require('fs');
-  return existsSync(`${(0, _config.getSetting)('databasePath', 'database/')}${entity}.json`);
-};
+const recordExists = entity => (0, _storage.fileExists)(`${entity}.json`);
 exports.recordExists = recordExists;

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.recordExists=void 0;var _config=require("./config");const recordExists=e=>{const{existsSync:s}=require("fs");return s(`${(0,_config.getSetting)("databasePath","database/")}${e}.json`)};exports.recordExists=recordExists;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.recordExists=void 0;var _storage=require("../storage");const recordExists=e=>(0,_storage.fileExists)(`${e}.json`);exports.recordExists=recordExists;

package/dist/data/utilities/registerRecord.js

@@ -5,12 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.registerRecord = void 0;
 require("core-js/modules/es.array.includes.js");
-require("core-js/modules/es.json.stringify.js");
-var _config = require("./config");
-const {
-  readFile,
-  writeFile
-} = require('fs/promises');
+var _storage = require("../storage");
 /**
  * __RECORDS is itself an ordinary record - path/definition/keys/entries - whose entries are the
  * filenames of every other record that has been created. This is the schema it's given the first
@@ -49,11 +44,10 @@ const defaultRegistry = () => ({
  * @param recordName
  */
 const registerRecord = async recordName => {
-  const databasePath = (0, _config.getSetting)('databasePath', 'database/');
-  const registryPath = `${databasePath}__RECORDS.json`;
+  const registryPath = '__RECORDS.json';
   let registry;
   try {
-    registry = JSON.parse(await readFile(registryPath, 'utf8'));
+    registry = await (0, _storage.readJson)(registryPath);
   } catch (err) {
     registry = defaultRegistry();
   }
@@ -61,7 +55,7 @@ const registerRecord = async recordName => {
   if (!registry.entries.includes(fileName)) {
     registry.entries.push(fileName);
   }
-  await writeFile(registryPath, JSON.stringify(registry, null, 2));
+  await (0, _storage.writeJson)(registryPath, registry);
   return registry;
 };
 exports.registerRecord = registerRecord;

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.registerRecord=void 0,require("core-js/modules/es.array.includes.js"),require("core-js/modules/es.json.stringify.js");var _config=require("./config");const{readFile:readFile,writeFile:writeFile}=require("fs/promises"),defaultRegistry=()=>({path:"",definition:[{name:"path",type:"string",optional:!1,autoGenerate:!1},{name:"definition",type:"object",optional:!1,autoGenerate:!1},{name:"keys",type:"array",optional:!1,autoGenerate:!1},{name:"entries",type:"array",optional:!1,autoGenerate:!1}],keys:[],entries:[]}),registerRecord=async e=>{const t=`${(0,_config.getSetting)("databasePath","database/")}__RECORDS.json`;let r;try{r=JSON.parse(await readFile(t,"utf8"))}catch(e){r=defaultRegistry()}const i=`${e}.json`;return r.entries.includes(i)||r.entries.push(i),await writeFile(t,JSON.stringify(r,null,2)),r};exports.registerRecord=registerRecord;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.registerRecord=void 0,require("core-js/modules/es.array.includes.js");var _storage=require("../storage");const defaultRegistry=()=>({path:"",definition:[{name:"path",type:"string",optional:!1,autoGenerate:!1},{name:"definition",type:"object",optional:!1,autoGenerate:!1},{name:"keys",type:"array",optional:!1,autoGenerate:!1},{name:"entries",type:"array",optional:!1,autoGenerate:!1}],keys:[],entries:[]}),registerRecord=async e=>{const t="__RECORDS.json";let r;try{r=await(0,_storage.readJson)(t)}catch(e){r=defaultRegistry()}const a=`${e}.json`;return r.entries.includes(a)||r.entries.push(a),await(0,_storage.writeJson)(t,r),r};exports.registerRecord=registerRecord;

package/dist/data/utilities/removeFromIndex.js

@@ -4,16 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.removeFromIndex = void 0;
-require("core-js/modules/es.json.stringify.js");
 require("core-js/modules/esnext.iterator.constructor.js");
 require("core-js/modules/esnext.iterator.filter.js");
 require("core-js/modules/esnext.iterator.map.js");
-var _config = require("./config");
 var _compareAs = require("./compareAs");
-const {
-  readFile,
-  writeFile
-} = require('fs/promises');
+var _storage = require("../storage");
 /**
  * Remove a single entry file from the index that backs one of a record's keys, dropping a value
  * entirely once its last file is removed. A key with no lookup, or an index file that doesn't
@@ -28,11 +23,10 @@ const removeFromIndex = async (path = '', key = null, value = undefined, fileNam
   if (!key || !key.lookup) {
     return null;
   }
-  const databasePath = (0, _config.getSetting)('databasePath', 'database/');
-  const indexPath = `${databasePath}__indexes/${path}/${key.lookup}`;
+  const indexPath = `__indexes/${path}/${key.lookup}`;
   let index = [];
   try {
-    index = JSON.parse(await readFile(indexPath, 'utf8'));
+    index = await (0, _storage.readJson)(indexPath);
   } catch (err) {
     return null;
   }
@@ -40,7 +34,7 @@ const removeFromIndex = async (path = '', key = null, value = undefined, fileNam
     value: entry.value,
     record: entry.record.filter(record => record !== fileName)
   } : entry).filter(entry => entry.record.length);
-  await writeFile(indexPath, JSON.stringify(index, null, 2));
+  await (0, _storage.writeJson)(indexPath, index);
   return index;
 };
 exports.removeFromIndex = removeFromIndex;

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.removeFromIndex=void 0,require("core-js/modules/es.json.stringify.js"),require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.js"),require("core-js/modules/esnext.iterator.map.js");var _config=require("./config"),_compareAs=require("./compareAs");const{readFile:readFile,writeFile:writeFile}=require("fs/promises"),removeFromIndex=async(e="",r=null,o=void 0,t="",i=void 0)=>{if(!r||!r.lookup)return null;const s=`${(0,_config.getSetting)("databasePath","database/")}__indexes/${e}/${r.lookup}`;let a=[];try{a=JSON.parse(await readFile(s,"utf8"))}catch(e){return null}return a=a.map((e=>(0,_compareAs.sameValue)(i,e.value,o)?{value:e.value,record:e.record.filter((e=>e!==t))}:e)).filter((e=>e.record.length)),await writeFile(s,JSON.stringify(a,null,2)),a};exports.removeFromIndex=removeFromIndex;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.removeFromIndex=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.js"),require("core-js/modules/esnext.iterator.map.js");var _compareAs=require("./compareAs"),_storage=require("../storage");const removeFromIndex=async(e="",r=null,o=void 0,t="",s=void 0)=>{if(!r||!r.lookup)return null;const a=`__indexes/${e}/${r.lookup}`;let u=[];try{u=await(0,_storage.readJson)(a)}catch(e){return null}return u=u.map((e=>(0,_compareAs.sameValue)(s,e.value,o)?{value:e.value,record:e.record.filter((e=>e!==t))}:e)).filter((e=>e.record.length)),await(0,_storage.writeJson)(a,u),u};exports.removeFromIndex=removeFromIndex;

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

@@ -1,2 +1,7 @@
+/**
+ * Read one JSON file of the database (see readJson), logging the underlying error and throwing one that names the file.
+ * @param path - A path inside the database, such as `users.json`.
+ * @throws {Error} `Could not read <path>` when the file can't be read.
+ */
 export declare const retrieveFile: (path: any) => Promise<any>;
 //# sourceMappingURL=retrieveFile.d.ts.map

package/dist/data/utilities/retrieveFile.js

@@ -1,26 +1,17 @@
 "use strict";
 
-require("core-js/modules/esnext.weak-map.delete-all.js");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.retrieveFile = void 0;
-var jsEnv = _interopRequireWildcard(require("browser-or-node"));
-var _config = require("./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; }
+var _storage = require("../storage");
+/**
+ * Read one JSON file of the database (see readJson), logging the underlying error and throwing one that names the file.
+ * @param path - A path inside the database, such as `users.json`.
+ * @throws {Error} `Could not read <path>` when the file can't be read.
+ */
 const retrieveFile = async path => {
-  let retrieveFn = url => fetch(url).then(res => res.json());
-  const relativePath = jsEnv.isBrowser ? (0, _config.getSetting)('relativePath', '') : '';
-  if (jsEnv.isNode) {
-    const {
-      readFile
-    } = require('fs/promises');
-    retrieveFn = url => readFile(url).then(res => JSON.parse(res));
-  }
-  const databasePath = (0, _config.getSetting)('databasePath', 'database/');
-  const fetchUrl = `${relativePath}${databasePath}${path}`;
-  const recordInfo = await retrieveFn(fetchUrl).catch(err => console.error(err));
+  const recordInfo = await (0, _storage.readJson)(path).catch(err => console.error(err));
   if (!recordInfo) {
     throw new Error(`Could not read ${path}`);
   }

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

@@ -1 +1 @@
-"use strict";require("core-js/modules/esnext.weak-map.delete-all.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.retrieveFile=void 0;var e,jsEnv=_interopRequireWildcard(require("browser-or-node")),_config=require("./config");function _interopRequireWildcard(r,t){if(!t&&r&&r.__esModule)return r;var i,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)&&((i=n&&Object.getOwnPropertyDescriptor(r,o))&&(i.get||i.set)?n(s,o,i):s[o]=r[o]);return s}const retrieveFile=async e=>{let r=e=>fetch(e).then((e=>e.json()));const t=jsEnv.isBrowser?(0,_config.getSetting)("relativePath",""):"";if(jsEnv.isNode){const{readFile:e}=require("fs/promises");r=r=>e(r).then((e=>JSON.parse(e)))}const i=`${t}${(0,_config.getSetting)("databasePath","database/")}${e}`,o=await r(i).catch((e=>console.error(e)));if(!o)throw new Error(`Could not read ${e}`);return o};exports.retrieveFile=retrieveFile;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.retrieveFile=void 0;var _storage=require("../storage");const retrieveFile=async e=>{const r=await(0,_storage.readJson)(e).catch((e=>console.error(e)));if(!r)throw new Error(`Could not read ${e}`);return r};exports.retrieveFile=retrieveFile;

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

@@ -0,0 +1,15 @@
+/**
+ * Read several files of the database at once and resolve to their contents in the order of `paths`. Up to
+ * `readConcurrency` reads (see configure) are in flight together: in a browser each file is an HTTP request, so a full
+ * read of 1,000 rows no longer waits for 1,000 requests one after another.
+ *
+ * Fails as reading them one at a time would: with the error of the first file (in `paths` order) that can't be read.
+ * Once a read fails no new ones start; the ones already started are awaited, so none is left running after this
+ * returns, and since reads start in order, every file before the first failure was read.
+ * @param paths - Paths inside the database, such as `users/1.json`.
+ * @param read - Reads one path (default retrieveFile); callers with their own error message for a missing file pass it
+ *   here.
+ * @throws {Error} The error of the first file that couldn't be read.
+ */
+export declare const retrieveFiles: (paths: string[], read?: (path: string) => Promise<any>) => Promise<any[]>;
+//# sourceMappingURL=retrieveFiles.d.ts.map

package/dist/data/utilities/retrieveFiles.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.retrieveFiles = void 0;
+var _retrieveFile = require("./retrieveFile");
+var _config = require("./config");
+/**
+ * Read several files of the database at once and resolve to their contents in the order of `paths`. Up to
+ * `readConcurrency` reads (see configure) are in flight together: in a browser each file is an HTTP request, so a full
+ * read of 1,000 rows no longer waits for 1,000 requests one after another.
+ *
+ * Fails as reading them one at a time would: with the error of the first file (in `paths` order) that can't be read.
+ * Once a read fails no new ones start; the ones already started are awaited, so none is left running after this
+ * returns, and since reads start in order, every file before the first failure was read.
+ * @param paths - Paths inside the database, such as `users/1.json`.
+ * @param read - Reads one path (default retrieveFile); callers with their own error message for a missing file pass it
+ *   here.
+ * @throws {Error} The error of the first file that couldn't be read.
+ */
+const retrieveFiles = async (paths, read = _retrieveFile.retrieveFile) => {
+  const limit = Math.max(1, Math.floor((0, _config.getSetting)('readConcurrency', 16)) || 1);
+  const contents = new Array(paths.length);
+  const failures = [];
+  let next = 0;
+  const worker = async () => {
+    while (next < paths.length && !failures.length) {
+      const position = next++;
+      try {
+        contents[position] = await read(paths[position]);
+      } catch (error) {
+        failures.push({
+          position,
+          error
+        });
+      }
+    }
+  };
+  await Promise.all(Array.from({
+    length: Math.min(limit, paths.length)
+  }, worker));
+  if (failures.length) {
+    throw failures.reduce((first, failure) => failure.position < first.position ? failure : first).error;
+  }
+  return contents;
+};
+exports.retrieveFiles = retrieveFiles;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.retrieveFiles=void 0;var _retrieveFile=require("./retrieveFile"),_config=require("./config");const retrieveFiles=async(e,r=_retrieveFile.retrieveFile)=>{const t=Math.max(1,Math.floor((0,_config.getSetting)("readConcurrency",16))||1),i=new Array(e.length),o=[];let n=0;if(await Promise.all(Array.from({length:Math.min(t,e.length)},(async()=>{for(;n<e.length&&!o.length;){const t=n++;try{i[t]=await r(e[t])}catch(e){o.push({position:t,error:e})}}}))),o.length)throw o.reduce(((e,r)=>r.position<e.position?r:e)).error;return i};exports.retrieveFiles=retrieveFiles;

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

@@ -1,2 +1,8 @@
+/**
+ * A record's definition (its fields, keys and entries), from `<entity>.json`.
+ * @param entity
+ * @throws {Error} `Record "<entity>" doesn't exist` when it doesn't (in Node, checked before reading; in a browser,
+ *   where that can't be checked without reading, when the file can't be read).
+ */
 export declare const retrieveRecord: (entity?: string) => Promise<any>;
 //# sourceMappingURL=retrieveRecord.d.ts.map

package/dist/data/utilities/retrieveRecord.js

@@ -1,9 +1,32 @@
 "use strict";
 
+require("core-js/modules/esnext.weak-map.delete-all.js");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.retrieveRecord = void 0;
+var jsEnv = _interopRequireWildcard(require("browser-or-node"));
 var _retrieveFile = require("./retrieveFile");
-const retrieveRecord = async (entity = '') => await (0, _retrieveFile.retrieveFile)(`${entity}.json`);
+var _recordExists = require("./recordExists");
+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; }
+/**
+ * A record's definition (its fields, keys and entries), from `<entity>.json`.
+ * @param entity
+ * @throws {Error} `Record "<entity>" doesn't exist` when it doesn't (in Node, checked before reading; in a browser,
+ *   where that can't be checked without reading, when the file can't be read).
+ */
+const retrieveRecord = async (entity = '') => {
+  if (jsEnv.isNode && !(0, _recordExists.recordExists)(entity)) {
+    throw new Error(`Record "${entity}" doesn't exist`);
+  }
+  try {
+    return await (0, _retrieveFile.retrieveFile)(`${entity}.json`);
+  } catch (error) {
+    if (!jsEnv.isNode) {
+      throw new Error(`Record "${entity}" doesn't exist, or ${entity}.json can't be read`);
+    }
+    throw error;
+  }
+};
 exports.retrieveRecord = retrieveRecord;

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.retrieveRecord=void 0;var _retrieveFile=require("./retrieveFile");const retrieveRecord=async(e="")=>await(0,_retrieveFile.retrieveFile)(`${e}.json`);exports.retrieveRecord=retrieveRecord;
+"use strict";require("core-js/modules/esnext.weak-map.delete-all.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.retrieveRecord=void 0;var e,jsEnv=_interopRequireWildcard(require("browser-or-node")),_retrieveFile=require("./retrieveFile"),_recordExists=require("./recordExists");function _interopRequireWildcard(r,t){if(!t&&r&&r.__esModule)return r;var o,i,s=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(i in r)"default"!==i&&{}.hasOwnProperty.call(r,i)&&((o=s&&Object.getOwnPropertyDescriptor(r,i))&&(o.get||o.set)?s(n,i,o):n[i]=r[i]);return n}const retrieveRecord=async(e="")=>{if(jsEnv.isNode&&!(0,_recordExists.recordExists)(e))throw new Error(`Record "${e}" doesn't exist`);try{return await(0,_retrieveFile.retrieveFile)(`${e}.json`)}catch(r){if(!jsEnv.isNode)throw new Error(`Record "${e}" doesn't exist, or ${e}.json can't be read`);throw r}};exports.retrieveRecord=retrieveRecord;

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

@@ -1,2 +1,24 @@
+import { recordDefinition } from '../introspect/definitions/record';
+/**
+ * Read one entry file, failing with the message a missing entry has always had.
+ * @param path - The entry's path inside the database, such as `users/1.json`.
+ */
+export declare const retrieveEntry: (path: string) => Promise<any>;
+/**
+ * The rows of some of a record's entry files, in the order of `files`. When they're more than one round of reads
+ * (`readConcurrency`, see retrieveFiles) and the record has a packed file that matches it (see retrievePacked), they
+ * come from the packed file in one read; otherwise, and for any file the packed file doesn't hold (an index can list a
+ * file the record doesn't), from the entry files, several at a time. So a lookup of a few rows never downloads a whole
+ * record, and a record of a few rows is never asked for a packed file.
+ * @param record
+ * @param files - Entry file names, such as `1.json`.
+ * @param read - Reads one entry file (default retrieveEntry).
+ */
+export declare const retrieveEntryRows: (record: recordDefinition, files: string[], read?: (path: string) => Promise<any>) => Promise<any[]>;
+/**
+ * Every row of a record, in the record's order: from its packed file when there's one that matches (see
+ * retrievePacked), otherwise from its entry files, several at a time (see retrieveFiles).
+ * @param entity
+ */
 export declare const retrieveRecords: (entity?: string) => Promise<any[]>;
 //# sourceMappingURL=retrieveRecords.d.ts.map

package/dist/data/utilities/retrieveRecords.js

@@ -3,19 +3,69 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.retrieveRecords = void 0;
+exports.retrieveRecords = exports.retrieveEntryRows = exports.retrieveEntry = void 0;
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.filter.js");
+require("core-js/modules/esnext.iterator.map.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");
 var _retrieveFile = require("./retrieveFile");
 var _retrieveRecord = require("./retrieveRecord");
+var _retrieveFiles = require("./retrieveFiles");
+var _packedTable = require("./packedTable");
+var _config = require("./config");
+/**
+ * Read one entry file, failing with the message a missing entry has always had.
+ * @param path - The entry's path inside the database, such as `users/1.json`.
+ */
+const retrieveEntry = async path => {
+  const data = await (0, _retrieveFile.retrieveFile)(path).catch(err => console.error(err));
+  if (!data) {
+    throw new Error(`Could not read entity ${path.slice(path.lastIndexOf('/') + 1)}`);
+  }
+  return data;
+};
+/**
+ * The rows of some of a record's entry files, in the order of `files`. When they're more than one round of reads
+ * (`readConcurrency`, see retrieveFiles) and the record has a packed file that matches it (see retrievePacked), they
+ * come from the packed file in one read; otherwise, and for any file the packed file doesn't hold (an index can list a
+ * file the record doesn't), from the entry files, several at a time. So a lookup of a few rows never downloads a whole
+ * record, and a record of a few rows is never asked for a packed file.
+ * @param record
+ * @param files - Entry file names, such as `1.json`.
+ * @param read - Reads one entry file (default retrieveEntry).
+ */
+exports.retrieveEntry = retrieveEntry;
+const retrieveEntryRows = async (record, files, read = retrieveEntry) => {
+  const packed = files.length > (0, _config.getSetting)('readConcurrency', 16) ? await (0, _packedTable.retrievePacked)(record) : undefined;
+  if (!packed) {
+    return (0, _retrieveFiles.retrieveFiles)(files.map(file => `${record.path}/${file}`), read);
+  }
+  const positions = new Map(packed.entries.map((entry, position) => [entry, position]));
+  const unpacked = files.filter(file => !positions.has(file));
+  const readRows = unpacked.length ? await (0, _retrieveFiles.retrieveFiles)(unpacked.map(file => `${record.path}/${file}`), read) : [];
+  const fromFiles = new Map(unpacked.map((file, position) => [file, readRows[position]]));
+  return files.map(file => positions.has(file) ? packed.rows[positions.get(file)] : fromFiles.get(file));
+};
+/**
+ * Every row of a record, in the record's order: from its packed file when there's one that matches (see
+ * retrievePacked), otherwise from its entry files, several at a time (see retrieveFiles).
+ * @param entity
+ */
+exports.retrieveEntryRows = retrieveEntryRows;
 const retrieveRecords = async (entity = '') => {
   const recordFile = await (0, _retrieveRecord.retrieveRecord)(entity);
-  const dataSet = [];
-  for (const file of recordFile.entries) {
-    const data = await (0, _retrieveFile.retrieveFile)(`${recordFile.path}/${file}`).catch(err => console.error(err));
-    if (!data) {
-      throw new Error(`Could not read entity ${file}`);
-    }
-    dataSet.push(data);
-  }
-  return dataSet;
+  return retrieveEntryRows(recordFile, recordFile.entries);
 };
 exports.retrieveRecords = retrieveRecords;

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.retrieveRecords=void 0;var _retrieveFile=require("./retrieveFile"),_retrieveRecord=require("./retrieveRecord");const retrieveRecords=async(e="")=>{const r=await(0,_retrieveRecord.retrieveRecord)(e),t=[];for(const e of r.entries){const o=await(0,_retrieveFile.retrieveFile)(`${r.path}/${e}`).catch((e=>console.error(e)));if(!o)throw new Error(`Could not read entity ${e}`);t.push(o)}return t};exports.retrieveRecords=retrieveRecords;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.retrieveRecords=exports.retrieveEntryRows=exports.retrieveEntry=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.js"),require("core-js/modules/esnext.iterator.map.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");var _retrieveFile=require("./retrieveFile"),_retrieveRecord=require("./retrieveRecord"),_retrieveFiles=require("./retrieveFiles"),_packedTable=require("./packedTable"),_config=require("./config");const retrieveEntry=async e=>{const r=await(0,_retrieveFile.retrieveFile)(e).catch((e=>console.error(e)));if(!r)throw new Error(`Could not read entity ${e.slice(e.lastIndexOf("/")+1)}`);return r};exports.retrieveEntry=retrieveEntry;const retrieveEntryRows=async(e,r,s=retrieveEntry)=>{const t=r.length>(0,_config.getSetting)("readConcurrency",16)?await(0,_packedTable.retrievePacked)(e):void 0;if(!t)return(0,_retrieveFiles.retrieveFiles)(r.map((r=>`${e.path}/${r}`)),s);const i=new Map(t.entries.map(((e,r)=>[e,r]))),o=r.filter((e=>!i.has(e))),n=o.length?await(0,_retrieveFiles.retrieveFiles)(o.map((r=>`${e.path}/${r}`)),s):[],a=new Map(o.map(((e,r)=>[e,n[r]])));return r.map((e=>i.has(e)?t.rows[i.get(e)]:a.get(e)))};exports.retrieveEntryRows=retrieveEntryRows;const retrieveRecords=async(e="")=>{const r=await(0,_retrieveRecord.retrieveRecord)(e);return retrieveEntryRows(r,r.entries)};exports.retrieveRecords=retrieveRecords;