json-fs-query 1.1.0 → 2.1.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

@@ -1,29 +1,29 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-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.
- * @param entity
- * @param property
- * @param value
- */
-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,
-    type
-  });
-  return found.length > 0;
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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.
+ * @param entity
+ * @param property
+ * @param value
+ */
+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,
+    type
+  });
+  return found.length > 0;
+};
 exports.foreignKeyExists = foreignKeyExists;

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

@@ -1,54 +1,54 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.hasDependents = void 0;
-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
- * 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.
- * @param entity
- * @param property
- * @param value
- */
-const hasDependents = async (entity, property, value) => {
-  const entityFiles = await (0, _describe.describe)();
-  for (const entityFile of entityFiles) {
-    const otherEntity = entityFile.replace(/\.json$/, '');
-    const otherRecord = await (0, _retrieveRecord.retrieveRecord)(otherEntity);
-    for (const key of otherRecord.keys) {
-      if (key.type !== 'foreign' || key.fields.length !== 1 || !key.references || key.references.length !== 1) {
-        continue;
-      }
-      const {
-        entity: refEntity,
-        property: refProperty
-      } = (0, _splitEntityProperty.splitEntityProperty)(key.references[0].fields[0]);
-      if (refEntity !== entity || refProperty !== property) {
-        continue;
-      }
-      const records = await (0, _retrieveRecords.retrieveRecords)(otherEntity);
-      const found = (0, _where.where)(records, {
-        property: key.fields[0],
-        comparator: '=',
-        value,
-        type: (0, _fieldType.fieldType)(otherRecord, key.fields[0])
-      });
-      if (found.length) {
-        return true;
-      }
-    }
-  }
-  return false;
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hasDependents = void 0;
+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
+ * 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.
+ * @param entity
+ * @param property
+ * @param value
+ */
+const hasDependents = async (entity, property, value) => {
+  const entityFiles = await (0, _describe.describe)();
+  for (const entityFile of entityFiles) {
+    const otherEntity = entityFile.replace(/\.json$/, '');
+    const otherRecord = await (0, _retrieveRecord.retrieveRecord)(otherEntity);
+    for (const key of otherRecord.keys) {
+      if (key.type !== 'foreign' || key.fields.length !== 1 || !key.references || key.references.length !== 1) {
+        continue;
+      }
+      const {
+        entity: refEntity,
+        property: refProperty
+      } = (0, _splitEntityProperty.splitEntityProperty)(key.references[0].fields[0]);
+      if (refEntity !== entity || refProperty !== property) {
+        continue;
+      }
+      const records = await (0, _retrieveRecords.retrieveRecords)(otherEntity);
+      const found = (0, _where.where)(records, {
+        property: key.fields[0],
+        comparator: '=',
+        value,
+        type: (0, _fieldType.fieldType)(otherRecord, key.fields[0])
+      });
+      if (found.length) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
 exports.hasDependents = hasDependents;

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

@@ -1,35 +1,35 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-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.
- * references and checkKeys are parallel arrays: references[i]'s value must equal checkKeys[i].
- * @param entity
- * @param references
- * @param checkKeys
- */
-const keyUnique = async (entity, references = [], checkKeys = []) => {
-  if (!references.length || references.length !== checkKeys.length) {
-    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],
-      type: (0, _fieldType.fieldType)(record, references[i])
-    });
-  }
-  return !records.length;
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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.
+ * references and checkKeys are parallel arrays: references[i]'s value must equal checkKeys[i].
+ * @param entity
+ * @param references
+ * @param checkKeys
+ */
+const keyUnique = async (entity, references = [], checkKeys = []) => {
+  if (!references.length || references.length !== checkKeys.length) {
+    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],
+      type: (0, _fieldType.fieldType)(record, references[i])
+    });
+  }
+  return !records.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);
@@ -27,6 +41,10 @@ const typeCheck = (type = 'string', value = undefined) => {
         if (Number.isNaN(coerced) || !Number.isInteger(coerced)) {
           throw new Error(`Value "${value}" is not a valid int`);
         }
+        // Past Number.MAX_SAFE_INTEGER an int can't be held exactly: '9007199254740993' would be stored as ...992
+        if (!Number.isSafeInteger(coerced)) {
+          throw new Error(`Value "${value}" is too large for an int (the largest is ${Number.MAX_SAFE_INTEGER})`);
+        }
         return coerced;
       }
     case 'boolean':

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`);if(!Number.isSafeInteger(e))throw new Error(`Value "${r}" is too large for an int (the largest is ${Number.MAX_SAFE_INTEGER})`);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;