json-fs-query 1.0.6 → 2.0.0

package/dist/data/queries/insertEntity.js

@@ -8,6 +8,7 @@ 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.iterator.some.js");
 var _retrieveRecord = require("../utilities/retrieveRecord");
 var _updateIndex = require("../utilities/updateIndex");
 var _keyGenerate = require("../introspect/policies/keyGenerate");
@@ -17,6 +18,7 @@ var _typeCheck = require("../introspect/policies/typeCheck");
 var _foreignKeyExists = require("../introspect/policies/foreignKeyExists");
 var _splitEntityProperty = require("../utilities/parsers/splitEntityProperty");
 var _computeKeyValue = require("../utilities/computeKeyValue");
+var _fieldType = require("../utilities/fieldType");
 var _config = require("../utilities/config");
 const {
   writeFile
@@ -43,13 +45,14 @@ const buildEntityValues = async (entity, record, rowValues = {}) => {
       }
       continue;
     }
-    entityValues[field.name] = (0, _typeCheck.typeCheck)(field.type, value);
+    entityValues[field.name] = (0, _typeCheck.typeCheck)(field.type, value, field.nullable);
   }
   return entityValues;
 };
 /**
  * Reject the insert if it collides with an existing primary or unique key value - a single field,
- * or a composite of several for a multi-field key.
+ * or a composite of several for a multi-field key. As in SQL, a value with a null in it is never a
+ * duplicate, so a nullable unique field can hold null in any number of rows.
  * @param entity
  * @param record
  * @param entityValues
@@ -60,6 +63,9 @@ const assertUnique = async (entity, record, entityValues) => {
       continue;
     }
     const checkKeys = key.fields.map(field => entityValues[field]);
+    if (checkKeys.some(value => value === null)) {
+      continue;
+    }
     const isUnique = await (0, _keyUnique.keyUnique)(entity, key.fields, checkKeys);
     if (!isUnique) {
       throw new Error(`Duplicate value for ${key.type} key "${key.fields.join(', ')}" on ${entity}`);
@@ -68,7 +74,7 @@ const assertUnique = async (entity, record, entityValues) => {
 };
 /**
  * Reject the insert if a single-field foreign key's value doesn't exist in the record it
- * references.
+ * references. A null references nothing, so it isn't checked (as in SQL).
  * @param entity
  * @param record
  * @param entityValues
@@ -79,7 +85,7 @@ const assertForeignKeys = async (entity, record, entityValues) => {
       continue;
     }
     const field = key.fields[0];
-    if (!Object.prototype.hasOwnProperty.call(entityValues, field)) {
+    if (!Object.prototype.hasOwnProperty.call(entityValues, field) || entityValues[field] === null) {
       continue;
     }
     const {
@@ -108,7 +114,7 @@ const insertEntity = async (entity = '', values = [], dataSet = {}) => {
     record.entries.push(fileName);
     await writeFile(`${databasePath}${record.path}.json`, JSON.stringify(record, null, 2));
     for (const key of record.keys) {
-      await (0, _updateIndex.updateIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, entityValues), fileName);
+      await (0, _updateIndex.updateIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, entityValues), fileName, (0, _fieldType.keyValueType)(record, key));
     }
     dataSet[entity].push(entityValues);
   }

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.insertEntity=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");var _retrieveRecord=require("../utilities/retrieveRecord"),_updateIndex=require("../utilities/updateIndex"),_keyGenerate=require("../introspect/policies/keyGenerate"),_keyUnique=require("../introspect/policies/keyUnique"),_useDefault=require("../introspect/policies/useDefault"),_typeCheck=require("../introspect/policies/typeCheck"),_foreignKeyExists=require("../introspect/policies/foreignKeyExists"),_splitEntityProperty=require("../utilities/parsers/splitEntityProperty"),_computeKeyValue=require("../utilities/computeKeyValue"),_config=require("../utilities/config");const{writeFile:writeFile}=require("fs/promises"),buildEntityValues=async(e,t,i={})=>{const r={};for(const s of t.definition){let t=i[s.name];if(s.autoGenerate?t=await(0,_keyGenerate.keyGenerate)(e,[s.name]):Object.prototype.hasOwnProperty.call(s,"default")&&(t=(0,_useDefault.useDefault)(s.default,t)),void 0!==t)r[s.name]=(0,_typeCheck.typeCheck)(s.type,t);else if(!s.optional)throw new Error(`Missing required field "${s.name}" for ${e}`)}return r},assertUnique=async(e,t,i)=>{for(const r of t.keys){if("primary"!==r.type&&"unique"!==r.type)continue;const t=r.fields.map((e=>i[e]));if(!await(0,_keyUnique.keyUnique)(e,r.fields,t))throw new Error(`Duplicate value for ${r.type} key "${r.fields.join(", ")}" on ${e}`)}},assertForeignKeys=async(e,t,i)=>{for(const r of t.keys){if("foreign"!==r.type||1!==r.fields.length||!r.references||1!==r.references.length)continue;const t=r.fields[0];if(!Object.prototype.hasOwnProperty.call(i,t))continue;const{entity:s,property:n}=(0,_splitEntityProperty.splitEntityProperty)(r.references[0].fields[0]);if(!await(0,_foreignKeyExists.foreignKeyExists)(s,n,i[t]))throw new Error(`Foreign key "${t}" on ${e} references a nonexistent ${s}.${n} = ${i[t]}`)}},insertEntity=async(e="",t=[],i={})=>{const r=(0,_config.getSetting)("databasePath","database/"),s=await(0,_retrieveRecord.retrieveRecord)(e),n=s.keys.find((e=>"primary"===e.type&&1===e.fields.length));Object.prototype.hasOwnProperty.call(i,e)||(i[e]=[]);for(const o of t){const t=await buildEntityValues(e,s,o);await assertUnique(e,s,t),await assertForeignKeys(e,s,t);const a=`${n?t[n.fields[0]]:crypto.randomUUID()}.json`;await writeFile(`${r}${s.path}/${a}`,JSON.stringify(t,null,2)),s.entries.push(a),await writeFile(`${r}${s.path}.json`,JSON.stringify(s,null,2));for(const e of s.keys)await(0,_updateIndex.updateIndex)(s.path,e,(0,_computeKeyValue.computeKeyValue)(e.fields,t),a);i[e].push(t)}return i};exports.insertEntity=insertEntity;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.insertEntity=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.iterator.some.js");var _retrieveRecord=require("../utilities/retrieveRecord"),_updateIndex=require("../utilities/updateIndex"),_keyGenerate=require("../introspect/policies/keyGenerate"),_keyUnique=require("../introspect/policies/keyUnique"),_useDefault=require("../introspect/policies/useDefault"),_typeCheck=require("../introspect/policies/typeCheck"),_foreignKeyExists=require("../introspect/policies/foreignKeyExists"),_splitEntityProperty=require("../utilities/parsers/splitEntityProperty"),_computeKeyValue=require("../utilities/computeKeyValue"),_fieldType=require("../utilities/fieldType"),_config=require("../utilities/config");const{writeFile:writeFile}=require("fs/promises"),buildEntityValues=async(e,t,i={})=>{const r={};for(const s of t.definition){let t=i[s.name];if(s.autoGenerate?t=await(0,_keyGenerate.keyGenerate)(e,[s.name]):Object.prototype.hasOwnProperty.call(s,"default")&&(t=(0,_useDefault.useDefault)(s.default,t)),void 0!==t)r[s.name]=(0,_typeCheck.typeCheck)(s.type,t,s.nullable);else if(!s.optional)throw new Error(`Missing required field "${s.name}" for ${e}`)}return r},assertUnique=async(e,t,i)=>{for(const r of t.keys){if("primary"!==r.type&&"unique"!==r.type)continue;const t=r.fields.map((e=>i[e]));if(t.some((e=>null===e)))continue;if(!await(0,_keyUnique.keyUnique)(e,r.fields,t))throw new Error(`Duplicate value for ${r.type} key "${r.fields.join(", ")}" on ${e}`)}},assertForeignKeys=async(e,t,i)=>{for(const r of t.keys){if("foreign"!==r.type||1!==r.fields.length||!r.references||1!==r.references.length)continue;const t=r.fields[0];if(!Object.prototype.hasOwnProperty.call(i,t)||null===i[t])continue;const{entity:s,property:n}=(0,_splitEntityProperty.splitEntityProperty)(r.references[0].fields[0]);if(!await(0,_foreignKeyExists.foreignKeyExists)(s,n,i[t]))throw new Error(`Foreign key "${t}" on ${e} references a nonexistent ${s}.${n} = ${i[t]}`)}},insertEntity=async(e="",t=[],i={})=>{const r=(0,_config.getSetting)("databasePath","database/"),s=await(0,_retrieveRecord.retrieveRecord)(e),n=s.keys.find((e=>"primary"===e.type&&1===e.fields.length));Object.prototype.hasOwnProperty.call(i,e)||(i[e]=[]);for(const o of t){const t=await buildEntityValues(e,s,o);await assertUnique(e,s,t),await assertForeignKeys(e,s,t);const a=`${n?t[n.fields[0]]:crypto.randomUUID()}.json`;await writeFile(`${r}${s.path}/${a}`,JSON.stringify(t,null,2)),s.entries.push(a),await writeFile(`${r}${s.path}.json`,JSON.stringify(s,null,2));for(const e of s.keys)await(0,_updateIndex.updateIndex)(s.path,e,(0,_computeKeyValue.computeKeyValue)(e.fields,t),a,(0,_fieldType.keyValueType)(s,e));i[e].push(t)}return i};exports.insertEntity=insertEntity;

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

@@ -1,2 +1,2 @@
-export declare const parser: (queries?: string) => any[];
+export declare const parser: (queries?: string) => import("../utilities/parsers/parseQuery").ParsedQuery[];
 //# sourceMappingURL=parser.d.ts.map

package/dist/data/queries/parser.js

@@ -4,27 +4,19 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.parser = void 0;
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.map.js");
 var _splitQueries = require("../utilities/parsers/splitQueries");
 var _parseQuery = require("../utilities/parsers/parseQuery");
 const parser = (queries = '') => {
   const queryArray = (0, _splitQueries.splitQueries)(queries);
-  const parsedQueries = [];
-  let mergeQuery = '';
-  for (const query of queryArray) {
-    mergeQuery = mergeQuery ? `${mergeQuery}${query}` : query;
-    let parsedQuery = {};
+  return queryArray.map((query, index) => {
     try {
-      parsedQuery = (0, _parseQuery.parseQuery)(mergeQuery);
-      mergeQuery = '';
+      return (0, _parseQuery.parseQuery)(query);
     } catch (e) {
-      // attempt to combine queries to fix bad splits
-      continue;
+      const which = queryArray.length > 1 ? ` query ${index + 1} of ${queryArray.length}` : '';
+      throw new Error(`Failed to interpret${which}: ${query} (${e.message})`);
     }
-    parsedQueries.push(parsedQuery);
-  }
-  if (mergeQuery) {
-    throw new Error(`Failed to interpret: ${mergeQuery}`);
-  }
-  return parsedQueries;
+  });
 };
 exports.parser = parser;

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.parser=void 0;var _splitQueries=require("../utilities/parsers/splitQueries"),_parseQuery=require("../utilities/parsers/parseQuery");const parser=(e="")=>{const r=(0,_splitQueries.splitQueries)(e),s=[];let t="";for(const e of r){t=t?`${t}${e}`:e;let r={};try{r=(0,_parseQuery.parseQuery)(t),t=""}catch(e){continue}s.push(r)}if(t)throw new Error(`Failed to interpret: ${t}`);return s};exports.parser=parser;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.parser=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.map.js");var _splitQueries=require("../utilities/parsers/splitQueries"),_parseQuery=require("../utilities/parsers/parseQuery");const parser=(e="")=>{const r=(0,_splitQueries.splitQueries)(e);return r.map(((e,s)=>{try{return(0,_parseQuery.parseQuery)(e)}catch(t){const i=r.length>1?` query ${s+1} of ${r.length}`:"";throw new Error(`Failed to interpret${i}: ${e} (${t.message})`)}}))};exports.parser=parser;

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

@@ -1,2 +1,8 @@
+/**
+ * Parse a query string (one query, or several separated by `;`) and run each query in turn, resolving to one result
+ * per query. The queries of one call run together, under the database lock: no other call's queries run between
+ * them (see withDatabaseLock).
+ * @param queryString
+ */
 export declare const query: (queryString?: string) => Promise<any[]>;
 //# sourceMappingURL=query.d.ts.map

package/dist/data/queries/query.js

@@ -6,13 +6,22 @@ Object.defineProperty(exports, "__esModule", {
 exports.query = void 0;
 var _parser = require("./parser");
 var _runQuery = require("../utilities/runQuery");
+var _databaseLock = require("../utilities/databaseLock");
+/**
+ * Parse a query string (one query, or several separated by `;`) and run each query in turn, resolving to one result
+ * per query. The queries of one call run together, under the database lock: no other call's queries run between
+ * them (see withDatabaseLock).
+ * @param queryString
+ */
 const query = async (queryString = '') => {
   const parsedQueries = (0, _parser.parser)(queryString);
-  const queryResults = [];
-  for (const parsed of parsedQueries) {
-    const dataSet = await (0, _runQuery.runQuery)(parsed);
-    queryResults.push(dataSet[parsed.entity]);
-  }
-  return queryResults;
+  return (0, _databaseLock.withDatabaseLock)(async () => {
+    const queryResults = [];
+    for (const parsed of parsedQueries) {
+      const dataSet = await (0, _runQuery.runQuery)(parsed);
+      queryResults.push(dataSet[parsed.entity]);
+    }
+    return queryResults;
+  });
 };
 exports.query = query;

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.query=void 0;var _parser=require("./parser"),_runQuery=require("../utilities/runQuery");const query=async(r="")=>{const e=(0,_parser.parser)(r),u=[];for(const r of e){const e=await(0,_runQuery.runQuery)(r);u.push(e[r.entity])}return u};exports.query=query;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.query=void 0;var _parser=require("./parser"),_runQuery=require("../utilities/runQuery"),_databaseLock=require("../utilities/databaseLock");const query=async(e="")=>{const r=(0,_parser.parser)(e);return(0,_databaseLock.withDatabaseLock)((async()=>{const e=[];for(const t of r){const r=await(0,_runQuery.runQuery)(t);e.push(r[t.entity])}return e}))};exports.query=query;

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

@@ -0,0 +1,15 @@
+export type QueryStatus = {
+    complete: boolean;
+    waitingFor: string;
+};
+/**
+ * Whether some query text, typed so far, is ready to run, and if not what it is waiting for: for a prompt which
+ * reads a query over several lines (such as the CLI). Uses the same rules as the parser, so a `;` inside a string,
+ * a comment or brackets doesn't count, and an open quote, comment or bracket keeps the query going.
+ * @example
+ * queryStatus("read notes where text = 'it") // { complete: false, waitingFor: "'" }
+ * queryStatus('read notes;') // { complete: true, waitingFor: '' }
+ * @param text - everything typed so far; join the lines with '\n', since a `--` comment ends at the end of a line
+ */
+export declare const queryStatus: (text?: string) => QueryStatus;
+//# sourceMappingURL=queryStatus.d.ts.map

package/dist/data/queries/queryStatus.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.queryStatus = void 0;
+var _scanQuery = require("../utilities/parsers/scanQuery");
+/**
+ * Whether some query text, typed so far, is ready to run, and if not what it is waiting for: for a prompt which
+ * reads a query over several lines (such as the CLI). Uses the same rules as the parser, so a `;` inside a string,
+ * a comment or brackets doesn't count, and an open quote, comment or bracket keeps the query going.
+ * @example
+ * queryStatus("read notes where text = 'it") // { complete: false, waitingFor: "'" }
+ * queryStatus('read notes;') // { complete: true, waitingFor: '' }
+ * @param text - everything typed so far; join the lines with '\n', since a `--` comment ends at the end of a line
+ */
+const queryStatus = (text = '') => {
+  const {
+    end,
+    closed,
+    terminated
+  } = (0, _scanQuery.scanQuery)(text);
+  if (terminated) {
+    return {
+      complete: true,
+      waitingFor: ''
+    };
+  }
+  if (end.quote) {
+    return {
+      complete: false,
+      waitingFor: end.quote
+    };
+  }
+  if (end.blockComment) {
+    return {
+      complete: false,
+      waitingFor: '/*'
+    };
+  }
+  if (!closed) {
+    return {
+      complete: false,
+      waitingFor: end.brackets[end.brackets.length - 1]
+    };
+  }
+  return {
+    complete: false,
+    waitingFor: ';'
+  };
+};
+exports.queryStatus = queryStatus;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.queryStatus=void 0;var _scanQuery=require("../utilities/parsers/scanQuery");const queryStatus=(e="")=>{const{end:t,closed:r,terminated:o}=(0,_scanQuery.scanQuery)(e);return o?{complete:!0,waitingFor:""}:t.quote?{complete:!1,waitingFor:t.quote}:t.blockComment?{complete:!1,waitingFor:"/*"}:r?{complete:!1,waitingFor:";"}:{complete:!1,waitingFor:t.brackets[t.brackets.length-1]}};exports.queryStatus=queryStatus;

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

@@ -0,0 +1,11 @@
+/**
+ * Write a value as a quoted string for a query, so any text can be used in one: the backslash and the quote are
+ * escaped, so the parser reads back exactly the text given.
+ * @example
+ * query(`insert exercises values name = ${quote("Farmer's walk")}`)
+ * // insert exercises values name = 'Farmer\'s walk'
+ * @param value - the text to quote (anything else is converted with String first)
+ * @param quoteChar - the quote to wrap it in
+ */
+export declare const quote: (value: any, quoteChar?: "'" | "\"") => string;
+//# sourceMappingURL=quote.d.ts.map

package/dist/data/queries/quote.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.quote = void 0;
+/**
+ * Write a value as a quoted string for a query, so any text can be used in one: the backslash and the quote are
+ * escaped, so the parser reads back exactly the text given.
+ * @example
+ * query(`insert exercises values name = ${quote("Farmer's walk")}`)
+ * // insert exercises values name = 'Farmer\'s walk'
+ * @param value - the text to quote (anything else is converted with String first)
+ * @param quoteChar - the quote to wrap it in
+ */
+const quote = (value, quoteChar = '\'') => `${quoteChar}${String(value).replace(/\\/g, '\\\\').split(quoteChar).join(`\\${quoteChar}`)}${quoteChar}`;
+exports.quote = quote;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.quote=void 0;const quote=(e,t="'")=>`${t}${String(e).replace(/\\/g,"\\\\").split(t).join(`\\${t}`)}${t}`;exports.quote=quote;

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

@@ -0,0 +1,6 @@
+/**
+ * Run `show records`: the name of every record in the __RECORDS registry, in the order they were created. A database
+ * with no records yet (no registry file) gives an empty list.
+ */
+export declare const showRecords: () => Promise<string[]>;
+//# sourceMappingURL=showRecords.d.ts.map

package/dist/data/queries/showRecords.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.showRecords = void 0;
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.map.js");
+var _retrieveRecord = require("../utilities/retrieveRecord");
+var _recordExists = require("../utilities/recordExists");
+/**
+ * Run `show records`: the name of every record in the __RECORDS registry, in the order they were created. A database
+ * with no records yet (no registry file) gives an empty list.
+ */
+const showRecords = async () => {
+  if (!(0, _recordExists.recordExists)('__RECORDS')) {
+    return [];
+  }
+  return (await (0, _retrieveRecord.retrieveRecord)('__RECORDS')).entries.map(fileName => fileName.replace(/\.json$/, ''));
+};
+exports.showRecords = showRecords;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.showRecords=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.map.js");var _retrieveRecord=require("../utilities/retrieveRecord"),_recordExists=require("../utilities/recordExists");const showRecords=async()=>(0,_recordExists.recordExists)("__RECORDS")?(await(0,_retrieveRecord.retrieveRecord)("__RECORDS")).entries.map((e=>e.replace(/\.json$/,""))):[];exports.showRecords=showRecords;

package/dist/data/queries/sortBy.js

@@ -12,6 +12,9 @@ const sortBy = (dataSet = [], sortClauses = []) => {
     for (const sortClause of sortClauses) {
       const property = sortClause.property;
       const direction = sortClause.direction;
+      // Ordering compares the raw stored values, not by declared type (that's only for equality, see where), so
+      // numeric ids in a string field still sort numerically. Loose so '3' and 3 still tie.
+      // eslint-disable-next-line eqeqeq
       if (a[property] == b[property]) {
         continue;
       }

package/dist/data/queries/updateEntity.js

@@ -14,6 +14,8 @@ var _retrieveFile = require("../utilities/retrieveFile");
 var _updateIndex = require("../utilities/updateIndex");
 var _removeFromIndex = require("../utilities/removeFromIndex");
 var _computeKeyValue = require("../utilities/computeKeyValue");
+var _fieldType = require("../utilities/fieldType");
+var _compareAs = require("../utilities/compareAs");
 var _keyUnique = require("../introspect/policies/keyUnique");
 var _typeCheck = require("../introspect/policies/typeCheck");
 var _foreignKeyExists = require("../introspect/policies/foreignKeyExists");
@@ -34,7 +36,7 @@ const {
 const findEntryFile = async (record, primaryKey, primaryValue) => {
   for (const fileName of record.entries) {
     const data = await (0, _retrieveFile.retrieveFile)(`${record.path}/${fileName}`);
-    if ((0, _computeKeyValue.computeKeyValue)(primaryKey.fields, data) == primaryValue) {
+    if ((0, _compareAs.sameValue)((0, _fieldType.keyValueType)(record, primaryKey), (0, _computeKeyValue.computeKeyValue)(primaryKey.fields, data), primaryValue)) {
       return fileName;
     }
   }
@@ -43,15 +45,17 @@ const findEntryFile = async (record, primaryKey, primaryValue) => {
 /**
  * True if the update actually changes at least one of this key's fields - a key none of whose
  * fields appear in newValues, or whose given values are all unchanged, doesn't need re-checking.
+ * @param record
  * @param key
  * @param oldData
  * @param newValues
  */
-const keyFieldsChanged = (key, oldData, newValues) => key.fields.some(field => Object.prototype.hasOwnProperty.call(newValues, field) && newValues[field] != oldData[field]);
+const keyFieldsChanged = (record, key, oldData, newValues) => key.fields.some(field => Object.prototype.hasOwnProperty.call(newValues, field) && !(0, _compareAs.sameValue)((0, _fieldType.fieldType)(record, field), newValues[field], oldData[field]));
 /**
  * Only check uniqueness for a primary/unique key (single-field, or composite) whose value is
  * actually changing - checking an unchanged value would find the record's own existing entry and
- * wrongly report it as a duplicate of itself.
+ * wrongly report it as a duplicate of itself. A value with a null in it is never a duplicate (as in
+ * SQL).
  * @param entity
  * @param record
  * @param oldData
@@ -60,10 +64,13 @@ const keyFieldsChanged = (key, oldData, newValues) => key.fields.some(field => O
  */
 const assertUniqueForUpdate = async (entity, record, oldData, newData, newValues) => {
   for (const key of record.keys) {
-    if (key.type !== 'primary' && key.type !== 'unique' || !keyFieldsChanged(key, oldData, newValues)) {
+    if (key.type !== 'primary' && key.type !== 'unique' || !keyFieldsChanged(record, key, oldData, newValues)) {
       continue;
     }
     const checkKeys = key.fields.map(field => newData[field]);
+    if (checkKeys.some(value => value === null)) {
+      continue;
+    }
     const isUnique = await (0, _keyUnique.keyUnique)(entity, key.fields, checkKeys);
     if (!isUnique) {
       throw new Error(`Duplicate value for ${key.type} key "${key.fields.join(', ')}" on ${entity}`);
@@ -73,7 +80,8 @@ const assertUniqueForUpdate = async (entity, record, oldData, newData, newValues
 /**
  * Same "only if it actually changed" scoping as assertUniqueForUpdate: re-checking an unchanged
  * foreign key value would re-validate a reference this update never touches, which could fail an
- * unrelated field's update if that parent record happened to be deleted since.
+ * unrelated field's update if that parent record happened to be deleted since. A null references
+ * nothing, so it isn't checked.
  * @param entity
  * @param record
  * @param oldData
@@ -85,7 +93,7 @@ const assertForeignKeysForUpdate = async (entity, record, oldData, newValues) =>
       continue;
     }
     const field = key.fields[0];
-    if (!Object.prototype.hasOwnProperty.call(newValues, field) || newValues[field] == oldData[field]) {
+    if (!Object.prototype.hasOwnProperty.call(newValues, field) || newValues[field] === null || (0, _compareAs.sameValue)((0, _fieldType.fieldType)(record, field), newValues[field], oldData[field])) {
       continue;
     }
     const {
@@ -104,12 +112,13 @@ const assertForeignKeysForUpdate = async (entity, record, oldData, newValues) =>
  * dangling, since the row itself isn't gone, just re-keyed. Only meaningful for a single-field
  * primary key, matching foreign key support's own single-field-only scope.
  * @param entity
+ * @param record
  * @param primaryKey
  * @param oldData
  * @param newValues
  */
-const assertNoDependentsForUpdate = async (entity, primaryKey, oldData, newValues) => {
-  if (!(0, _config.getSetting)('enforceForeignKeys', true) || primaryKey.fields.length !== 1 || !keyFieldsChanged(primaryKey, oldData, newValues)) {
+const assertNoDependentsForUpdate = async (entity, record, primaryKey, oldData, newValues) => {
+  if (!(0, _config.getSetting)('enforceForeignKeys', true) || primaryKey.fields.length !== 1 || !keyFieldsChanged(record, primaryKey, oldData, newValues)) {
     return;
   }
   const property = primaryKey.fields[0];
@@ -128,11 +137,41 @@ const assertNoDependentsForUpdate = async (entity, primaryKey, oldData, newValue
  */
 const reconcileIndexes = async (record, oldData, newData, newValues, fileName) => {
   for (const key of record.keys) {
-    if (!keyFieldsChanged(key, oldData, newValues)) {
+    if (!keyFieldsChanged(record, key, oldData, newValues)) {
+      continue;
+    }
+    await (0, _removeFromIndex.removeFromIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, oldData), fileName, (0, _fieldType.keyValueType)(record, key));
+    await (0, _updateIndex.updateIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, newData), fileName, (0, _fieldType.keyValueType)(record, key));
+  }
+};
+/**
+ * The rows of one update are checked before any is written, so a check can't see the batch's own new values on disk.
+ * Reject the update if two of its rows would end with the same value for a primary or unique key that it changes (a
+ * value with a null in it is never a duplicate, as in assertUniqueForUpdate).
+ * @param entity
+ * @param record
+ * @param planned
+ * @param newValues
+ */
+const assertUniqueWithinUpdate = (entity, record, planned, newValues) => {
+  for (const key of record.keys) {
+    if (key.type !== 'primary' && key.type !== 'unique') {
       continue;
     }
-    await (0, _removeFromIndex.removeFromIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, oldData), fileName);
-    await (0, _updateIndex.updateIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, newData), fileName);
+    const claimed = [];
+    for (const {
+      oldData,
+      newData
+    } of planned) {
+      if (!keyFieldsChanged(record, key, oldData, newValues) || key.fields.some(field => newData[field] === null)) {
+        continue;
+      }
+      const value = (0, _computeKeyValue.computeKeyValue)(key.fields, newData);
+      if (claimed.some(other => (0, _compareAs.sameValue)((0, _fieldType.keyValueType)(record, key), other, value))) {
+        throw new Error(`Duplicate value for ${key.type} key "${key.fields.join(', ')}" on ${entity}`);
+      }
+      claimed.push(value);
+    }
   }
 };
 const assertRequiredFields = (entity, record, newData) => {
@@ -154,7 +193,7 @@ const applyFieldTypes = (record, values) => {
   const typedValues = Object.assign({}, values);
   for (const field of record.definition) {
     if (Object.prototype.hasOwnProperty.call(typedValues, field.name)) {
-      typedValues[field.name] = (0, _typeCheck.typeCheck)(field.type, typedValues[field.name]);
+      typedValues[field.name] = (0, _typeCheck.typeCheck)(field.type, typedValues[field.name], field.nullable);
     }
   }
   return typedValues;
@@ -167,24 +206,41 @@ const updateEntity = async (entity = '', values = {}, dataSet = {}) => {
     throw new Error(`Cannot update "${entity}" without a primary key`);
   }
   const typedValues = applyFieldTypes(record, values);
-  const toUpdate = dataSet[entity] || [];
-  const updatedRows = [];
-  for (const row of toUpdate) {
+  // Check every row first and write only once all of them pass, so a row that fails leaves the others unchanged too
+  const planned = [];
+  for (const row of dataSet[entity] || []) {
     const fileName = await findEntryFile(record, primaryKey, (0, _computeKeyValue.computeKeyValue)(primaryKey.fields, row));
     if (!fileName) {
       throw new Error(`Could not find entry for ${entity} where "${primaryKey.fields.join(', ')}" = ${(0, _computeKeyValue.computeKeyValue)(primaryKey.fields, row)}`);
     }
+    if (planned.some(other => other.fileName === fileName)) {
+      // The same entry given twice is one row: updating it once is enough, and it can't collide with itself
+      continue;
+    }
     const oldData = await (0, _retrieveFile.retrieveFile)(`${record.path}/${fileName}`);
     const newData = Object.assign({}, oldData, typedValues);
     await assertUniqueForUpdate(entity, record, oldData, newData, typedValues);
     await assertForeignKeysForUpdate(entity, record, oldData, typedValues);
-    await assertNoDependentsForUpdate(entity, primaryKey, oldData, typedValues);
+    await assertNoDependentsForUpdate(entity, record, primaryKey, oldData, typedValues);
     assertRequiredFields(entity, record, newData);
+    planned.push({
+      fileName,
+      oldData,
+      newData
+    });
+  }
+  assertUniqueWithinUpdate(entity, record, planned, typedValues);
+  for (const {
+    fileName,
+    oldData,
+    newData
+  } of planned) {
     await reconcileIndexes(record, oldData, newData, typedValues, fileName);
     await writeFile(`${databasePath}${record.path}/${fileName}`, JSON.stringify(newData, null, 2));
-    updatedRows.push(newData);
   }
-  dataSet[entity] = updatedRows;
+  dataSet[entity] = planned.map(({
+    newData
+  }) => newData);
   return dataSet;
 };
 exports.updateEntity = updateEntity;

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.updateEntity=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.iterator.some.js");var _retrieveRecord=require("../utilities/retrieveRecord"),_retrieveFile=require("../utilities/retrieveFile"),_updateIndex=require("../utilities/updateIndex"),_removeFromIndex=require("../utilities/removeFromIndex"),_computeKeyValue=require("../utilities/computeKeyValue"),_keyUnique=require("../introspect/policies/keyUnique"),_typeCheck=require("../introspect/policies/typeCheck"),_foreignKeyExists=require("../introspect/policies/foreignKeyExists"),_hasDependents=require("../introspect/policies/hasDependents"),_splitEntityProperty=require("../utilities/parsers/splitEntityProperty"),_config=require("../utilities/config");const{writeFile:writeFile}=require("fs/promises"),findEntryFile=async(e,t,r)=>{for(const i of e.entries){const s=await(0,_retrieveFile.retrieveFile)(`${e.path}/${i}`);if((0,_computeKeyValue.computeKeyValue)(t.fields,s)==r)return i}return null},keyFieldsChanged=(e,t,r)=>e.fields.some((e=>Object.prototype.hasOwnProperty.call(r,e)&&r[e]!=t[e])),assertUniqueForUpdate=async(e,t,r,i,s)=>{for(const o of t.keys){if("primary"!==o.type&&"unique"!==o.type||!keyFieldsChanged(o,r,s))continue;const t=o.fields.map((e=>i[e]));if(!await(0,_keyUnique.keyUnique)(e,o.fields,t))throw new Error(`Duplicate value for ${o.type} key "${o.fields.join(", ")}" on ${e}`)}},assertForeignKeysForUpdate=async(e,t,r,i)=>{for(const s of t.keys){if("foreign"!==s.type||1!==s.fields.length||!s.references||1!==s.references.length)continue;const t=s.fields[0];if(!Object.prototype.hasOwnProperty.call(i,t)||i[t]==r[t])continue;const{entity:o,property:n}=(0,_splitEntityProperty.splitEntityProperty)(s.references[0].fields[0]);if(!await(0,_foreignKeyExists.foreignKeyExists)(o,n,i[t]))throw new Error(`Foreign key "${t}" on ${e} references a nonexistent ${o}.${n} = ${i[t]}`)}},assertNoDependentsForUpdate=async(e,t,r,i)=>{if(!(0,_config.getSetting)("enforceForeignKeys",!0)||1!==t.fields.length||!keyFieldsChanged(t,r,i))return;const s=t.fields[0];if(await(0,_hasDependents.hasDependents)(e,s,r[s]))throw new Error(`Cannot update "${e}" where "${s}" = ${r[s]} - other records still reference it`)},reconcileIndexes=async(e,t,r,i,s)=>{for(const o of e.keys)keyFieldsChanged(o,t,i)&&(await(0,_removeFromIndex.removeFromIndex)(e.path,o,(0,_computeKeyValue.computeKeyValue)(o.fields,t),s),await(0,_updateIndex.updateIndex)(e.path,o,(0,_computeKeyValue.computeKeyValue)(o.fields,r),s))},assertRequiredFields=(e,t,r)=>{for(const i of t.definition)if(!i.optional&&void 0===r[i.name])throw new Error(`Missing required field "${i.name}" for ${e}`)},applyFieldTypes=(e,t)=>{const r=Object.assign({},t);for(const t of e.definition)Object.prototype.hasOwnProperty.call(r,t.name)&&(r[t.name]=(0,_typeCheck.typeCheck)(t.type,r[t.name]));return r},updateEntity=async(e="",t={},r={})=>{const i=(0,_config.getSetting)("databasePath","database/"),s=await(0,_retrieveRecord.retrieveRecord)(e),o=s.keys.find((e=>"primary"===e.type));if(!o)throw new Error(`Cannot update "${e}" without a primary key`);const n=applyFieldTypes(s,t),a=r[e]||[],p=[];for(const t of a){const r=await findEntryFile(s,o,(0,_computeKeyValue.computeKeyValue)(o.fields,t));if(!r)throw new Error(`Could not find entry for ${e} where "${o.fields.join(", ")}" = ${(0,_computeKeyValue.computeKeyValue)(o.fields,t)}`);const a=await(0,_retrieveFile.retrieveFile)(`${s.path}/${r}`),u=Object.assign({},a,n);await assertUniqueForUpdate(e,s,a,u,n),await assertForeignKeysForUpdate(e,s,a,n),await assertNoDependentsForUpdate(e,o,a,n),assertRequiredFields(e,s,u),await reconcileIndexes(s,a,u,n,r),await writeFile(`${i}${s.path}/${r}`,JSON.stringify(u,null,2)),p.push(u)}return r[e]=p,r};exports.updateEntity=updateEntity;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.updateEntity=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.iterator.some.js");var _retrieveRecord=require("../utilities/retrieveRecord"),_retrieveFile=require("../utilities/retrieveFile"),_updateIndex=require("../utilities/updateIndex"),_removeFromIndex=require("../utilities/removeFromIndex"),_computeKeyValue=require("../utilities/computeKeyValue"),_fieldType=require("../utilities/fieldType"),_compareAs=require("../utilities/compareAs"),_keyUnique=require("../introspect/policies/keyUnique"),_typeCheck=require("../introspect/policies/typeCheck"),_foreignKeyExists=require("../introspect/policies/foreignKeyExists"),_hasDependents=require("../introspect/policies/hasDependents"),_splitEntityProperty=require("../utilities/parsers/splitEntityProperty"),_config=require("../utilities/config");const{writeFile:writeFile}=require("fs/promises"),findEntryFile=async(e,t,i)=>{for(const r of e.entries){const o=await(0,_retrieveFile.retrieveFile)(`${e.path}/${r}`);if((0,_compareAs.sameValue)((0,_fieldType.keyValueType)(e,t),(0,_computeKeyValue.computeKeyValue)(t.fields,o),i))return r}return null},keyFieldsChanged=(e,t,i,r)=>t.fields.some((t=>Object.prototype.hasOwnProperty.call(r,t)&&!(0,_compareAs.sameValue)((0,_fieldType.fieldType)(e,t),r[t],i[t]))),assertUniqueForUpdate=async(e,t,i,r,o)=>{for(const s of t.keys){if("primary"!==s.type&&"unique"!==s.type||!keyFieldsChanged(t,s,i,o))continue;const n=s.fields.map((e=>r[e]));if(n.some((e=>null===e)))continue;if(!await(0,_keyUnique.keyUnique)(e,s.fields,n))throw new Error(`Duplicate value for ${s.type} key "${s.fields.join(", ")}" on ${e}`)}},assertForeignKeysForUpdate=async(e,t,i,r)=>{for(const o of t.keys){if("foreign"!==o.type||1!==o.fields.length||!o.references||1!==o.references.length)continue;const s=o.fields[0];if(!Object.prototype.hasOwnProperty.call(r,s)||null===r[s]||(0,_compareAs.sameValue)((0,_fieldType.fieldType)(t,s),r[s],i[s]))continue;const{entity:n,property:a}=(0,_splitEntityProperty.splitEntityProperty)(o.references[0].fields[0]);if(!await(0,_foreignKeyExists.foreignKeyExists)(n,a,r[s]))throw new Error(`Foreign key "${s}" on ${e} references a nonexistent ${n}.${a} = ${r[s]}`)}},assertNoDependentsForUpdate=async(e,t,i,r,o)=>{if(!(0,_config.getSetting)("enforceForeignKeys",!0)||1!==i.fields.length||!keyFieldsChanged(t,i,r,o))return;const s=i.fields[0];if(await(0,_hasDependents.hasDependents)(e,s,r[s]))throw new Error(`Cannot update "${e}" where "${s}" = ${r[s]} - other records still reference it`)},reconcileIndexes=async(e,t,i,r,o)=>{for(const s of e.keys)keyFieldsChanged(e,s,t,r)&&(await(0,_removeFromIndex.removeFromIndex)(e.path,s,(0,_computeKeyValue.computeKeyValue)(s.fields,t),o,(0,_fieldType.keyValueType)(e,s)),await(0,_updateIndex.updateIndex)(e.path,s,(0,_computeKeyValue.computeKeyValue)(s.fields,i),o,(0,_fieldType.keyValueType)(e,s)))},assertUniqueWithinUpdate=(e,t,i,r)=>{for(const o of t.keys){if("primary"!==o.type&&"unique"!==o.type)continue;const s=[];for(const{oldData:n,newData:a}of i){if(!keyFieldsChanged(t,o,n,r)||o.fields.some((e=>null===a[e])))continue;const i=(0,_computeKeyValue.computeKeyValue)(o.fields,a);if(s.some((e=>(0,_compareAs.sameValue)((0,_fieldType.keyValueType)(t,o),e,i))))throw new Error(`Duplicate value for ${o.type} key "${o.fields.join(", ")}" on ${e}`);s.push(i)}}},assertRequiredFields=(e,t,i)=>{for(const r of t.definition)if(!r.optional&&void 0===i[r.name])throw new Error(`Missing required field "${r.name}" for ${e}`)},applyFieldTypes=(e,t)=>{const i=Object.assign({},t);for(const t of e.definition)Object.prototype.hasOwnProperty.call(i,t.name)&&(i[t.name]=(0,_typeCheck.typeCheck)(t.type,i[t.name],t.nullable));return i},updateEntity=async(e="",t={},i={})=>{const r=(0,_config.getSetting)("databasePath","database/"),o=await(0,_retrieveRecord.retrieveRecord)(e),s=o.keys.find((e=>"primary"===e.type));if(!s)throw new Error(`Cannot update "${e}" without a primary key`);const n=applyFieldTypes(o,t),a=[];for(const t of i[e]||[]){const i=await findEntryFile(o,s,(0,_computeKeyValue.computeKeyValue)(s.fields,t));if(!i)throw new Error(`Could not find entry for ${e} where "${s.fields.join(", ")}" = ${(0,_computeKeyValue.computeKeyValue)(s.fields,t)}`);if(a.some((e=>e.fileName===i)))continue;const r=await(0,_retrieveFile.retrieveFile)(`${o.path}/${i}`),l=Object.assign({},r,n);await assertUniqueForUpdate(e,o,r,l,n),await assertForeignKeysForUpdate(e,o,r,n),await assertNoDependentsForUpdate(e,o,s,r,n),assertRequiredFields(e,o,l),a.push({fileName:i,oldData:r,newData:l})}assertUniqueWithinUpdate(e,o,a,n);for(const{fileName:e,oldData:t,newData:i}of a)await reconcileIndexes(o,t,i,n,e),await writeFile(`${r}${o.path}/${e}`,JSON.stringify(i,null,2));return i[e]=a.map((({newData:e})=>e)),i};exports.updateEntity=updateEntity;

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

@@ -1,7 +1,8 @@
-export declare const where: (dataSet?: any[], { property, joinEntity, comparator, value }?: {
+export declare const where: (dataSet?: any[], { property, joinEntity, comparator, value, type }?: {
     property?: string;
     joinEntity?: any;
     comparator?: string;
     value?: any;
+    type?: any;
 }) => any[];
 //# sourceMappingURL=where.d.ts.map

package/dist/data/queries/where.js

@@ -7,6 +7,8 @@ exports.where = 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.some.js");
+var _compareAs = require("../utilities/compareAs");
 const likeMatch = (dataValue, pattern) => {
   if (typeof dataValue !== 'string' || typeof pattern !== 'string') {
     return false;
@@ -14,17 +16,26 @@ const likeMatch = (dataValue, pattern) => {
   const regexPattern = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/%/g, '.*').replace(/_/g, '.');
   return new RegExp(`^${regexPattern}$`, 'i').test(dataValue);
 };
-const makeCondition = (data, property, comparator, value) => {
+/**
+ * Equality (=, !=, <>, in) compares by the field's declared type when given one (see sameValue), so
+ * '3' and 3 match in a string or int field. Ordering (>, <, between, like) compares the raw values.
+ * @param data
+ * @param property
+ * @param comparator
+ * @param value
+ * @param type
+ */
+const makeCondition = (data, property, comparator, value, type = undefined) => {
   if (!Object.prototype.hasOwnProperty.call(data, property)) {
     return false;
   }
   const dataValue = data[property];
   switch (comparator) {
     case '=':
-      return dataValue == value;
+      return (0, _compareAs.sameValue)(type, dataValue, value);
     case '!=':
     case '<>':
-      return dataValue != value;
+      return !(0, _compareAs.sameValue)(type, dataValue, value);
     case '>':
       return dataValue > value;
     case '>=':
@@ -34,7 +45,7 @@ const makeCondition = (data, property, comparator, value) => {
     case '<=':
       return dataValue <= value;
     case 'in':
-      return Array.isArray(value) && value.includes(dataValue);
+      return Array.isArray(value) && (type ? value.some(item => (0, _compareAs.sameValue)(type, dataValue, item)) : value.includes(dataValue));
     case 'between':
       return Array.isArray(value) && value.length === 2 && dataValue >= value[0] && dataValue <= value[1];
     case 'like':
@@ -46,11 +57,12 @@ const where = (dataSet = [], {
   property = '',
   joinEntity = undefined,
   comparator = '=',
-  value = null
+  value = null,
+  type = undefined
 } = {}) => {
   return dataSet.filter(data => {
     const testProperty = joinEntity ? `${joinEntity}.${property}` : property;
-    return makeCondition(data, testProperty, comparator, value);
+    return makeCondition(data, testProperty, comparator, value, type);
   });
 };
 exports.where = where;

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.where=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");const likeMatch=(e,r)=>{if("string"!=typeof e||"string"!=typeof r)return!1;const t=r.replace(/[.*+?^${}()|[\]\\]/g,"\\$&").replace(/%/g,".*").replace(/_/g,".");return new RegExp(`^${t}$`,"i").test(e)},makeCondition=(e,r,t,s)=>{if(!Object.prototype.hasOwnProperty.call(e,r))return!1;const n=e[r];switch(t){case"=":return n==s;case"!=":case"<>":return n!=s;case">":return n>s;case">=":return n>=s;case"<":return n<s;case"<=":return n<=s;case"in":return Array.isArray(s)&&s.includes(n);case"between":return Array.isArray(s)&&2===s.length&&n>=s[0]&&n<=s[1];case"like":return likeMatch(n,s)}return!1},where=(e=[],{property:r="",joinEntity:t,comparator:s="=",value:n=null}={})=>e.filter((e=>makeCondition(e,t?`${t}.${r}`:r,s,n)));exports.where=where;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.where=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.some.js");var _compareAs=require("../utilities/compareAs");const likeMatch=(e,r)=>{if("string"!=typeof e||"string"!=typeof r)return!1;const t=r.replace(/[.*+?^${}()|[\]\\]/g,"\\$&").replace(/%/g,".*").replace(/_/g,".");return new RegExp(`^${t}$`,"i").test(e)},makeCondition=(e,r,t,s,a=void 0)=>{if(!Object.prototype.hasOwnProperty.call(e,r))return!1;const o=e[r];switch(t){case"=":return(0,_compareAs.sameValue)(a,o,s);case"!=":case"<>":return!(0,_compareAs.sameValue)(a,o,s);case">":return o>s;case">=":return o>=s;case"<":return o<s;case"<=":return o<=s;case"in":return Array.isArray(s)&&(a?s.some((e=>(0,_compareAs.sameValue)(a,o,e))):s.includes(o));case"between":return Array.isArray(s)&&2===s.length&&o>=s[0]&&o<=s[1];case"like":return likeMatch(o,s)}return!1},where=(e=[],{property:r="",joinEntity:t,comparator:s="=",value:a=null,type:o}={})=>e.filter((e=>makeCondition(e,t?`${t}.${r}`:r,s,a,o)));exports.where=where;