json-fs-query 3.1.4 → 3.3.0

package/dist/data/introspect/packDatabase.d.ts

@@ -0,0 +1,27 @@
+export type packResult = {
+    records: number;
+    rows: number;
+};
+export type packCheck = {
+    stale: string[];
+    orphaned: string[];
+};
+/**
+ * Write every record of the configured database into one packed file (`__packed/<record>.json`, compact JSON): its
+ * rows in the record's order. A browser then reads a record in one request instead of one per row when it needs more
+ * rows than one round of requests (see packedReads in configure); a static site runs this as a build step, after its data changes. The entry files
+ * stay the copy that's edited and reviewed; any insert, update or delete through json-fs-query removes the record's
+ * packed file, and reads only use one that matches its record, so a packed file is never read in place of a change
+ * made through json-fs-query. Packed files of records that no longer exist are removed.
+ *
+ * Runs as one statement (the public version, see withWriteSet): a row that can't be read fails it and nothing is
+ * written. Node only.
+ */
+export declare const packDatabase: () => Promise<packResult>;
+/**
+ * Which records' packed files don't match their entry files (missing, or packed before a change made by
+ * hand), and which packed files belong to no record, without changing anything: for a build or test to check that
+ * packDatabase has run since the data last changed. Node only.
+ */
+export declare const checkPacked: () => Promise<packCheck>;
+//# sourceMappingURL=packDatabase.d.ts.map

package/dist/data/introspect/packDatabase.js

@@ -0,0 +1,113 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.packDatabase = exports.checkPacked = 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");
+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 _storage = require("../storage");
+var _retrieveRecord = require("../utilities/retrieveRecord");
+var _retrieveFiles = require("../utilities/retrieveFiles");
+var _retrieveRecords = require("../utilities/retrieveRecords");
+var _packedTable = require("../utilities/packedTable");
+var _showRecords = require("../queries/showRecords");
+var _requireNode = require("../utilities/requireNode");
+/**
+ * The packed file a record should have, read from its entry files (never from a packed file), as the compact
+ * text packDatabase writes.
+ * @param name - The record's name.
+ */
+const packedText = async name => {
+  const record = await (0, _retrieveRecord.retrieveRecord)(name);
+  const entries = record.entries || [];
+  const rows = await (0, _retrieveFiles.retrieveFiles)(entries.map(file => `${record.path}/${file}`), _retrieveRecords.retrieveEntry);
+  const packed = {
+    entries,
+    rows
+  };
+  return {
+    path: (0, _packedTable.packedPath)(record.path),
+    text: (0, _storage.jsonText)(packed, 'compact'),
+    rows: entries.length
+  };
+};
+/**
+ * The packed files under `__packed/` that belong to no record (left by a record dropped outside json-fs-query, or
+ * renamed by hand).
+ * @param names - The records' names.
+ */
+const orphanedPacks = async names => {
+  const expected = new Set(names.map(name => (0, _packedTable.packedPath)(name)));
+  return (await (0, _storage.listFiles)('__packed')).filter(path => !expected.has(path));
+};
+/**
+ * Write every record of the configured database into one packed file (`__packed/<record>.json`, compact JSON): its
+ * rows in the record's order. A browser then reads a record in one request instead of one per row when it needs more
+ * rows than one round of requests (see packedReads in configure); a static site runs this as a build step, after its data changes. The entry files
+ * stay the copy that's edited and reviewed; any insert, update or delete through json-fs-query removes the record's
+ * packed file, and reads only use one that matches its record, so a packed file is never read in place of a change
+ * made through json-fs-query. Packed files of records that no longer exist are removed.
+ *
+ * Runs as one statement (the public version, see withWriteSet): a row that can't be read fails it and nothing is
+ * written. Node only.
+ */
+const packDatabase = async () => {
+  (0, _requireNode.requireNode)('packDatabase');
+  const names = await (0, _showRecords.showRecords)();
+  let rows = 0;
+  for (const name of names) {
+    const packed = await packedText(name);
+    await (0, _storage.makeDirectory)(packed.path.slice(0, packed.path.lastIndexOf('/')));
+    await (0, _storage.writeJson)(packed.path, JSON.parse(packed.text), 'compact');
+    rows += packed.rows;
+  }
+  for (const path of await orphanedPacks(names)) {
+    await (0, _storage.removeFile)(path);
+  }
+  return {
+    records: names.length,
+    rows
+  };
+};
+/**
+ * Which records' packed files don't match their entry files (missing, or packed before a change made by
+ * hand), and which packed files belong to no record, without changing anything: for a build or test to check that
+ * packDatabase has run since the data last changed. Node only.
+ */
+exports.packDatabase = packDatabase;
+const checkPacked = async () => {
+  (0, _requireNode.requireNode)('checkPacked');
+  const names = await (0, _showRecords.showRecords)();
+  const stale = [];
+  for (const name of names) {
+    const packed = await packedText(name);
+    const current = (0, _storage.fileExists)(packed.path) ? await (0, _storage.readText)(packed.path).catch(() => undefined) : undefined;
+    if (typeof current === 'undefined' || JSON.stringify(JSON.parse(current)) !== packed.text) {
+      stale.push(name);
+    }
+  }
+  return {
+    stale,
+    orphaned: await orphanedPacks(names)
+  };
+};
+exports.checkPacked = checkPacked;

package/dist/data/introspect/packDatabase.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.packDatabase=exports.checkPacked=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"),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 _storage=require("../storage"),_retrieveRecord=require("../utilities/retrieveRecord"),_retrieveFiles=require("../utilities/retrieveFiles"),_retrieveRecords=require("../utilities/retrieveRecords"),_packedTable=require("../utilities/packedTable"),_showRecords=require("../queries/showRecords"),_requireNode=require("../utilities/requireNode");const packedText=async e=>{const s=await(0,_retrieveRecord.retrieveRecord)(e),r=s.entries||[],t=await(0,_retrieveFiles.retrieveFiles)(r.map((e=>`${s.path}/${e}`)),_retrieveRecords.retrieveEntry),o={entries:r,rows:t};return{path:(0,_packedTable.packedPath)(s.path),text:(0,_storage.jsonText)(o,"compact"),rows:r.length}},orphanedPacks=async e=>{const s=new Set(e.map((e=>(0,_packedTable.packedPath)(e))));return(await(0,_storage.listFiles)("__packed")).filter((e=>!s.has(e)))},packDatabase=async()=>{(0,_requireNode.requireNode)("packDatabase");const e=await(0,_showRecords.showRecords)();let s=0;for(const r of e){const e=await packedText(r);await(0,_storage.makeDirectory)(e.path.slice(0,e.path.lastIndexOf("/"))),await(0,_storage.writeJson)(e.path,JSON.parse(e.text),"compact"),s+=e.rows}for(const s of await orphanedPacks(e))await(0,_storage.removeFile)(s);return{records:e.length,rows:s}};exports.packDatabase=packDatabase;const checkPacked=async()=>{(0,_requireNode.requireNode)("checkPacked");const e=await(0,_showRecords.showRecords)(),s=[];for(const r of e){const e=await packedText(r),t=(0,_storage.fileExists)(e.path)?await(0,_storage.readText)(e.path).catch((()=>{})):void 0;void 0!==t&&JSON.stringify(JSON.parse(t))===e.text||s.push(r)}return{stale:s,orphaned:await orphanedPacks(e)}};exports.checkPacked=checkPacked;

package/dist/data/introspect/policies/foreignKeyExists.d.ts

@@ -1,6 +1,8 @@
 /**
  * Check whether any record in the referenced entity has the given property set to the given
  * value - the mirror image of keyUnique(), which checks that no record already has a value.
+ * A referenced field with an index (a foreign key usually references a primary key) is answered from it; otherwise
+ * every row is read.
  * @param entity
  * @param property
  * @param value

package/dist/data/introspect/policies/foreignKeyExists.js

@@ -8,22 +8,28 @@ var _retrieveRecords = require("../../utilities/retrieveRecords");
 var _where = require("../../queries/where");
 var _retrieveRecord = require("../../utilities/retrieveRecord");
 var _fieldType = require("../../utilities/fieldType");
+var _indexHas = require("../../utilities/indexHas");
 /**
  * Check whether any record in the referenced entity has the given property set to the given
  * value - the mirror image of keyUnique(), which checks that no record already has a value.
+ * A referenced field with an index (a foreign key usually references a primary key) is answered from it; otherwise
+ * every row is read.
  * @param entity
  * @param property
  * @param value
  */
 const foreignKeyExists = async (entity, property, value) => {
+  const found = await (0, _indexHas.indexHas)(entity, property, value);
+  if (typeof found !== 'undefined') {
+    return found;
+  }
   const records = await (0, _retrieveRecords.retrieveRecords)(entity);
   const type = (0, _fieldType.fieldType)(await (0, _retrieveRecord.retrieveRecord)(entity), property);
-  const found = (0, _where.where)(records, {
+  return (0, _where.where)(records, {
     property,
     comparator: '=',
     value,
     type
-  });
-  return found.length > 0;
+  }).length > 0;
 };
 exports.foreignKeyExists = foreignKeyExists;

package/dist/data/introspect/policies/foreignKeyExists.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.foreignKeyExists=void 0;var _retrieveRecords=require("../../utilities/retrieveRecords"),_where=require("../../queries/where"),_retrieveRecord=require("../../utilities/retrieveRecord"),_fieldType=require("../../utilities/fieldType");const foreignKeyExists=async(e,r,i)=>{const t=await(0,_retrieveRecords.retrieveRecords)(e),s=(0,_fieldType.fieldType)(await(0,_retrieveRecord.retrieveRecord)(e),r);return(0,_where.where)(t,{property:r,comparator:"=",value:i,type:s}).length>0};exports.foreignKeyExists=foreignKeyExists;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.foreignKeyExists=void 0;var _retrieveRecords=require("../../utilities/retrieveRecords"),_where=require("../../queries/where"),_retrieveRecord=require("../../utilities/retrieveRecord"),_fieldType=require("../../utilities/fieldType"),_indexHas=require("../../utilities/indexHas");const foreignKeyExists=async(e,r,i)=>{const t=await(0,_indexHas.indexHas)(e,r,i);if(void 0!==t)return t;const s=await(0,_retrieveRecords.retrieveRecords)(e),o=(0,_fieldType.fieldType)(await(0,_retrieveRecord.retrieveRecord)(e),r);return(0,_where.where)(s,{property:r,comparator:"=",value:i,type:o}).length>0};exports.foreignKeyExists=foreignKeyExists;

package/dist/data/introspect/policies/hasDependents.d.ts

@@ -2,9 +2,9 @@
  * Check whether any other record, in any entity, still has a single-field foreign key pointing
  * at entity.property = value - the mirror image of foreignKeyExists(), which checks the opposite
  * direction (that a new/updated foreign key value points at something real). Used to RESTRICT a
- * delete or update that would otherwise leave a dangling reference behind. Scans every record in
- * the database via the __RECORDS registry, the same "no index needed, just look" approach as
- * keyUnique()/foreignKeyExists() - correctness over speed, matching this project's overall scale.
+ * delete or update that would otherwise leave a dangling reference behind. Looks at every record in
+ * the database (via the __RECORDS registry) for a foreign key to entity.property. A foreign key field with an index
+ * (each one gets one) is answered from it; otherwise that record's rows are read.
  * @param entity
  * @param property
  * @param value

package/dist/data/introspect/policies/hasDependents.js

@@ -10,13 +10,14 @@ var _retrieveRecords = require("../../utilities/retrieveRecords");
 var _where = require("../../queries/where");
 var _fieldType = require("../../utilities/fieldType");
 var _splitEntityProperty = require("../../utilities/parsers/splitEntityProperty");
+var _indexHas = require("../../utilities/indexHas");
 /**
  * Check whether any other record, in any entity, still has a single-field foreign key pointing
  * at entity.property = value - the mirror image of foreignKeyExists(), which checks the opposite
  * direction (that a new/updated foreign key value points at something real). Used to RESTRICT a
- * delete or update that would otherwise leave a dangling reference behind. Scans every record in
- * the database via the __RECORDS registry, the same "no index needed, just look" approach as
- * keyUnique()/foreignKeyExists() - correctness over speed, matching this project's overall scale.
+ * delete or update that would otherwise leave a dangling reference behind. Looks at every record in
+ * the database (via the __RECORDS registry) for a foreign key to entity.property. A foreign key field with an index
+ * (each one gets one) is answered from it; otherwise that record's rows are read.
  * @param entity
  * @param property
  * @param value
@@ -37,6 +38,13 @@ const hasDependents = async (entity, property, value) => {
       if (refEntity !== entity || refProperty !== property) {
         continue;
       }
+      const indexed = await (0, _indexHas.indexHas)(otherEntity, key.fields[0], value);
+      if (typeof indexed !== 'undefined') {
+        if (indexed) {
+          return true;
+        }
+        continue;
+      }
       const records = await (0, _retrieveRecords.retrieveRecords)(otherEntity);
       const found = (0, _where.where)(records, {
         property: key.fields[0],

package/dist/data/introspect/policies/hasDependents.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.hasDependents=void 0;var _describe=require("../describe"),_retrieveRecord=require("../../utilities/retrieveRecord"),_retrieveRecords=require("../../utilities/retrieveRecords"),_where=require("../../queries/where"),_fieldType=require("../../utilities/fieldType"),_splitEntityProperty=require("../../utilities/parsers/splitEntityProperty");const hasDependents=async(e,r,t)=>{const i=await(0,_describe.describe)();for(const s of i){const i=s.replace(/\.json$/,""),o=await(0,_retrieveRecord.retrieveRecord)(i);for(const s of o.keys){if("foreign"!==s.type||1!==s.fields.length||!s.references||1!==s.references.length)continue;const{entity:n,property:c}=(0,_splitEntityProperty.splitEntityProperty)(s.references[0].fields[0]);if(n!==e||c!==r)continue;const p=await(0,_retrieveRecords.retrieveRecords)(i);if((0,_where.where)(p,{property:s.fields[0],comparator:"=",value:t,type:(0,_fieldType.fieldType)(o,s.fields[0])}).length)return!0}}return!1};exports.hasDependents=hasDependents;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.hasDependents=void 0;var _describe=require("../describe"),_retrieveRecord=require("../../utilities/retrieveRecord"),_retrieveRecords=require("../../utilities/retrieveRecords"),_where=require("../../queries/where"),_fieldType=require("../../utilities/fieldType"),_splitEntityProperty=require("../../utilities/parsers/splitEntityProperty"),_indexHas=require("../../utilities/indexHas");const hasDependents=async(e,r,i)=>{const t=await(0,_describe.describe)();for(const s of t){const t=s.replace(/\.json$/,""),n=await(0,_retrieveRecord.retrieveRecord)(t);for(const s of n.keys){if("foreign"!==s.type||1!==s.fields.length||!s.references||1!==s.references.length)continue;const{entity:o,property:d}=(0,_splitEntityProperty.splitEntityProperty)(s.references[0].fields[0]);if(o!==e||d!==r)continue;const c=await(0,_indexHas.indexHas)(t,s.fields[0],i);if(void 0!==c){if(c)return!0;continue}const p=await(0,_retrieveRecords.retrieveRecords)(t);if((0,_where.where)(p,{property:s.fields[0],comparator:"=",value:i,type:(0,_fieldType.fieldType)(n,s.fields[0])}).length)return!0}}return!1};exports.hasDependents=hasDependents;

package/dist/data/introspect/policies/keyUnique.d.ts

@@ -2,6 +2,9 @@
  * Check that no existing record already has this combination of values across all of the given
  * fields - a single field for a normal unique/primary key, or several for a composite one.
  * references and checkKeys are parallel arrays: references[i]'s value must equal checkKeys[i].
+ *
+ * One field with an index (every primary and unique key has one) is answered from the index; a composite key, or a
+ * field without one, reads every row.
  * @param entity
  * @param references
  * @param checkKeys

package/dist/data/introspect/policies/keyUnique.js

@@ -8,10 +8,14 @@ var _retrieveRecords = require("../../utilities/retrieveRecords");
 var _where = require("../../queries/where");
 var _retrieveRecord = require("../../utilities/retrieveRecord");
 var _fieldType = require("../../utilities/fieldType");
+var _indexHas = require("../../utilities/indexHas");
 /**
  * Check that no existing record already has this combination of values across all of the given
  * fields - a single field for a normal unique/primary key, or several for a composite one.
  * references and checkKeys are parallel arrays: references[i]'s value must equal checkKeys[i].
+ *
+ * One field with an index (every primary and unique key has one) is answered from the index; a composite key, or a
+ * field without one, reads every row.
  * @param entity
  * @param references
  * @param checkKeys
@@ -20,6 +24,12 @@ const keyUnique = async (entity, references = [], checkKeys = []) => {
   if (!references.length || references.length !== checkKeys.length) {
     return false;
   }
+  if (references.length === 1) {
+    const found = await (0, _indexHas.indexHas)(entity, references[0], checkKeys[0]);
+    if (typeof found !== 'undefined') {
+      return !found;
+    }
+  }
   let records = await (0, _retrieveRecords.retrieveRecords)(entity);
   const record = await (0, _retrieveRecord.retrieveRecord)(entity);
   for (let i = 0; i < references.length; i++) {

package/dist/data/introspect/policies/keyUnique.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.keyUnique=void 0;var _retrieveRecords=require("../../utilities/retrieveRecords"),_where=require("../../queries/where"),_retrieveRecord=require("../../utilities/retrieveRecord"),_fieldType=require("../../utilities/fieldType");const keyUnique=async(e,r=[],t=[])=>{if(!r.length||r.length!==t.length)return!1;let i=await(0,_retrieveRecords.retrieveRecords)(e);const o=await(0,_retrieveRecord.retrieveRecord)(e);for(let e=0;e<r.length;e++)i=(0,_where.where)(i,{property:r[e],comparator:"=",value:t[e],type:(0,_fieldType.fieldType)(o,r[e])});return!i.length};exports.keyUnique=keyUnique;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.keyUnique=void 0;var _retrieveRecords=require("../../utilities/retrieveRecords"),_where=require("../../queries/where"),_retrieveRecord=require("../../utilities/retrieveRecord"),_fieldType=require("../../utilities/fieldType"),_indexHas=require("../../utilities/indexHas");const keyUnique=async(e,r=[],i=[])=>{if(!r.length||r.length!==i.length)return!1;if(1===r.length){const t=await(0,_indexHas.indexHas)(e,r[0],i[0]);if(void 0!==t)return!t}let t=await(0,_retrieveRecords.retrieveRecords)(e);const s=await(0,_retrieveRecord.retrieveRecord)(e);for(let e=0;e<r.length;e++)t=(0,_where.where)(t,{property:r[e],comparator:"=",value:i[e],type:(0,_fieldType.fieldType)(s,r[e])});return!t.length};exports.keyUnique=keyUnique;

package/dist/data/queries/databaseStatements.d.ts

@@ -0,0 +1,31 @@
+/**
+ * `create database [if not exists] <name>`: a new, empty database in the folder holding them (databasesPath). It
+ * doesn't switch to it (see use). The name is listed before the folder is made, so a stop part way leaves a listed
+ * database whose folder appears with its first record, never a folder no list names. A folder that's there but not
+ * listed (copied in by hand, or left by an older version) is listed by `if not exists`. Node only.
+ * @param name
+ * @param ifNotExists
+ * @returns The name, or null when it existed and `if not exists` was given.
+ */
+export declare const createDatabase: (name: string, ifNotExists?: boolean) => Promise<string | null>;
+/**
+ * `drop database [if exists] <name>`: delete a database, its records and every row in them. The database in use can't
+ * be dropped (use another one first). Node only.
+ * @param name
+ * @param ifExists
+ * @returns The name, or null when it didn't exist and `if exists` was given.
+ */
+export declare const dropDatabase: (name: string, ifExists?: boolean) => Promise<string | null>;
+/**
+ * `use <name>`: switch to another database in the folder holding them, for the rest of the call and the calls after it
+ * (as configure({ database }) does). Works in a browser too (reading only), for a database listed in
+ * `__DATABASES.json`, while no other call is running in the page.
+ * @param name
+ * @returns The name.
+ */
+export declare const useDatabase: (name: string) => Promise<string>;
+/**
+ * `show databases`: the databases' names, in the order they were created.
+ */
+export declare const showDatabases: () => Promise<string[]>;
+//# sourceMappingURL=databaseStatements.d.ts.map

package/dist/data/queries/databaseStatements.js

@@ -0,0 +1,97 @@
+"use strict";
+
+require("core-js/modules/esnext.weak-map.delete-all.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useDatabase = exports.showDatabases = exports.dropDatabase = exports.createDatabase = void 0;
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.filter.js");
+var jsEnv = _interopRequireWildcard(require("browser-or-node"));
+var _config = require("../utilities/config");
+var _requireNode = require("../utilities/requireNode");
+var _databaseLock = require("../utilities/databaseLock");
+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; }
+/**
+ * Whether a database exists: listed in `__DATABASES.json`, or (in Node) a folder of that name is there.
+ * @param name
+ */
+const databaseExists = async name => (await (0, _storage.readDatabaseList)()).includes(name) || jsEnv.isNode && (0, _storage.databaseFolderExists)(name);
+/**
+ * `create database [if not exists] <name>`: a new, empty database in the folder holding them (databasesPath). It
+ * doesn't switch to it (see use). The name is listed before the folder is made, so a stop part way leaves a listed
+ * database whose folder appears with its first record, never a folder no list names. A folder that's there but not
+ * listed (copied in by hand, or left by an older version) is listed by `if not exists`. Node only.
+ * @param name
+ * @param ifNotExists
+ * @returns The name, or null when it existed and `if not exists` was given.
+ */
+const createDatabase = async (name, ifNotExists = false) => {
+  (0, _requireNode.requireNode)('"create database"');
+  const listed = await (0, _storage.readDatabaseList)();
+  if (listed.includes(name) || (0, _storage.databaseFolderExists)(name)) {
+    if (!ifNotExists) {
+      throw new Error(listed.includes(name) ? `Database "${name}" already exists` : `Database "${name}" already exists as a folder that isn't listed: create database if not exists ${name} lists it`);
+    }
+    if (!listed.includes(name)) {
+      await (0, _storage.writeDatabaseList)([...listed, name]);
+    }
+    return null;
+  }
+  await (0, _storage.writeDatabaseList)([...listed, name]);
+  await (0, _storage.makeDatabaseFolder)(name);
+  return name;
+};
+/**
+ * `drop database [if exists] <name>`: delete a database, its records and every row in them. The database in use can't
+ * be dropped (use another one first). Node only.
+ * @param name
+ * @param ifExists
+ * @returns The name, or null when it didn't exist and `if exists` was given.
+ */
+exports.createDatabase = createDatabase;
+const dropDatabase = async (name, ifExists = false) => {
+  (0, _requireNode.requireNode)('"drop database"');
+  if (!(await databaseExists(name))) {
+    if (ifExists) {
+      return null;
+    }
+    throw new Error(`Database "${name}" doesn't exist`);
+  }
+  if ((0, _config.getSetting)('database', undefined) === name) {
+    throw new Error(`Can't drop the database in use ("${name}"): use another one first`);
+  }
+  // Unlisted first: a stop part way leaves a folder no list names, never a listed database with no folder
+  await (0, _storage.writeDatabaseList)((await (0, _storage.readDatabaseList)()).filter(listed => listed !== name));
+  await (0, _storage.removeDatabaseFolder)(name);
+  return name;
+};
+/**
+ * `use <name>`: switch to another database in the folder holding them, for the rest of the call and the calls after it
+ * (as configure({ database }) does). Works in a browser too (reading only), for a database listed in
+ * `__DATABASES.json`, while no other call is running in the page.
+ * @param name
+ * @returns The name.
+ */
+exports.dropDatabase = dropDatabase;
+const useDatabase = async name => {
+  // A browser runs calls side by side (see withDatabaseLock), and there's one database in use for the page: switching
+  // now would move the other calls to it part way
+  if (!jsEnv.isNode && (0, _databaseLock.browserCallsRunning)() > 1) {
+    throw new Error(`Can't use "${name}" while other calls are running in this page: await them first, or pick the database with configure({ database }) between calls`);
+  }
+  if (!(await databaseExists(name))) {
+    throw new Error(`Database "${name}" doesn't exist${jsEnv.isNode ? '' : ' (or isn\'t listed in __DATABASES.json)'}`);
+  }
+  (0, _config.switchDatabase)(name);
+  return name;
+};
+/**
+ * `show databases`: the databases' names, in the order they were created.
+ */
+exports.useDatabase = useDatabase;
+const showDatabases = async () => (0, _storage.readDatabaseList)();
+exports.showDatabases = showDatabases;

package/dist/data/queries/databaseStatements.min.js

@@ -0,0 +1 @@
+"use strict";require("core-js/modules/esnext.weak-map.delete-all.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.useDatabase=exports.showDatabases=exports.dropDatabase=exports.createDatabase=void 0,require("core-js/modules/es.array.includes.js"),require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.js");var e,jsEnv=_interopRequireWildcard(require("browser-or-node")),_config=require("../utilities/config"),_requireNode=require("../utilities/requireNode"),_databaseLock=require("../utilities/databaseLock"),_storage=require("../storage");function _interopRequireWildcard(a,t){if(!t&&a&&a.__esModule)return a;var s,r,i=Object.defineProperty,o={__proto__:null,default:a};if(Object(a)!==a)return o;if(e||"function"!=typeof WeakMap||(e=new WeakMap),e){if(e.has(a))return e.get(a);e.set(a,o)}for(r in a)"default"!==r&&{}.hasOwnProperty.call(a,r)&&((s=i&&Object.getOwnPropertyDescriptor(a,r))&&(s.get||s.set)?i(o,r,s):o[r]=a[r]);return o}const databaseExists=async e=>(await(0,_storage.readDatabaseList)()).includes(e)||jsEnv.isNode&&(0,_storage.databaseFolderExists)(e),createDatabase=async(e,a=!1)=>{(0,_requireNode.requireNode)('"create database"');const t=await(0,_storage.readDatabaseList)();if(t.includes(e)||(0,_storage.databaseFolderExists)(e)){if(!a)throw new Error(t.includes(e)?`Database "${e}" already exists`:`Database "${e}" already exists as a folder that isn't listed: create database if not exists ${e} lists it`);return t.includes(e)||await(0,_storage.writeDatabaseList)([...t,e]),null}return await(0,_storage.writeDatabaseList)([...t,e]),await(0,_storage.makeDatabaseFolder)(e),e};exports.createDatabase=createDatabase;const dropDatabase=async(e,a=!1)=>{if((0,_requireNode.requireNode)('"drop database"'),!await databaseExists(e)){if(a)return null;throw new Error(`Database "${e}" doesn't exist`)}if((0,_config.getSetting)("database",void 0)===e)throw new Error(`Can't drop the database in use ("${e}"): use another one first`);return await(0,_storage.writeDatabaseList)((await(0,_storage.readDatabaseList)()).filter((a=>a!==e))),await(0,_storage.removeDatabaseFolder)(e),e};exports.dropDatabase=dropDatabase;const useDatabase=async e=>{if(!jsEnv.isNode&&(0,_databaseLock.browserCallsRunning)()>1)throw new Error(`Can't use "${e}" while other calls are running in this page: await them first, or pick the database with configure({ database }) between calls`);if(!await databaseExists(e))throw new Error(`Database "${e}" doesn't exist${jsEnv.isNode?"":" (or isn't listed in __DATABASES.json)"}`);return(0,_config.switchDatabase)(e),e};exports.useDatabase=useDatabase;const showDatabases=async()=>(0,_storage.readDatabaseList)();exports.showDatabases=showDatabases;

package/dist/data/queries/deleteEntity.js

@@ -4,8 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.deleteEntity = 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.find.js");
 require("core-js/modules/esnext.iterator.map.js");
 require("core-js/modules/esnext.set.add-all.js");
@@ -31,10 +31,9 @@ var _computeKeyValue = require("../utilities/computeKeyValue");
 var _fieldType = require("../utilities/fieldType");
 var _hasDependents = require("../introspect/policies/hasDependents");
 var _config = require("../utilities/config");
-const {
-  rm,
-  writeFile
-} = require('fs/promises');
+var _keyIndexFiles = require("../utilities/keyIndexFiles");
+var _storage = require("../storage");
+var _packedTable = require("../utilities/packedTable");
 /**
  * RESTRICT: reject the whole delete (before removing anything) if any row being deleted is still
  * referenced by a single-field foreign key elsewhere. Only meaningful for a single-field primary
@@ -57,32 +56,45 @@ const assertNoDependents = async (entity, primaryKey, toDelete) => {
 };
 /**
  * A record object carries no memory of which entry file it was read from, and files are not
- * guaranteed to be named after any field's value, so the only reliable way to find a record's
- * file is to re-scan every entry and match it by its primary key value(s) - a single field, or a
- * composite of several for a multi-field primary key.
+ * guaranteed to be named after any field's value, so a deleted row's file is found by its primary
+ * key value(s) - a single field, or a composite of several for a multi-field primary key. The
+ * primary key's index says which files those are (each is read to confirm it); any deleted value
+ * the index didn't lead to, or a record without one, is found by looking at every entry, as before.
+ * Inserts and updates keep primary key values unique, so each value is one row: only a database
+ * edited by hand into two rows of one value, with an index listing just one, would keep the other
+ * (looking at every entry used to delete both).
  * @param entity
  * @param record
  * @param primaryKey
  * @param deletedValues
  */
 const removeMatchingEntries = async (entity, record, primaryKey, deletedValues) => {
-  const databasePath = (0, _config.getSetting)('databasePath', 'database/');
-  const remainingEntries = [];
-  for (const fileName of record.entries) {
+  const removed = new Set();
+  const found = new Set();
+  const removeIfDeleted = async fileName => {
     const data = await (0, _retrieveFile.retrieveFile)(`${record.path}/${fileName}`);
-    if (!deletedValues.has((0, _computeKeyValue.computeKeyValue)(primaryKey.fields, data))) {
-      remainingEntries.push(fileName);
-      continue;
+    const value = (0, _computeKeyValue.computeKeyValue)(primaryKey.fields, data);
+    if (!deletedValues.has(value)) {
+      return;
     }
-    await rm(`${databasePath}${record.path}/${fileName}`);
+    await (0, _storage.removeFile)(`${record.path}/${fileName}`);
     for (const key of record.keys) {
       await (0, _removeFromIndex.removeFromIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, data), fileName, (0, _fieldType.keyValueType)(record, key));
     }
+    removed.add(fileName);
+    found.add(value);
+  };
+  for (const fileName of (await (0, _keyIndexFiles.keyIndexFiles)(record, primaryKey, value => deletedValues.has(value))) ?? []) {
+    await removeIfDeleted(fileName);
   }
-  return remainingEntries;
+  if (found.size < deletedValues.size) {
+    for (const fileName of record.entries.filter(entry => !removed.has(entry))) {
+      await removeIfDeleted(fileName);
+    }
+  }
+  return record.entries.filter(fileName => !removed.has(fileName));
 };
 const deleteEntity = async (entity = '', dataSet = {}) => {
-  const databasePath = (0, _config.getSetting)('databasePath', 'database/');
   const record = await (0, _retrieveRecord.retrieveRecord)(entity);
   const primaryKey = record.keys.find(key => key.type === 'primary');
   if (!primaryKey) {
@@ -94,8 +106,12 @@ const deleteEntity = async (entity = '', dataSet = {}) => {
   }
   await assertNoDependents(entity, primaryKey, toDelete);
   const deletedValues = new Set(toDelete.map(row => (0, _computeKeyValue.computeKeyValue)(primaryKey.fields, row)));
-  record.entries = await removeMatchingEntries(entity, record, primaryKey, deletedValues);
-  await writeFile(`${databasePath}${record.path}.json`, JSON.stringify(record, null, 2));
+  const remaining = await removeMatchingEntries(entity, record, primaryKey, deletedValues);
+  if (remaining.length !== record.entries.length) {
+    await (0, _packedTable.discardPacked)(record.path);
+  }
+  record.entries = remaining;
+  await (0, _storage.writeJson)(`${record.path}.json`, record);
   return dataSet;
 };
 exports.deleteEntity = deleteEntity;

package/dist/data/queries/deleteEntity.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.deleteEntity=void 0,require("core-js/modules/es.json.stringify.js"),require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.find.js"),require("core-js/modules/esnext.iterator.map.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 _retrieveRecord=require("../utilities/retrieveRecord"),_retrieveFile=require("../utilities/retrieveFile"),_removeFromIndex=require("../utilities/removeFromIndex"),_computeKeyValue=require("../utilities/computeKeyValue"),_fieldType=require("../utilities/fieldType"),_hasDependents=require("../introspect/policies/hasDependents"),_config=require("../utilities/config");const{rm:rm,writeFile:writeFile}=require("fs/promises"),assertNoDependents=async(e,r,s)=>{if(!(0,_config.getSetting)("enforceForeignKeys",!0)||1!==r.fields.length)return;const t=r.fields[0];for(const r of s)if(await(0,_hasDependents.hasDependents)(e,t,r[t]))throw new Error(`Cannot delete from "${e}" where "${t}" = ${r[t]} - other records still reference it`)},removeMatchingEntries=async(e,r,s,t)=>{const i=(0,_config.getSetting)("databasePath","database/"),o=[];for(const e of r.entries){const n=await(0,_retrieveFile.retrieveFile)(`${r.path}/${e}`);if(t.has((0,_computeKeyValue.computeKeyValue)(s.fields,n))){await rm(`${i}${r.path}/${e}`);for(const s of r.keys)await(0,_removeFromIndex.removeFromIndex)(r.path,s,(0,_computeKeyValue.computeKeyValue)(s.fields,n),e,(0,_fieldType.keyValueType)(r,s))}else o.push(e)}return o},deleteEntity=async(e="",r={})=>{const s=(0,_config.getSetting)("databasePath","database/"),t=await(0,_retrieveRecord.retrieveRecord)(e),i=t.keys.find((e=>"primary"===e.type));if(!i)throw new Error(`Cannot delete from "${e}" without a primary key`);const o=r[e]||[];if(!o.length)return r;await assertNoDependents(e,i,o);const n=new Set(o.map((e=>(0,_computeKeyValue.computeKeyValue)(i.fields,e))));return t.entries=await removeMatchingEntries(0,t,i,n),await writeFile(`${s}${t.path}.json`,JSON.stringify(t,null,2)),r};exports.deleteEntity=deleteEntity;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.deleteEntity=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.js"),require("core-js/modules/esnext.iterator.find.js"),require("core-js/modules/esnext.iterator.map.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 _retrieveRecord=require("../utilities/retrieveRecord"),_retrieveFile=require("../utilities/retrieveFile"),_removeFromIndex=require("../utilities/removeFromIndex"),_computeKeyValue=require("../utilities/computeKeyValue"),_fieldType=require("../utilities/fieldType"),_hasDependents=require("../introspect/policies/hasDependents"),_config=require("../utilities/config"),_keyIndexFiles=require("../utilities/keyIndexFiles"),_storage=require("../storage"),_packedTable=require("../utilities/packedTable");const assertNoDependents=async(e,r,s)=>{if(!(0,_config.getSetting)("enforceForeignKeys",!0)||1!==r.fields.length)return;const t=r.fields[0];for(const r of s)if(await(0,_hasDependents.hasDependents)(e,t,r[t]))throw new Error(`Cannot delete from "${e}" where "${t}" = ${r[t]} - other records still reference it`)},removeMatchingEntries=async(e,r,s,t)=>{const i=new Set,o=new Set,n=async e=>{const n=await(0,_retrieveFile.retrieveFile)(`${r.path}/${e}`),u=(0,_computeKeyValue.computeKeyValue)(s.fields,n);if(t.has(u)){await(0,_storage.removeFile)(`${r.path}/${e}`);for(const s of r.keys)await(0,_removeFromIndex.removeFromIndex)(r.path,s,(0,_computeKeyValue.computeKeyValue)(s.fields,n),e,(0,_fieldType.keyValueType)(r,s));i.add(e),o.add(u)}};for(const e of await(0,_keyIndexFiles.keyIndexFiles)(r,s,(e=>t.has(e)))??[])await n(e);if(o.size<t.size)for(const e of r.entries.filter((e=>!i.has(e))))await n(e);return r.entries.filter((e=>!i.has(e)))},deleteEntity=async(e="",r={})=>{const s=await(0,_retrieveRecord.retrieveRecord)(e),t=s.keys.find((e=>"primary"===e.type));if(!t)throw new Error(`Cannot delete from "${e}" without a primary key`);const i=r[e]||[];if(!i.length)return r;await assertNoDependents(e,t,i);const o=new Set(i.map((e=>(0,_computeKeyValue.computeKeyValue)(t.fields,e)))),n=await removeMatchingEntries(0,s,t,o);return n.length!==s.entries.length&&await(0,_packedTable.discardPacked)(s.path),s.entries=n,await(0,_storage.writeJson)(`${s.path}.json`,s),r};exports.deleteEntity=deleteEntity;

package/dist/data/queries/insertEntity.d.ts

@@ -1,2 +1,10 @@
+/**
+ * Insert rows into a record, all in one statement: every row is checked (against the rows in storage and the rows
+ * before it in the statement) and its entry file written, then the record file and each index are written once.
+ * Inside a write set (as every query runs, see withWriteSet) a row that fails leaves none of them written.
+ * @param entity
+ * @param values - The rows, as field -> value.
+ * @param dataSet
+ */
 export declare const insertEntity: (entity?: string, values?: Object[], dataSet?: Object) => Promise<Object>;
 //# sourceMappingURL=insertEntity.d.ts.map