json-fs-query 1.0.6 → 2.0.0

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

@@ -2,7 +2,7 @@ import { recordDefinition } from './definitions/record';
 import { keyProperties } from './definitions/key';
 import { fieldProperties } from './definitions/field';
 /**
- * Create a new record.
+ * Create a new record. Throws if the definition is invalid (see assertValidDefinition).
  * @param recordName
  * @param definition
  * @param keys

package/dist/data/introspect/create.js

@@ -5,11 +5,41 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.create = 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.some.js");
 var _record = require("./definitions/record");
 var _registerRecord = require("../utilities/registerRecord");
 var _config = require("../utilities/config");
+var _typeCheck = require("./policies/typeCheck");
 /**
- * Create a new record.
+ * 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).
+ * @param recordName
+ * @param recordContent
+ */
+const assertValidDefinition = (recordName, recordContent) => {
+  for (const field of recordContent.definition) {
+    if (!Object.prototype.hasOwnProperty.call(field, 'default')) {
+      continue;
+    }
+    try {
+      (0, _typeCheck.typeCheck)(field.type, field['default'], field.nullable);
+    } catch (err) {
+      throw new Error(`Invalid default for field "${field.name}" of ${recordName}: ${err.message}`);
+    }
+  }
+  const primaryKey = recordContent.keys.find(key => key.type === 'primary');
+  for (const fieldName of primaryKey ? primaryKey.fields : []) {
+    if (recordContent.definition.some(field => field.name === fieldName && field.nullable)) {
+      throw new Error(`Primary key field "${fieldName}" of ${recordName} can't be nullable`);
+    }
+  }
+};
+/**
+ * Create a new record. Throws if the definition is invalid (see assertValidDefinition).
  * @param recordName
  * @param definition
  * @param keys
@@ -29,14 +59,15 @@ const create = async (recordName, definition = [], keys = []) => {
   if (existsSync(`${databasePath}${recordName}.json`)) {
     return null;
   }
-  await mkdir(databasePath, {
-    recursive: true
-  });
   const recordContent = (0, _record.record)({
     path: recordName,
     definition,
     keys
   });
+  assertValidDefinition(recordName, recordContent);
+  await mkdir(databasePath, {
+    recursive: true
+  });
   await writeFile(`${databasePath}${recordName}.json`, JSON.stringify(recordContent, null, 2));
   await mkdir(`${databasePath}${recordName}`, {
     recursive: true

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.json.stringify.js");var _record=require("./definitions/record"),_registerRecord=require("../utilities/registerRecord"),_config=require("../utilities/config");const create=async(e,r=[],i=[])=>{const{writeFile:t,mkdir:s}=require("fs/promises"),{existsSync:o}=require("fs"),c=(0,_config.getSetting)("databasePath","database/");if("__RECORDS"===e)return null;if(o(`${c}${e}.json`))return null;await s(c,{recursive:!0});const n=(0,_record.record)({path:e,definition:r,keys:i});return await t(`${c}${e}.json`,JSON.stringify(n,null,2)),await s(`${c}${e}`,{recursive:!0}),await(0,_registerRecord.registerRecord)(e),n};exports.create=create;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.create=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.some.js");var _record=require("./definitions/record"),_registerRecord=require("../utilities/registerRecord"),_config=require("../utilities/config"),_typeCheck=require("./policies/typeCheck");const assertValidDefinition=(e,r)=>{for(const t of r.definition)if(Object.prototype.hasOwnProperty.call(t,"default"))try{(0,_typeCheck.typeCheck)(t.type,t.default,t.nullable)}catch(r){throw new Error(`Invalid default for field "${t.name}" of ${e}: ${r.message}`)}const t=r.keys.find((e=>"primary"===e.type));for(const i of t?t.fields:[])if(r.definition.some((e=>e.name===i&&e.nullable)))throw new Error(`Primary key field "${i}" of ${e} can't be nullable`)},create=async(e,r=[],t=[])=>{const{writeFile:i,mkdir:s}=require("fs/promises"),{existsSync:o}=require("fs"),n=(0,_config.getSetting)("databasePath","database/");if("__RECORDS"===e)return null;if(o(`${n}${e}.json`))return null;const a=(0,_record.record)({path:e,definition:r,keys:t});return assertValidDefinition(e,a),await s(n,{recursive:!0}),await i(`${n}${e}.json`,JSON.stringify(a,null,2)),await s(`${n}${e}`,{recursive:!0}),await(0,_registerRecord.registerRecord)(e),a};exports.create=create;

package/dist/data/introspect/definitions/field.d.ts

@@ -3,6 +3,7 @@ export type fieldDefinition = {
     name: fieldName;
     type: string;
     optional: boolean;
+    nullable?: boolean;
     default?: any;
     autoGenerate: boolean;
 };
@@ -10,19 +11,22 @@ export type fieldProperties = {
     name?: string;
     type?: string;
     optional?: boolean;
+    nullable?: boolean;
     useDefault?: boolean;
     defaultValue?: any;
     autoGenerate?: boolean;
 };
 /**
- * Generate a field for a record.
+ * Generate a field for a record. `nullable` is only stored when true (like `default`), so fields
+ * that never mention it, and schemas written before it existed, stay exactly as they were.
  * @param properties
  * @param properties.name
  * @param properties.type
  * @param properties.optional
+ * @param properties.nullable
  * @param properties.useDefault
  * @param properties.defaultValue
  * @param properties.autoGenerate
  */
-export declare const field: ({ name, type, optional, useDefault, defaultValue, autoGenerate }?: fieldProperties) => fieldDefinition;
+export declare const field: ({ name, type, optional, nullable, useDefault, defaultValue, autoGenerate }?: fieldProperties) => fieldDefinition;
 //# sourceMappingURL=field.d.ts.map

package/dist/data/introspect/definitions/field.js

@@ -5,11 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.field = void 0;
 /**
- * Generate a field for a record.
+ * Generate a field for a record. `nullable` is only stored when true (like `default`), so fields
+ * that never mention it, and schemas written before it existed, stay exactly as they were.
  * @param properties
  * @param properties.name
  * @param properties.type
  * @param properties.optional
+ * @param properties.nullable
  * @param properties.useDefault
  * @param properties.defaultValue
  * @param properties.autoGenerate
@@ -18,6 +20,7 @@ const field = ({
   name = '',
   type = 'string',
   optional = false,
+  nullable = false,
   useDefault = false,
   defaultValue = '',
   autoGenerate = false
@@ -28,6 +31,9 @@ const field = ({
     optional,
     autoGenerate
   };
+  if (nullable) {
+    returnField['nullable'] = true;
+  }
   if (useDefault) {
     returnField['default'] = defaultValue;
   }

package/dist/data/introspect/definitions/field.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.field=void 0;const field=({name:e="",type:t="string",optional:o=!1,useDefault:a=!1,defaultValue:l="",autoGenerate:n=!1}={})=>{const r={name:e,type:t,optional:o,autoGenerate:n};return a&&(r.default=l),r};exports.field=field;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.field=void 0;const field=({name:e="",type:t="string",optional:l=!1,nullable:a=!1,useDefault:o=!1,defaultValue:n="",autoGenerate:u=!1}={})=>{const r={name:e,type:t,optional:l,autoGenerate:u};return a&&(r.nullable=!0),o&&(r.default=n),r};exports.field=field;

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

@@ -1,6 +1,9 @@
-export { create } from './create';
-export { drop } from './drop';
-export { describe } from './describe';
+import { create as createRecord } from './create';
+import { drop as dropRecord } from './drop';
+import { describe as describeRecord } from './describe';
+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 describe: (...args: Parameters<typeof describeRecord>) => ReturnType<typeof describeRecord>;
 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,24 +7,15 @@ require("core-js/modules/esnext.iterator.drop.js");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-Object.defineProperty(exports, "create", {
-  enumerable: true,
-  get: function () {
-    return _create.create;
-  }
-});
-Object.defineProperty(exports, "describe", {
-  enumerable: true,
-  get: function () {
-    return _describe.describe;
-  }
-});
-Object.defineProperty(exports, "drop", {
-  enumerable: true,
-  get: function () {
-    return _drop.drop;
-  }
-});
+exports.drop = exports.describe = exports.create = void 0;
 var _create = require("./create");
 var _drop = require("./drop");
-var _describe = require("./describe");
+var _describe = require("./describe");
+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));
+exports.create = create;
+const drop = (...args) => (0, _databaseLock.withDatabaseLock)(() => (0, _drop.drop)(...args));
+exports.drop = drop;
+const describe = (...args) => (0, _databaseLock.withDatabaseLock)(() => (0, _describe.describe)(...args));
+exports.describe = describe;

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}),Object.defineProperty(exports,"create",{enumerable:!0,get:function(){return _create.create}}),Object.defineProperty(exports,"describe",{enumerable:!0,get:function(){return _describe.describe}}),Object.defineProperty(exports,"drop",{enumerable:!0,get:function(){return _drop.drop}});var _create=require("./create"),_drop=require("./drop"),_describe=require("./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.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;

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

@@ -6,6 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 exports.foreignKeyExists = void 0;
 var _retrieveRecords = require("../../utilities/retrieveRecords");
 var _where = require("../../queries/where");
+var _retrieveRecord = require("../../utilities/retrieveRecord");
+var _fieldType = require("../../utilities/fieldType");
 /**
  * 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.
@@ -15,10 +17,12 @@ var _where = require("../../queries/where");
  */
 const foreignKeyExists = async (entity, property, value) => {
   const records = await (0, _retrieveRecords.retrieveRecords)(entity);
+  const type = (0, _fieldType.fieldType)(await (0, _retrieveRecord.retrieveRecord)(entity), property);
   const found = (0, _where.where)(records, {
     property,
     comparator: '=',
-    value
+    value,
+    type
   });
   return found.length > 0;
 };

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");const foreignKeyExists=async(e,r,t)=>{const s=await(0,_retrieveRecords.retrieveRecords)(e);return(0,_where.where)(s,{property:r,comparator:"=",value:t}).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");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;

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

@@ -8,6 +8,7 @@ var _describe = require("../describe");
 var _retrieveRecord = require("../../utilities/retrieveRecord");
 var _retrieveRecords = require("../../utilities/retrieveRecords");
 var _where = require("../../queries/where");
+var _fieldType = require("../../utilities/fieldType");
 var _splitEntityProperty = require("../../utilities/parsers/splitEntityProperty");
 /**
  * Check whether any other record, in any entity, still has a single-field foreign key pointing
@@ -40,7 +41,8 @@ const hasDependents = async (entity, property, value) => {
       const found = (0, _where.where)(records, {
         property: key.fields[0],
         comparator: '=',
-        value
+        value,
+        type: (0, _fieldType.fieldType)(otherRecord, key.fields[0])
       });
       if (found.length) {
         return true;

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"),_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:o,property:n}=(0,_splitEntityProperty.splitEntityProperty)(s.references[0].fields[0]);if(o!==e||n!==r)continue;const c=await(0,_retrieveRecords.retrieveRecords)(i);if((0,_where.where)(c,{property:s.fields[0],comparator:"=",value:t}).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");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;

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

@@ -6,6 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 exports.keyUnique = void 0;
 var _retrieveRecords = require("../../utilities/retrieveRecords");
 var _where = require("../../queries/where");
+var _retrieveRecord = require("../../utilities/retrieveRecord");
+var _fieldType = require("../../utilities/fieldType");
 /**
  * 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.
@@ -19,11 +21,13 @@ const keyUnique = async (entity, references = [], checkKeys = []) => {
     return false;
   }
   let records = await (0, _retrieveRecords.retrieveRecords)(entity);
+  const record = await (0, _retrieveRecord.retrieveRecord)(entity);
   for (let i = 0; i < references.length; i++) {
     records = (0, _where.where)(records, {
       property: references[i],
       comparator: '=',
-      value: checkKeys[i]
+      value: checkKeys[i],
+      type: (0, _fieldType.fieldType)(record, references[i])
     });
   }
   return !records.length;

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");const keyUnique=async(e,r=[],t=[])=>{if(!r.length||r.length!==t.length)return!1;let i=await(0,_retrieveRecords.retrieveRecords)(e);for(let e=0;e<r.length;e++)i=(0,_where.where)(i,{property:r[e],comparator:"=",value:t[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");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;

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

@@ -1,3 +1,7 @@
+/**
+ * The type names typeCheck knows. The create statement accepts only these; create() accepts any name (see below).
+ */
+export declare const fieldTypes: string[];
 /**
  * Validate (and where sensible, coerce) a value against a field's declared type. Runs only
  * against values being written by insertEntity/updateEntity - it never re-validates data already
@@ -5,8 +9,12 @@
  * happen, since nothing enforced this before) is left alone until something actually updates it.
  * An unrecognized type name is treated as unconstrained rather than rejected, so a typo in a
  * schema's field type can't silently block every write to that field.
+ *
+ * A null is a real JSON null, kept as it is for a nullable field and rejected for any other, of
+ * any type: it is never coerced, so a string field can't store the text "null" or an int field 0.
  * @param type
  * @param value
+ * @param nullable - Whether the field may hold null (the field definition's `nullable`).
  */
-export declare const typeCheck: (type?: string, value?: any) => any;
+export declare const typeCheck: (type?: string, value?: any, nullable?: boolean) => any;
 //# sourceMappingURL=typeCheck.d.ts.map

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

@@ -3,7 +3,11 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.typeCheck = void 0;
+exports.typeCheck = exports.fieldTypes = void 0;
+/**
+ * The type names typeCheck knows. The create statement accepts only these; create() accepts any name (see below).
+ */
+const fieldTypes = exports.fieldTypes = ['string', 'int', 'boolean', 'object', 'array'];
 /**
  * Validate (and where sensible, coerce) a value against a field's declared type. Runs only
  * against values being written by insertEntity/updateEntity - it never re-validates data already
@@ -11,13 +15,23 @@ exports.typeCheck = void 0;
  * happen, since nothing enforced this before) is left alone until something actually updates it.
  * An unrecognized type name is treated as unconstrained rather than rejected, so a typo in a
  * schema's field type can't silently block every write to that field.
+ *
+ * A null is a real JSON null, kept as it is for a nullable field and rejected for any other, of
+ * any type: it is never coerced, so a string field can't store the text "null" or an int field 0.
  * @param type
  * @param value
+ * @param nullable - Whether the field may hold null (the field definition's `nullable`).
  */
-const typeCheck = (type = 'string', value = undefined) => {
+const typeCheck = (type = 'string', value = undefined, nullable = false) => {
   if (typeof value === 'undefined') {
     return value;
   }
+  if (value === null) {
+    if (nullable) {
+      return value;
+    }
+    throw new Error('Value "null" is not allowed: the field is not nullable');
+  }
   switch (type) {
     case 'string':
       return typeof value === 'string' ? value : String(value);

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.typeCheck=void 0;const typeCheck=(r="string",e=void 0)=>{if(void 0===e)return e;switch(r){case"string":return"string"==typeof e?e:String(e);case"int":{const r=Number(e);if(Number.isNaN(r)||!Number.isInteger(r))throw new Error(`Value "${e}" is not a valid int`);return r}case"boolean":if("boolean"==typeof e)return e;if("true"===e)return!0;if("false"===e)return!1;throw new Error(`Value "${e}" is not a valid boolean`);case"object":if("object"!=typeof e||null===e||Array.isArray(e))throw new Error(`Value "${e}" is not a valid object`);return e;case"array":if(!Array.isArray(e))throw new Error(`Value "${e}" is not a valid array`);return e;default:return e}};exports.typeCheck=typeCheck;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.typeCheck=exports.fieldTypes=void 0;const fieldTypes=exports.fieldTypes=["string","int","boolean","object","array"],typeCheck=(e="string",r=void 0,t=!1)=>{if(void 0===r)return r;if(null===r){if(t)return r;throw new Error('Value "null" is not allowed: the field is not nullable')}switch(e){case"string":return"string"==typeof r?r:String(r);case"int":{const e=Number(r);if(Number.isNaN(e)||!Number.isInteger(e))throw new Error(`Value "${r}" is not a valid int`);return e}case"boolean":if("boolean"==typeof r)return r;if("true"===r)return!0;if("false"===r)return!1;throw new Error(`Value "${r}" is not a valid boolean`);case"object":if("object"!=typeof r||null===r||Array.isArray(r))throw new Error(`Value "${r}" is not a valid object`);return r;case"array":if(!Array.isArray(r))throw new Error(`Value "${r}" is not a valid array`);return r;default:return r}};exports.typeCheck=typeCheck;

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

@@ -0,0 +1,11 @@
+import { recordDefinition } from '../introspect/definitions/record';
+import { ParsedCreate } from '../utilities/parsers/parseCreate';
+/**
+ * Run a parsed create statement: an error if the record already exists, unless the statement says
+ * `if not exists` (then nothing happens and the result is null). Otherwise create() it and resolve to its
+ * definition, as create() does.
+ * @param entity
+ * @param parsed
+ */
+export declare const createRecord: (entity: string, parsed: ParsedCreate) => Promise<recordDefinition | null>;
+//# sourceMappingURL=createRecord.d.ts.map

package/dist/data/queries/createRecord.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRecord = void 0;
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.map.js");
+var _create = require("../introspect/create");
+var _retrieveRecord = require("../utilities/retrieveRecord");
+var _splitEntityProperty = require("../utilities/parsers/splitEntityProperty");
+var _recordExists = require("../utilities/recordExists");
+/**
+ * Reject a foreign key whose referenced record, or field on it, doesn't exist. A key referencing the record being
+ * created is checked against its own fields.
+ * @param entity
+ * @param parsed
+ */
+const assertReferencesExist = async (entity, parsed) => {
+  for (const key of parsed.keys) {
+    if (key.type !== 'foreign') {
+      continue;
+    }
+    const {
+      entity: refEntity,
+      property: refProperty
+    } = (0, _splitEntityProperty.splitEntityProperty)(key.references[0].fields[0]);
+    let fields = parsed.definition.map(field => field.name);
+    if (refEntity !== entity) {
+      if (!(0, _recordExists.recordExists)(refEntity)) {
+        throw new Error(`Foreign key "${key.fields[0]}" references "${refEntity}", which doesn't exist`);
+      }
+      fields = (await (0, _retrieveRecord.retrieveRecord)(refEntity)).definition.map(field => field.name);
+    }
+    if (!fields.includes(refProperty)) {
+      throw new Error(`Foreign key "${key.fields[0]}" references "${refEntity}.${refProperty}", which is not a field`);
+    }
+  }
+};
+/**
+ * Run a parsed create statement: an error if the record already exists, unless the statement says
+ * `if not exists` (then nothing happens and the result is null). Otherwise create() it and resolve to its
+ * definition, as create() does.
+ * @param entity
+ * @param parsed
+ */
+const createRecord = async (entity, parsed) => {
+  if ((0, _recordExists.recordExists)(entity)) {
+    if (parsed.ifNotExists) {
+      return null;
+    }
+    throw new Error(`Record "${entity}" already exists`);
+  }
+  await assertReferencesExist(entity, parsed);
+  return (0, _create.create)(entity, parsed.definition, parsed.keys);
+};
+exports.createRecord = createRecord;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.createRecord=void 0,require("core-js/modules/es.array.includes.js"),require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.map.js");var _create=require("../introspect/create"),_retrieveRecord=require("../utilities/retrieveRecord"),_splitEntityProperty=require("../utilities/parsers/splitEntityProperty"),_recordExists=require("../utilities/recordExists");const assertReferencesExist=async(e,r)=>{for(const t of r.keys){if("foreign"!==t.type)continue;const{entity:i,property:s}=(0,_splitEntityProperty.splitEntityProperty)(t.references[0].fields[0]);let o=r.definition.map((e=>e.name));if(i!==e){if(!(0,_recordExists.recordExists)(i))throw new Error(`Foreign key "${t.fields[0]}" references "${i}", which doesn't exist`);o=(await(0,_retrieveRecord.retrieveRecord)(i)).definition.map((e=>e.name))}if(!o.includes(s))throw new Error(`Foreign key "${t.fields[0]}" references "${i}.${s}", which is not a field`)}},createRecord=async(e,r)=>{if((0,_recordExists.recordExists)(e)){if(r.ifNotExists)return null;throw new Error(`Record "${e}" already exists`)}return await assertReferencesExist(e,r),(0,_create.create)(e,r.definition,r.keys)};exports.createRecord=createRecord;

package/dist/data/queries/deleteEntity.js

@@ -28,6 +28,7 @@ var _retrieveRecord = require("../utilities/retrieveRecord");
 var _retrieveFile = require("../utilities/retrieveFile");
 var _removeFromIndex = require("../utilities/removeFromIndex");
 var _computeKeyValue = require("../utilities/computeKeyValue");
+var _fieldType = require("../utilities/fieldType");
 var _hasDependents = require("../introspect/policies/hasDependents");
 var _config = require("../utilities/config");
 const {
@@ -75,7 +76,7 @@ const removeMatchingEntries = async (entity, record, primaryKey, deletedValues)
     }
     await rm(`${databasePath}${record.path}/${fileName}`);
     for (const key of record.keys) {
-      await (0, _removeFromIndex.removeFromIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, data), fileName);
+      await (0, _removeFromIndex.removeFromIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, data), fileName, (0, _fieldType.keyValueType)(record, key));
     }
   }
   return remainingEntries;

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"),_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)}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/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;

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

@@ -0,0 +1,9 @@
+import { recordDefinition } from '../introspect/definitions/record';
+export type recordDescription = Pick<recordDefinition, 'path' | 'definition' | 'keys'>;
+/**
+ * Run a parsed describe statement: the record's fields and keys (describe() in JS gives only the fields). An error
+ * if the record doesn't exist.
+ * @param entity
+ */
+export declare const describeRecord: (entity: string) => Promise<recordDescription>;
+//# sourceMappingURL=describeRecord.d.ts.map

package/dist/data/queries/describeRecord.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.describeRecord = void 0;
+var _retrieveRecord = require("../utilities/retrieveRecord");
+var _recordExists = require("../utilities/recordExists");
+/**
+ * Run a parsed describe statement: the record's fields and keys (describe() in JS gives only the fields). An error
+ * if the record doesn't exist.
+ * @param entity
+ */
+const describeRecord = async entity => {
+  if (!(0, _recordExists.recordExists)(entity)) {
+    throw new Error(`Record "${entity}" doesn't exist`);
+  }
+  const {
+    path,
+    definition,
+    keys
+  } = await (0, _retrieveRecord.retrieveRecord)(entity);
+  return {
+    path,
+    definition,
+    keys
+  };
+};
+exports.describeRecord = describeRecord;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.describeRecord=void 0;var _retrieveRecord=require("../utilities/retrieveRecord"),_recordExists=require("../utilities/recordExists");const describeRecord=async e=>{if(!(0,_recordExists.recordExists)(e))throw new Error(`Record "${e}" doesn't exist`);const{path:r,definition:i,keys:t}=await(0,_retrieveRecord.retrieveRecord)(e);return{path:r,definition:i,keys:t}};exports.describeRecord=describeRecord;

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

@@ -0,0 +1,9 @@
+import { recordDefinition } from '../introspect/definitions/record';
+/**
+ * Run a parsed drop statement: an error if the record doesn't exist, unless the statement says `if exists` (then
+ * nothing happens and the result is null). Otherwise drop() it and resolve to the definition it had.
+ * @param entity
+ * @param ifExists
+ */
+export declare const dropRecord: (entity: string, ifExists: boolean) => Promise<recordDefinition | null>;
+//# sourceMappingURL=dropRecord.d.ts.map

package/dist/data/queries/dropRecord.js

@@ -0,0 +1,61 @@
+"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.drop.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dropRecord = void 0;
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.some.js");
+var _drop = require("../introspect/drop");
+var _retrieveRecord = require("../utilities/retrieveRecord");
+var _recordExists = require("../utilities/recordExists");
+var _splitEntityProperty = require("../utilities/parsers/splitEntityProperty");
+var _config = require("../utilities/config");
+/**
+ * RESTRICT, as MySQL does for a referenced table: reject dropping a record while another record has a foreign key
+ * referencing it, since every write to that record would then fail looking for the dropped one. A record referencing
+ * itself doesn't count. Off with enforceForeignKeys, like the row-level checks.
+ * @param entity
+ */
+const assertNotReferenced = async entity => {
+  if (!(0, _config.getSetting)('enforceForeignKeys', true) || !(0, _recordExists.recordExists)('__RECORDS')) {
+    return;
+  }
+  const registry = await (0, _retrieveRecord.retrieveRecord)('__RECORDS');
+  for (const fileName of registry.entries) {
+    const other = fileName.replace(/\.json$/, '');
+    if (other === entity || !(0, _recordExists.recordExists)(other)) {
+      continue;
+    }
+    for (const key of (await (0, _retrieveRecord.retrieveRecord)(other)).keys) {
+      if (key.type !== 'foreign' || !key.references) {
+        continue;
+      }
+      if (key.references.some(reference => (0, _splitEntityProperty.splitEntityProperty)(reference.fields[0]).entity === entity)) {
+        throw new Error(`Cannot drop "${entity}": ${other}.${key.fields.join(', ')} references it`);
+      }
+    }
+  }
+};
+/**
+ * Run a parsed drop statement: an error if the record doesn't exist, unless the statement says `if exists` (then
+ * nothing happens and the result is null). Otherwise drop() it and resolve to the definition it had.
+ * @param entity
+ * @param ifExists
+ */
+const dropRecord = async (entity, ifExists) => {
+  if (!(0, _recordExists.recordExists)(entity)) {
+    if (ifExists) {
+      return null;
+    }
+    throw new Error(`Record "${entity}" doesn't exist`);
+  }
+  await assertNotReferenced(entity);
+  const record = await (0, _retrieveRecord.retrieveRecord)(entity);
+  await (0, _drop.drop)(entity);
+  return record;
+};
+exports.dropRecord = dropRecord;

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

@@ -0,0 +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.drop.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.dropRecord=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.some.js");var _drop=require("../introspect/drop"),_retrieveRecord=require("../utilities/retrieveRecord"),_recordExists=require("../utilities/recordExists"),_splitEntityProperty=require("../utilities/parsers/splitEntityProperty"),_config=require("../utilities/config");const assertNotReferenced=async e=>{if(!(0,_config.getSetting)("enforceForeignKeys",!0)||!(0,_recordExists.recordExists)("__RECORDS"))return;const r=await(0,_retrieveRecord.retrieveRecord)("__RECORDS");for(const t of r.entries){const r=t.replace(/\.json$/,"");if(r!==e&&(0,_recordExists.recordExists)(r))for(const t of(await(0,_retrieveRecord.retrieveRecord)(r)).keys)if("foreign"===t.type&&t.references&&t.references.some((r=>(0,_splitEntityProperty.splitEntityProperty)(r.fields[0]).entity===e)))throw new Error(`Cannot drop "${e}": ${r}.${t.fields.join(", ")} references it`)}},dropRecord=async(e,r)=>{if(!(0,_recordExists.recordExists)(e)){if(r)return null;throw new Error(`Record "${e}" doesn't exist`)}await assertNotReferenced(e);const t=await(0,_retrieveRecord.retrieveRecord)(e);return await(0,_drop.drop)(e),t};exports.dropRecord=dropRecord;