json-fs-query 3.2.0 → 3.3.0

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

@@ -0,0 +1,12 @@
+import { fieldDefinition } from './definitions/field';
+import { ParsedAlter } from '../utilities/parsers/parseAlter';
+/**
+ * Change one field of an existing record (see ParsedAlter): add, drop or rename it, or change whether it's optional or
+ * nullable and its default. The public version runs as one statement (see withWriteSet): a change that fails part way
+ * changes nothing. Node only.
+ * @param entity
+ * @param change
+ * @returns The record's new field definitions (as describe gives them).
+ */
+export declare const alter: (entity: string, change: ParsedAlter) => Promise<fieldDefinition[]>;
+//# sourceMappingURL=alter.d.ts.map

package/dist/data/introspect/alter.js

@@ -0,0 +1,304 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.alter = void 0;
+require("core-js/modules/es.array.includes.js");
+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.iterator.some.js");
+var _field = require("./definitions/field");
+var _create = require("./create");
+var _parseCreate = require("../utilities/parsers/parseCreate");
+var _retrieveRecord = require("../utilities/retrieveRecord");
+var _retrieveFiles = require("../utilities/retrieveFiles");
+var _retrieveRecords = require("../utilities/retrieveRecords");
+var _knownFields = require("../utilities/knownFields");
+var _packedTable = require("../utilities/packedTable");
+var _requireNode = require("../utilities/requireNode");
+var _showRecords = require("../queries/showRecords");
+var _updateEntity = require("../queries/updateEntity");
+var _typeCheck = require("./policies/typeCheck");
+var _storage = require("../storage");
+/**
+ * Every row of a record, with the entry file it's in.
+ * @param record
+ */
+const rowsOf = async record => {
+  const rows = await (0, _retrieveFiles.retrieveFiles)(record.entries.map(file => `${record.path}/${file}`), _retrieveRecords.retrieveEntry);
+  return rows.map((data, position) => ({
+    fileName: record.entries[position],
+    data
+  }));
+};
+const has = (row, name) => Object.prototype.hasOwnProperty.call(row, name);
+/** The keys of a record that use a field. */
+const keysUsing = (record, name) => record.keys.filter(key => key.fields.includes(name));
+const describeKey = key => `${key.type} key (${key.fields.join(', ')})`;
+/**
+ * Every record's foreign keys that reference `<entity>.<name>`, with the record they're on.
+ * @param entity
+ * @param name
+ */
+const referencesTo = async (entity, name) => {
+  const found = [];
+  for (const other of await (0, _showRecords.showRecords)()) {
+    const record = await (0, _retrieveRecord.retrieveRecord)(other);
+    for (const key of record.keys) {
+      if (key.type === 'foreign' && (key.references || []).some(reference => reference.fields.includes(`${entity}.${name}`))) {
+        found.push({
+          entity: other,
+          record,
+          key
+        });
+      }
+    }
+  }
+  return found;
+};
+/**
+ * Write the record's new definition, after checking it as create checks a new one (defaults fit their types, keys name
+ * defined fields, primary key fields aren't nullable).
+ * @param entity
+ * @param record
+ */
+const writeRecord = async (entity, record) => {
+  (0, _create.assertValidDefinition)(entity, record);
+  await (0, _storage.writeJson)(`${entity}.json`, record);
+};
+/**
+ * Give `rows` a value for `name` (or, with undefined, remove it). A field no key uses is written straight into each
+ * entry file. For a field a key uses, the rows go through update, as `update <entity> set <name> = ...` would change
+ * them, so the key's index moves with them and its checks (uniqueness, foreign keys) apply; that needs the record's
+ * new definition written first, and a primary key to find each row by.
+ * @param entity
+ * @param record - The record's new definition.
+ * @param rows
+ * @param name
+ * @param value - The value, or a function giving each row's; undefined removes the field.
+ */
+const setField = async (entity, record, rows, name, value) => {
+  if (!rows.length) {
+    return;
+  }
+  await (0, _packedTable.discardPacked)(record.path);
+  if (keysUsing(record, name).length && typeof value !== 'function') {
+    if (!record.keys.some(key => key.type === 'primary')) {
+      throw new Error(`Can't change "${name}" on ${entity}'s rows: a key uses it, and rows are found by the primary key, which ${entity} doesn't have`);
+    }
+    // update reads null in an optional field that isn't nullable as removing it (see updateEntity)
+    await (0, _updateEntity.updateEntity)(entity, {
+      [name]: typeof value === 'undefined' ? null : value
+    }, {
+      [entity]: rows.map(row => row.data)
+    });
+    return;
+  }
+  for (const row of rows) {
+    const changed = Object.assign({}, row.data);
+    const next = typeof value === 'function' ? value(row) : value;
+    if (typeof next === 'undefined') {
+      delete changed[name];
+    } else {
+      changed[name] = next;
+    }
+    await (0, _storage.writeJson)(`${record.path}/${row.fileName}`, changed);
+  }
+};
+/**
+ * Add a field. Existing rows get its default, or a new id for an `auto` field; with neither, it must be optional (the
+ * rows would otherwise be missing a required field). A row that already holds a value under the name (written before
+ * the field was defined) keeps it, if it fits the type.
+ */
+const addField = async (entity, record, added) => {
+  if (record.definition.some(field => field.name === added.name)) {
+    throw new Error(`Field "${added.name}" already exists on ${entity}`);
+  }
+  const updated = {
+    ...record,
+    definition: [...record.definition, added]
+  };
+  const rows = await rowsOf(record);
+  for (const row of rows.filter(row => has(row.data, added.name))) {
+    try {
+      (0, _typeCheck.typeCheck)(added.type, row.data[added.name], added.nullable);
+    } catch (error) {
+      throw new Error(`Can't add "${added.name}" to ${entity}: row ${row.fileName} already holds a value for it that doesn't fit (${error.message})`);
+    }
+  }
+  const missing = rows.filter(row => !has(row.data, added.name));
+  const hasDefault = has(added, 'default');
+  if (missing.length && !added.optional && !hasDefault && !added.autoGenerate) {
+    throw new Error(`Can't add required field "${added.name}" to ${entity}: its ${missing.length} row(s) have no value for it (give it a default, or make it optional)`);
+  }
+  await writeRecord(entity, updated);
+  if (added.autoGenerate) {
+    await setField(entity, updated, missing, added.name, () => crypto.randomUUID());
+  } else if (hasDefault) {
+    await setField(entity, updated, missing, added.name, added['default']);
+  }
+  return updated;
+};
+/**
+ * Drop a field, removing it from every row. Refused while a key uses it, or another record's foreign key references it
+ * (drop or change those first).
+ */
+const dropField = async (entity, record, name) => {
+  (0, _knownFields.assertFieldsDefined)(entity, record, [name], 'alter');
+  const key = keysUsing(record, name)[0];
+  if (key) {
+    throw new Error(`Can't drop "${name}" from ${entity}: its ${describeKey(key)} uses it`);
+  }
+  const reference = (await referencesTo(entity, name))[0];
+  if (reference) {
+    throw new Error(`Can't drop "${name}" from ${entity}: ${reference.entity}'s foreign key "${reference.key.fields[0]}" references it`);
+  }
+  const updated = {
+    ...record,
+    definition: record.definition.filter(field => field.name !== name)
+  };
+  await writeRecord(entity, updated);
+  await setField(entity, updated, (await rowsOf(record)).filter(row => has(row.data, name)), name, undefined);
+  return updated;
+};
+/**
+ * Rename a field: in the definition, in every row, in the record's keys (moving an index file named after the field to
+ * its new name), and in every foreign key that references it.
+ */
+const renameField = async (entity, record, name, to) => {
+  (0, _knownFields.assertFieldsDefined)(entity, record, [name], 'alter');
+  if (record.definition.some(field => field.name === to)) {
+    throw new Error(`Can't rename "${name}" on ${entity} to "${to}": a field of that name already exists`);
+  }
+  const references = await referencesTo(entity, name);
+  const keys = record.keys.map(key => {
+    if (!key.fields.includes(name)) {
+      return key;
+    }
+    const fields = key.fields.map(field => field === name ? to : field);
+    // An index file create named after the fields moves to the new name; a name given some other way stays
+    const lookup = key.lookup && key.lookup === (0, _parseCreate.keyLookup)(key.type, key.fields) ? (0, _parseCreate.keyLookup)(key.type, fields) : key.lookup;
+    return {
+      ...key,
+      fields,
+      lookup
+    };
+  });
+  const renameReferences = key => key.type !== 'foreign' ? key : {
+    ...key,
+    references: (key.references || []).map(reference => ({
+      ...reference,
+      fields: reference.fields.map(field => field === `${entity}.${name}` ? `${entity}.${to}` : field)
+    }))
+  };
+  const updated = {
+    ...record,
+    definition: record.definition.map(field => field.name === name ? {
+      ...field,
+      name: to
+    } : field),
+    keys: keys.map(renameReferences)
+  };
+  for (const [position, key] of record.keys.entries()) {
+    const moved = keys[position].lookup;
+    if (key.lookup && moved !== key.lookup && (0, _storage.fileExists)(`__indexes/${record.path}/${key.lookup}`)) {
+      await (0, _storage.writeJson)(`__indexes/${record.path}/${moved}`, await (0, _storage.readJson)(`__indexes/${record.path}/${key.lookup}`));
+      await (0, _storage.removeFile)(`__indexes/${record.path}/${key.lookup}`);
+    }
+  }
+  await writeRecord(entity, updated);
+  for (const reference of references.filter(reference => reference.entity !== entity)) {
+    await (0, _storage.writeJson)(`${reference.entity}.json`, {
+      ...reference.record,
+      keys: reference.record.keys.map(renameReferences)
+    });
+  }
+  // Each row's value moves to the new name (the indexes hold values, not names, so they only moved file)
+  const rows = (await rowsOf(record)).filter(row => has(row.data, name));
+  if (rows.length) {
+    await (0, _packedTable.discardPacked)(record.path);
+  }
+  for (const row of rows) {
+    const moved = Object.assign({}, row.data);
+    moved[to] = moved[name];
+    delete moved[name];
+    await (0, _storage.writeJson)(`${record.path}/${row.fileName}`, moved);
+  }
+  return updated;
+};
+/**
+ * Change a field's definition: whether it's optional or nullable, and its default (its type, and whether it's auto,
+ * stay). The statement gives the whole new definition, as MySQL's MODIFY does: what it leaves out is cleared, so a
+ * default it doesn't repeat is removed, as `optional` or `null` left out make the field required or not nullable. Rows that would no longer fit are filled with the new default, or the change is refused: a field made
+ * required needs a value in every row, and one made not nullable can't hold null (an optional one then has no value,
+ * as null means in an optional field).
+ */
+const modifyField = async (entity, record, changed) => {
+  (0, _knownFields.assertFieldsDefined)(entity, record, [changed.name], 'alter');
+  const current = record.definition.find(field => field.name === changed.name);
+  if (current.type !== changed.type) {
+    throw new Error(`Can't change the type of "${changed.name}" on ${entity} (${current.type} to ${changed.type}): only optional, null and default can change`);
+  }
+  if (Boolean(current.autoGenerate) !== Boolean(changed.autoGenerate)) {
+    throw new Error(`Can't change whether "${changed.name}" on ${entity} is auto: only optional, null and default can change`);
+  }
+  const updated = {
+    ...record,
+    definition: record.definition.map(field => field.name === changed.name ? changed : field)
+  };
+  const rows = await rowsOf(record);
+  const hasDefault = has(changed, 'default');
+  const holdsNull = changed.nullable ? [] : rows.filter(row => row.data[changed.name] === null);
+  const missing = changed.optional ? [] : rows.filter(row => !has(row.data, changed.name));
+  const unfillable = changed.optional ? [] : holdsNull;
+  if ((missing.length || unfillable.length) && !hasDefault) {
+    throw missing.length ? new Error(`Can't make "${changed.name}" required on ${entity}: ${missing.length} row(s) have no value for it (give it a default to fill them in)`) : new Error(`Can't make "${changed.name}" not null on ${entity}: ${unfillable.length} row(s) hold null (give it a default to fill them in, or make it optional)`);
+  }
+  await writeRecord(entity, updated);
+  if (hasDefault) {
+    await setField(entity, updated, [...missing, ...unfillable], changed.name, changed['default']);
+  }
+  if (changed.optional && holdsNull.length) {
+    await setField(entity, updated, holdsNull, changed.name, undefined);
+  }
+  return updated;
+};
+/**
+ * Change one field of an existing record (see ParsedAlter): add, drop or rename it, or change whether it's optional or
+ * nullable and its default. The public version runs as one statement (see withWriteSet): a change that fails part way
+ * changes nothing. Node only.
+ * @param entity
+ * @param change
+ * @returns The record's new field definitions (as describe gives them).
+ */
+const alter = async (entity, change) => {
+  (0, _requireNode.requireNode)('alter');
+  if (entity === '__RECORDS') {
+    throw new Error('__RECORDS is reserved for the list of records');
+  }
+  // The same names the query language allows: a name becomes a key in every row and part of index file paths, so
+  // one like `../x` from a direct call must not get that far
+  const names = [entity, ...('field' in change ? [change.field?.name] : []), ...('name' in change ? [change.name] : []), ...('to' in change ? [change.to] : [])];
+  const invalid = names.findIndex(name => typeof name !== 'string' || !_parseCreate.nameMatch.test(name));
+  if (invalid !== -1) {
+    throw new Error(`Invalid name ${JSON.stringify(names[invalid]) ?? 'undefined'} in alter: names use letters, digits, _ and - only`);
+  }
+  const record = await (0, _retrieveRecord.retrieveRecord)(entity);
+  switch (change.action) {
+    case 'add':
+      return (await addField(entity, record, (0, _field.field)(change.field))).definition;
+    case 'drop':
+      return (await dropField(entity, record, change.name)).definition;
+    case 'rename':
+      return (await renameField(entity, record, change.name, change.to)).definition;
+    case 'modify':
+      return (await modifyField(entity, record, (0, _field.field)(change.field))).definition;
+    default:
+      throw new Error(`Unknown alter action: ${change.action}`);
+  }
+};
+exports.alter = alter;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.alter=void 0,require("core-js/modules/es.array.includes.js"),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.iterator.some.js");var _field=require("./definitions/field"),_create=require("./create"),_parseCreate=require("../utilities/parsers/parseCreate"),_retrieveRecord=require("../utilities/retrieveRecord"),_retrieveFiles=require("../utilities/retrieveFiles"),_retrieveRecords=require("../utilities/retrieveRecords"),_knownFields=require("../utilities/knownFields"),_packedTable=require("../utilities/packedTable"),_requireNode=require("../utilities/requireNode"),_showRecords=require("../queries/showRecords"),_updateEntity=require("../queries/updateEntity"),_typeCheck=require("./policies/typeCheck"),_storage=require("../storage");const rowsOf=async e=>(await(0,_retrieveFiles.retrieveFiles)(e.entries.map((t=>`${e.path}/${t}`)),_retrieveRecords.retrieveEntry)).map(((t,r)=>({fileName:e.entries[r],data:t}))),has=(e,t)=>Object.prototype.hasOwnProperty.call(e,t),keysUsing=(e,t)=>e.keys.filter((e=>e.fields.includes(t))),describeKey=e=>`${e.type} key (${e.fields.join(", ")})`,referencesTo=async(e,t)=>{const r=[];for(const i of await(0,_showRecords.showRecords)()){const a=await(0,_retrieveRecord.retrieveRecord)(i);for(const o of a.keys)"foreign"===o.type&&(o.references||[]).some((r=>r.fields.includes(`${e}.${t}`)))&&r.push({entity:i,record:a,key:o})}return r},writeRecord=async(e,t)=>{(0,_create.assertValidDefinition)(e,t),await(0,_storage.writeJson)(`${e}.json`,t)},setField=async(e,t,r,i,a)=>{if(r.length)if(await(0,_packedTable.discardPacked)(t.path),keysUsing(t,i).length&&"function"!=typeof a){if(!t.keys.some((e=>"primary"===e.type)))throw new Error(`Can't change "${i}" on ${e}'s rows: a key uses it, and rows are found by the primary key, which ${e} doesn't have`);await(0,_updateEntity.updateEntity)(e,{[i]:void 0===a?null:a},{[e]:r.map((e=>e.data))})}else for(const e of r){const r=Object.assign({},e.data),o="function"==typeof a?a(e):a;void 0===o?delete r[i]:r[i]=o,await(0,_storage.writeJson)(`${t.path}/${e.fileName}`,r)}},addField=async(e,t,r)=>{if(t.definition.some((e=>e.name===r.name)))throw new Error(`Field "${r.name}" already exists on ${e}`);const i={...t,definition:[...t.definition,r]},a=await rowsOf(t);for(const t of a.filter((e=>has(e.data,r.name))))try{(0,_typeCheck.typeCheck)(r.type,t.data[r.name],r.nullable)}catch(i){throw new Error(`Can't add "${r.name}" to ${e}: row ${t.fileName} already holds a value for it that doesn't fit (${i.message})`)}const o=a.filter((e=>!has(e.data,r.name))),n=has(r,"default");if(o.length&&!r.optional&&!n&&!r.autoGenerate)throw new Error(`Can't add required field "${r.name}" to ${e}: its ${o.length} row(s) have no value for it (give it a default, or make it optional)`);return await writeRecord(e,i),r.autoGenerate?await setField(e,i,o,r.name,(()=>crypto.randomUUID())):n&&await setField(e,i,o,r.name,r.default),i},dropField=async(e,t,r)=>{(0,_knownFields.assertFieldsDefined)(e,t,[r],"alter");const i=keysUsing(t,r)[0];if(i)throw new Error(`Can't drop "${r}" from ${e}: its ${describeKey(i)} uses it`);const a=(await referencesTo(e,r))[0];if(a)throw new Error(`Can't drop "${r}" from ${e}: ${a.entity}'s foreign key "${a.key.fields[0]}" references it`);const o={...t,definition:t.definition.filter((e=>e.name!==r))};return await writeRecord(e,o),await setField(e,o,(await rowsOf(t)).filter((e=>has(e.data,r))),r,void 0),o},renameField=async(e,t,r,i)=>{if((0,_knownFields.assertFieldsDefined)(e,t,[r],"alter"),t.definition.some((e=>e.name===i)))throw new Error(`Can't rename "${r}" on ${e} to "${i}": a field of that name already exists`);const a=await referencesTo(e,r),o=t.keys.map((e=>{if(!e.fields.includes(r))return e;const t=e.fields.map((e=>e===r?i:e)),a=e.lookup&&e.lookup===(0,_parseCreate.keyLookup)(e.type,e.fields)?(0,_parseCreate.keyLookup)(e.type,t):e.lookup;return{...e,fields:t,lookup:a}})),n=t=>"foreign"!==t.type?t:{...t,references:(t.references||[]).map((t=>({...t,fields:t.fields.map((t=>t===`${e}.${r}`?`${e}.${i}`:t))})))},s={...t,definition:t.definition.map((e=>e.name===r?{...e,name:i}:e)),keys:o.map(n)};for(const[e,r]of t.keys.entries()){const i=o[e].lookup;r.lookup&&i!==r.lookup&&(0,_storage.fileExists)(`__indexes/${t.path}/${r.lookup}`)&&(await(0,_storage.writeJson)(`__indexes/${t.path}/${i}`,await(0,_storage.readJson)(`__indexes/${t.path}/${r.lookup}`)),await(0,_storage.removeFile)(`__indexes/${t.path}/${r.lookup}`))}await writeRecord(e,s);for(const t of a.filter((t=>t.entity!==e)))await(0,_storage.writeJson)(`${t.entity}.json`,{...t.record,keys:t.record.keys.map(n)});const d=(await rowsOf(t)).filter((e=>has(e.data,r)));d.length&&await(0,_packedTable.discardPacked)(t.path);for(const e of d){const a=Object.assign({},e.data);a[i]=a[r],delete a[r],await(0,_storage.writeJson)(`${t.path}/${e.fileName}`,a)}return s},modifyField=async(e,t,r)=>{(0,_knownFields.assertFieldsDefined)(e,t,[r.name],"alter");const i=t.definition.find((e=>e.name===r.name));if(i.type!==r.type)throw new Error(`Can't change the type of "${r.name}" on ${e} (${i.type} to ${r.type}): only optional, null and default can change`);if(Boolean(i.autoGenerate)!==Boolean(r.autoGenerate))throw new Error(`Can't change whether "${r.name}" on ${e} is auto: only optional, null and default can change`);const a={...t,definition:t.definition.map((e=>e.name===r.name?r:e))},o=await rowsOf(t),n=has(r,"default"),s=r.nullable?[]:o.filter((e=>null===e.data[r.name])),d=r.optional?[]:o.filter((e=>!has(e.data,r.name))),l=r.optional?[]:s;if((d.length||l.length)&&!n)throw d.length?new Error(`Can't make "${r.name}" required on ${e}: ${d.length} row(s) have no value for it (give it a default to fill them in)`):new Error(`Can't make "${r.name}" not null on ${e}: ${l.length} row(s) hold null (give it a default to fill them in, or make it optional)`);return await writeRecord(e,a),n&&await setField(e,a,[...d,...l],r.name,r.default),r.optional&&s.length&&await setField(e,a,s,r.name,void 0),a},alter=async(e,t)=>{if((0,_requireNode.requireNode)("alter"),"__RECORDS"===e)throw new Error("__RECORDS is reserved for the list of records");const r=[e,..."field"in t?[t.field?.name]:[],..."name"in t?[t.name]:[],..."to"in t?[t.to]:[]],i=r.findIndex((e=>"string"!=typeof e||!_parseCreate.nameMatch.test(e)));if(-1!==i)throw new Error(`Invalid name ${JSON.stringify(r[i])??"undefined"} in alter: names use letters, digits, _ and - only`);const a=await(0,_retrieveRecord.retrieveRecord)(e);switch(t.action){case"add":return(await addField(e,a,(0,_field.field)(t.field))).definition;case"drop":return(await dropField(e,a,t.name)).definition;case"rename":return(await renameField(e,a,t.name,t.to)).definition;case"modify":return(await modifyField(e,a,(0,_field.field)(t.field))).definition;default:throw new Error(`Unknown alter action: ${t.action}`)}};exports.alter=alter;

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

@@ -1,6 +1,16 @@
 import { recordDefinition } from './definitions/record';
 import { keyProperties } from './definitions/key';
 import { fieldProperties } from './definitions/field';
+/**
+ * Reject a definition that could never be written correctly, before anything is created: a
+ * default that fails its field's type check (otherwise every insert leaving that field out would
+ * fail instead), including a null default on a field that isn't nullable, and a nullable field in
+ * the primary key (an entry's file name comes from its primary key value). Also a key with no fields,
+ * or with a field that isn't in the definition.
+ * @param recordName
+ * @param recordContent
+ */
+export declare const assertValidDefinition: (recordName: string, recordContent: recordDefinition) => void;
 /**
  * Create a new record. Throws if the definition is invalid (see assertValidDefinition).
  * @param recordName

package/dist/data/introspect/create.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.create = void 0;
+exports.create = exports.assertValidDefinition = 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");
@@ -73,6 +73,7 @@ const assertValidDefinition = (recordName, recordContent) => {
  * @param definition
  * @param keys
  */
+exports.assertValidDefinition = assertValidDefinition;
 const create = async (recordName, definition = [], keys = []) => {
   (0, _requireNode.requireNode)('create()');
   if (recordName === '__RECORDS') {

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.create=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"),require("core-js/modules/esnext.iterator.find.js"),require("core-js/modules/esnext.iterator.some.js");var _record=require("./definitions/record"),_registerRecord=require("../utilities/registerRecord"),_storage=require("../storage"),_requireNode=require("../utilities/requireNode"),_typeCheck=require("./policies/typeCheck");const knownKeyProperties=["type","fields","lookup","references"],assertKnownKeyProperties=(e,r)=>{for(const o of r)for(const r of Object.keys(o))if(!knownKeyProperties.includes(r))throw new Error(`Unknown property "${r}" on ${o.type??"index"} key of ${e}; must be ${knownKeyProperties.join(", ")}`)},assertValidDefinition=(e,r)=>{for(const o of r.definition)if(Object.prototype.hasOwnProperty.call(o,"default"))try{(0,_typeCheck.typeCheck)(o.type,o.default,o.nullable)}catch(r){throw new Error(`Invalid default for field "${o.name}" of ${e}: ${r.message}`)}for(const o of r.keys){if(o.fields.length<1)throw new Error(`The ${o.type} key of ${e} must have at least one field`);for(const t of o.fields)if(!r.definition.some((e=>e.name===t)))throw new Error(`The ${o.type} key of ${e} names field "${t}", which isn't in the definition`)}const o=r.keys.find((e=>"primary"===e.type));for(const t of o?o.fields:[])if(r.definition.some((e=>e.name===t&&e.nullable)))throw new Error(`Primary key field "${t}" of ${e} can't be nullable`)},create=async(e,r=[],o=[])=>{if((0,_requireNode.requireNode)("create()"),"__RECORDS"===e)return null;if((0,_storage.fileExists)(`${e}.json`))return null;assertKnownKeyProperties(e,o);const t=(0,_record.record)({path:e,definition:r,keys:o});assertValidDefinition(e,t),await(0,_storage.makeDirectory)(),await(0,_storage.writeJson)(`${e}.json`,t),await(0,_storage.makeDirectory)(e);const i=t.keys.filter((e=>e.lookup));if(i.length){await(0,_storage.makeDirectory)(`__indexes/${e}`);for(const r of i)await(0,_storage.writeJson)(`__indexes/${e}/${r.lookup}`,[])}return await(0,_registerRecord.registerRecord)(e),t};exports.create=create;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.create=exports.assertValidDefinition=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"),require("core-js/modules/esnext.iterator.find.js"),require("core-js/modules/esnext.iterator.some.js");var _record=require("./definitions/record"),_registerRecord=require("../utilities/registerRecord"),_storage=require("../storage"),_requireNode=require("../utilities/requireNode"),_typeCheck=require("./policies/typeCheck");const knownKeyProperties=["type","fields","lookup","references"],assertKnownKeyProperties=(e,r)=>{for(const o of r)for(const r of Object.keys(o))if(!knownKeyProperties.includes(r))throw new Error(`Unknown property "${r}" on ${o.type??"index"} key of ${e}; must be ${knownKeyProperties.join(", ")}`)},assertValidDefinition=(e,r)=>{for(const o of r.definition)if(Object.prototype.hasOwnProperty.call(o,"default"))try{(0,_typeCheck.typeCheck)(o.type,o.default,o.nullable)}catch(r){throw new Error(`Invalid default for field "${o.name}" of ${e}: ${r.message}`)}for(const o of r.keys){if(o.fields.length<1)throw new Error(`The ${o.type} key of ${e} must have at least one field`);for(const t of o.fields)if(!r.definition.some((e=>e.name===t)))throw new Error(`The ${o.type} key of ${e} names field "${t}", which isn't in the definition`)}const o=r.keys.find((e=>"primary"===e.type));for(const t of o?o.fields:[])if(r.definition.some((e=>e.name===t&&e.nullable)))throw new Error(`Primary key field "${t}" of ${e} can't be nullable`)};exports.assertValidDefinition=assertValidDefinition;const create=async(e,r=[],o=[])=>{if((0,_requireNode.requireNode)("create()"),"__RECORDS"===e)return null;if((0,_storage.fileExists)(`${e}.json`))return null;assertKnownKeyProperties(e,o);const t=(0,_record.record)({path:e,definition:r,keys:o});assertValidDefinition(e,t),await(0,_storage.makeDirectory)(),await(0,_storage.writeJson)(`${e}.json`,t),await(0,_storage.makeDirectory)(e);const i=t.keys.filter((e=>e.lookup));if(i.length){await(0,_storage.makeDirectory)(`__indexes/${e}`);for(const r of i)await(0,_storage.writeJson)(`__indexes/${e}/${r.lookup}`,[])}return await(0,_registerRecord.registerRecord)(e),t};exports.create=create;

package/dist/data/introspect/drop.js

@@ -12,6 +12,7 @@ var _retrieveFile = require("../utilities/retrieveFile");
 var _deregisterRecord = require("../utilities/deregisterRecord");
 var _requireNode = require("../utilities/requireNode");
 var _storage = require("../storage");
+var _packedTable = require("../utilities/packedTable");
 const drop = async record => {
   (0, _requireNode.requireNode)('drop()');
   if (record === '__RECORDS') {
@@ -23,6 +24,7 @@ const drop = async record => {
   }
   await (0, _storage.removeDirectory)(recordFile.path);
   await (0, _storage.removeDirectory)(`__indexes/${recordFile.path}`);
+  await (0, _packedTable.discardPacked)(recordFile.path);
   await (0, _storage.removeFile)(`${record}.json`);
   await (0, _deregisterRecord.deregisterRecord)(record);
 };

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

@@ -1 +1 @@
-"use strict";require("core-js/modules/esnext.async-iterator.constructor.js"),require("core-js/modules/esnext.async-iterator.drop.js"),require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.drop.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.drop=void 0;var _retrieveFile=require("../utilities/retrieveFile"),_deregisterRecord=require("../utilities/deregisterRecord"),_requireNode=require("../utilities/requireNode"),_storage=require("../storage");const drop=async e=>{if((0,_requireNode.requireNode)("drop()"),"__RECORDS"===e)return null;const r=await(0,_retrieveFile.retrieveFile)(`${e}.json`);for(const e of r.entries)await(0,_storage.removeFile)(`${r.path}/${e}`);await(0,_storage.removeDirectory)(r.path),await(0,_storage.removeDirectory)(`__indexes/${r.path}`),await(0,_storage.removeFile)(`${e}.json`),await(0,_deregisterRecord.deregisterRecord)(e)};exports.drop=drop;
+"use strict";require("core-js/modules/esnext.async-iterator.constructor.js"),require("core-js/modules/esnext.async-iterator.drop.js"),require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.drop.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.drop=void 0;var _retrieveFile=require("../utilities/retrieveFile"),_deregisterRecord=require("../utilities/deregisterRecord"),_requireNode=require("../utilities/requireNode"),_storage=require("../storage"),_packedTable=require("../utilities/packedTable");const drop=async e=>{if((0,_requireNode.requireNode)("drop()"),"__RECORDS"===e)return null;const r=await(0,_retrieveFile.retrieveFile)(`${e}.json`);for(const e of r.entries)await(0,_storage.removeFile)(`${r.path}/${e}`);await(0,_storage.removeDirectory)(r.path),await(0,_storage.removeDirectory)(`__indexes/${r.path}`),await(0,_packedTable.discardPacked)(r.path),await(0,_storage.removeFile)(`${e}.json`),await(0,_deregisterRecord.deregisterRecord)(e)};exports.drop=drop;

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

@@ -0,0 +1,17 @@
+export type formatResult = {
+    files: number;
+    rewritten: number;
+};
+/**
+ * Rewrite every JSON file of the configured database (records, entries, indexes, `__RECORDS.json`) in one format:
+ * 'compact' or 'pretty' (see configure). Files already in that format are left alone, so running it twice changes
+ * nothing the second time. Writing in one format never stops the other from being read; this is for making a whole
+ * database match, for example after changing `format` on a database written before.
+ *
+ * Every file is read and checked before any is written: one that isn't valid JSON fails the whole call with its path,
+ * and nothing is changed (the public version runs as one statement, see withWriteSet). Node only.
+ * @param format - Defaults to the configured format.
+ * @throws {Error} When format is neither 'compact' nor 'pretty', when a file isn't valid JSON, or in a browser.
+ */
+export declare const formatDatabase: (format?: "compact" | "pretty") => Promise<formatResult>;
+//# sourceMappingURL=formatDatabase.d.ts.map

package/dist/data/introspect/formatDatabase.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatDatabase = void 0;
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.filter.js");
+var _storage = require("../storage");
+var _config = require("../utilities/config");
+var _requireNode = require("../utilities/requireNode");
+/**
+ * Rewrite every JSON file of the configured database (records, entries, indexes, `__RECORDS.json`) in one format:
+ * 'compact' or 'pretty' (see configure). Files already in that format are left alone, so running it twice changes
+ * nothing the second time. Writing in one format never stops the other from being read; this is for making a whole
+ * database match, for example after changing `format` on a database written before.
+ *
+ * Every file is read and checked before any is written: one that isn't valid JSON fails the whole call with its path,
+ * and nothing is changed (the public version runs as one statement, see withWriteSet). Node only.
+ * @param format - Defaults to the configured format.
+ * @throws {Error} When format is neither 'compact' nor 'pretty', when a file isn't valid JSON, or in a browser.
+ */
+const formatDatabase = async (format = (0, _config.getSetting)('format', 'compact')) => {
+  (0, _requireNode.requireNode)('formatDatabase');
+  if (format !== 'compact' && format !== 'pretty') {
+    throw new Error(`Unknown format "${format}": use 'compact' or 'pretty'`);
+  }
+  const paths = (await (0, _storage.listFiles)()).filter(path => path.endsWith('.json'));
+  const changes = [];
+  for (const path of paths) {
+    const text = await (0, _storage.readText)(path);
+    let content;
+    try {
+      content = JSON.parse(text);
+    } catch (error) {
+      throw new Error(`Could not format ${path}: ${error.message}`);
+    }
+    if ((0, _storage.jsonText)(content, format) !== text) {
+      changes.push({
+        path,
+        content
+      });
+    }
+  }
+  for (const {
+    path,
+    content
+  } of changes) {
+    await (0, _storage.writeJson)(path, content, format);
+  }
+  return {
+    files: paths.length,
+    rewritten: changes.length
+  };
+};
+exports.formatDatabase = formatDatabase;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.formatDatabase=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.js");var _storage=require("../storage"),_config=require("../utilities/config"),_requireNode=require("../utilities/requireNode");const formatDatabase=async(e=(0,_config.getSetting)("format","compact"))=>{if((0,_requireNode.requireNode)("formatDatabase"),"compact"!==e&&"pretty"!==e)throw new Error(`Unknown format "${e}": use 'compact' or 'pretty'`);const t=(await(0,_storage.listFiles)()).filter((e=>e.endsWith(".json"))),r=[];for(const o of t){const t=await(0,_storage.readText)(o);let a;try{a=JSON.parse(t)}catch(e){throw new Error(`Could not format ${o}: ${e.message}`)}(0,_storage.jsonText)(a,e)!==t&&r.push({path:o,content:a})}for(const{path:t,content:o}of r)await(0,_storage.writeJson)(t,o,e);return{files:t.length,rewritten:r.length}};exports.formatDatabase=formatDatabase;

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

@@ -1,9 +1,18 @@
 import { create as createRecord } from './create';
 import { drop as dropRecord } from './drop';
 import { describe as describeRecord } from './describe';
+import { formatDatabase as formatAll } from './formatDatabase';
+import { alter as alterRecord } from './alter';
+import { checkPacked as checkAllPacked, packDatabase as packAll } from './packDatabase';
 export declare const create: (...args: Parameters<typeof createRecord>) => ReturnType<typeof createRecord>;
 export declare const drop: (...args: Parameters<typeof dropRecord>) => ReturnType<typeof dropRecord>;
+export declare const alter: (...args: Parameters<typeof alterRecord>) => ReturnType<typeof alterRecord>;
 export declare const describe: (...args: Parameters<typeof describeRecord>) => ReturnType<typeof describeRecord>;
+export declare const formatDatabase: (...args: Parameters<typeof formatAll>) => ReturnType<typeof formatAll>;
+export type { formatResult } from './formatDatabase';
+export declare const packDatabase: () => ReturnType<typeof packAll>;
+export declare const checkPacked: () => ReturnType<typeof checkAllPacked>;
+export type { packResult, packCheck } from './packDatabase';
 export { fieldProperties, fieldDefinition, fieldName } from './definitions/field';
 export { keyProperties, keyDefinition, indexType, indexLocation } from './definitions/key';
 export { referenceProperties, reference } from './definitions/keyReference';

package/dist/data/introspect/index.js

@@ -7,15 +7,28 @@ require("core-js/modules/esnext.iterator.drop.js");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.drop = exports.describe = exports.create = void 0;
+exports.packDatabase = exports.formatDatabase = exports.drop = exports.describe = exports.create = exports.checkPacked = exports.alter = void 0;
 var _create = require("./create");
 var _drop = require("./drop");
 var _describe = require("./describe");
+var _formatDatabase = require("./formatDatabase");
+var _alter = require("./alter");
+var _packDatabase = require("./packDatabase");
 var _databaseLock = require("../utilities/databaseLock");
-// The public versions take the database lock (see withDatabaseLock); code inside the package imports the files directly
-const create = (...args) => (0, _databaseLock.withDatabaseLock)(() => (0, _create.create)(...args));
+var _storage = require("../storage");
+// The public versions take the database lock (see withDatabaseLock), and create, drop, alter, formatDatabase and
+// packDatabase change storage all at once or not at all (see withWriteSet); code inside the package imports the files directly
+const create = (...args) => (0, _databaseLock.withDatabaseLock)(() => (0, _storage.withWriteSet)(() => (0, _create.create)(...args)));
 exports.create = create;
-const drop = (...args) => (0, _databaseLock.withDatabaseLock)(() => (0, _drop.drop)(...args));
+const drop = (...args) => (0, _databaseLock.withDatabaseLock)(() => (0, _storage.withWriteSet)(() => (0, _drop.drop)(...args)));
 exports.drop = drop;
+const alter = (...args) => (0, _databaseLock.withDatabaseLock)(() => (0, _storage.withWriteSet)(() => (0, _alter.alter)(...args)));
+exports.alter = alter;
 const describe = (...args) => (0, _databaseLock.withDatabaseLock)(() => (0, _describe.describe)(...args));
-exports.describe = describe;
+exports.describe = describe;
+const formatDatabase = (...args) => (0, _databaseLock.withDatabaseLock)(() => (0, _storage.withWriteSet)(() => (0, _formatDatabase.formatDatabase)(...args)));
+exports.formatDatabase = formatDatabase;
+const packDatabase = () => (0, _databaseLock.withDatabaseLock)(() => (0, _storage.withWriteSet)(() => (0, _packDatabase.packDatabase)()));
+exports.packDatabase = packDatabase;
+const checkPacked = () => (0, _databaseLock.withDatabaseLock)(() => (0, _packDatabase.checkPacked)());
+exports.checkPacked = checkPacked;

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

@@ -1 +1 @@
-"use strict";require("core-js/modules/esnext.async-iterator.constructor.js"),require("core-js/modules/esnext.async-iterator.drop.js"),require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.drop.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.drop=exports.describe=exports.create=void 0;var _create=require("./create"),_drop=require("./drop"),_describe=require("./describe"),_databaseLock=require("../utilities/databaseLock");const create=(...e)=>(0,_databaseLock.withDatabaseLock)((()=>(0,_create.create)(...e)));exports.create=create;const drop=(...e)=>(0,_databaseLock.withDatabaseLock)((()=>(0,_drop.drop)(...e)));exports.drop=drop;const describe=(...e)=>(0,_databaseLock.withDatabaseLock)((()=>(0,_describe.describe)(...e)));exports.describe=describe;
+"use strict";require("core-js/modules/esnext.async-iterator.constructor.js"),require("core-js/modules/esnext.async-iterator.drop.js"),require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.drop.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.packDatabase=exports.formatDatabase=exports.drop=exports.describe=exports.create=exports.checkPacked=exports.alter=void 0;var _create=require("./create"),_drop=require("./drop"),_describe=require("./describe"),_formatDatabase=require("./formatDatabase"),_alter=require("./alter"),_packDatabase=require("./packDatabase"),_databaseLock=require("../utilities/databaseLock"),_storage=require("../storage");const create=(...e)=>(0,_databaseLock.withDatabaseLock)((()=>(0,_storage.withWriteSet)((()=>(0,_create.create)(...e)))));exports.create=create;const drop=(...e)=>(0,_databaseLock.withDatabaseLock)((()=>(0,_storage.withWriteSet)((()=>(0,_drop.drop)(...e)))));exports.drop=drop;const alter=(...e)=>(0,_databaseLock.withDatabaseLock)((()=>(0,_storage.withWriteSet)((()=>(0,_alter.alter)(...e)))));exports.alter=alter;const describe=(...e)=>(0,_databaseLock.withDatabaseLock)((()=>(0,_describe.describe)(...e)));exports.describe=describe;const formatDatabase=(...e)=>(0,_databaseLock.withDatabaseLock)((()=>(0,_storage.withWriteSet)((()=>(0,_formatDatabase.formatDatabase)(...e)))));exports.formatDatabase=formatDatabase;const packDatabase=()=>(0,_databaseLock.withDatabaseLock)((()=>(0,_storage.withWriteSet)((()=>(0,_packDatabase.packDatabase)()))));exports.packDatabase=packDatabase;const checkPacked=()=>(0,_databaseLock.withDatabaseLock)((()=>(0,_packDatabase.checkPacked)()));exports.checkPacked=checkPacked;

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