json-fs-query 1.1.0 → 2.0.0

package/dist/data/utilities/compareAs.d.ts

@@ -1,20 +1,20 @@
-/**
- * Normalize a value to a field's declared type for an equality comparison - never written back,
- * only compared. Writes are coerced to the declared type (typeCheck), but values already stored
- * may not match it (ids declared string, so they can hold an integer or a UUID, are often stored
- * as numbers), and query literals carry their own type. A declared type is what says '3' and 3
- * are the same value. A missing or unrecognized type returns the value unchanged.
- * @param type
- * @param value
- */
-export declare const compareAs: (type: string | undefined, value: any) => any;
-/**
- * Whether two values are equal for a field of the given declared type: both are normalized to
- * that type (see compareAs) and compared strictly. A field with no declared type, or one that
- * can't be normalized (object, array, or an unrecognized type), keeps loose equality.
- * @param type
- * @param a
- * @param b
- */
-export declare const sameValue: (type: string | undefined, a: any, b: any) => boolean;
+/**
+ * Normalize a value to a field's declared type for an equality comparison - never written back,
+ * only compared. Writes are coerced to the declared type (typeCheck), but values already stored
+ * may not match it (ids declared string, so they can hold an integer or a UUID, are often stored
+ * as numbers), and query literals carry their own type. A declared type is what says '3' and 3
+ * are the same value. A missing or unrecognized type returns the value unchanged.
+ * @param type
+ * @param value
+ */
+export declare const compareAs: (type: string | undefined, value: any) => any;
+/**
+ * Whether two values are equal for a field of the given declared type: both are normalized to
+ * that type (see compareAs) and compared strictly. A field with no declared type, or one that
+ * can't be normalized (object, array, or an unrecognized type), keeps loose equality.
+ * @param type
+ * @param a
+ * @param b
+ */
+export declare const sameValue: (type: string | undefined, a: any, b: any) => boolean;
 //# sourceMappingURL=compareAs.d.ts.map

package/dist/data/utilities/compareAs.js

@@ -1,58 +1,58 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.sameValue = exports.compareAs = void 0;
-require("core-js/modules/es.array.includes.js");
-/**
- * Normalize a value to a field's declared type for an equality comparison - never written back,
- * only compared. Writes are coerced to the declared type (typeCheck), but values already stored
- * may not match it (ids declared string, so they can hold an integer or a UUID, are often stored
- * as numbers), and query literals carry their own type. A declared type is what says '3' and 3
- * are the same value. A missing or unrecognized type returns the value unchanged.
- * @param type
- * @param value
- */
-const compareAs = (type, value) => {
-  if (value === null || typeof value === 'undefined') {
-    return value;
-  }
-  switch (type) {
-    case 'string':
-      return typeof value === 'object' ? value : String(value);
-    case 'int':
-      {
-        const coerced = Number(value);
-        return Number.isNaN(coerced) ? value : coerced;
-      }
-    case 'boolean':
-      if (value === 'true') {
-        return true;
-      }
-      if (value === 'false') {
-        return false;
-      }
-      return value;
-    default:
-      return value;
-  }
-};
-exports.compareAs = compareAs;
-const comparableTypes = ['string', 'int', 'boolean'];
-/**
- * Whether two values are equal for a field of the given declared type: both are normalized to
- * that type (see compareAs) and compared strictly. A field with no declared type, or one that
- * can't be normalized (object, array, or an unrecognized type), keeps loose equality.
- * @param type
- * @param a
- * @param b
- */
-const sameValue = (type, a, b) => {
-  if (!comparableTypes.includes(type)) {
-    // eslint-disable-next-line eqeqeq
-    return a == b;
-  }
-  return compareAs(type, a) === compareAs(type, b);
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sameValue = exports.compareAs = void 0;
+require("core-js/modules/es.array.includes.js");
+/**
+ * Normalize a value to a field's declared type for an equality comparison - never written back,
+ * only compared. Writes are coerced to the declared type (typeCheck), but values already stored
+ * may not match it (ids declared string, so they can hold an integer or a UUID, are often stored
+ * as numbers), and query literals carry their own type. A declared type is what says '3' and 3
+ * are the same value. A missing or unrecognized type returns the value unchanged.
+ * @param type
+ * @param value
+ */
+const compareAs = (type, value) => {
+  if (value === null || typeof value === 'undefined') {
+    return value;
+  }
+  switch (type) {
+    case 'string':
+      return typeof value === 'object' ? value : String(value);
+    case 'int':
+      {
+        const coerced = Number(value);
+        return Number.isNaN(coerced) ? value : coerced;
+      }
+    case 'boolean':
+      if (value === 'true') {
+        return true;
+      }
+      if (value === 'false') {
+        return false;
+      }
+      return value;
+    default:
+      return value;
+  }
+};
+exports.compareAs = compareAs;
+const comparableTypes = ['string', 'int', 'boolean'];
+/**
+ * Whether two values are equal for a field of the given declared type: both are normalized to
+ * that type (see compareAs) and compared strictly. A field with no declared type, or one that
+ * can't be normalized (object, array, or an unrecognized type), keeps loose equality.
+ * @param type
+ * @param a
+ * @param b
+ */
+const sameValue = (type, a, b) => {
+  if (!comparableTypes.includes(type)) {
+    // eslint-disable-next-line eqeqeq
+    return a == b;
+  }
+  return compareAs(type, a) === compareAs(type, b);
+};
 exports.sameValue = sameValue;

package/dist/data/utilities/config.d.ts

@@ -3,6 +3,18 @@ export type RuntimeSettings = {
     relativePath: string;
     enforceForeignKeys: boolean;
 };
+/**
+ * The folder a databasePath points to, so that `database/`, `./database` and its absolute path count as one database.
+ * Node only (only Node calls are counted, see trackDatabaseCall).
+ * @param databasePath
+ */
+export declare const resolveDatabasePath: (databasePath: string) => string;
+/**
+ * Count a database call (taken by withDatabaseLock as soon as a call is queued) until the returned function is called.
+ * While any call is counted, configure() refuses to point databasePath somewhere else: every step of a call reads
+ * databasePath again, so a change halfway would write part of the call to one folder and the rest to another.
+ */
+export declare const trackDatabaseCall: () => (() => void);
 /**
  * Set where this package's data lives: databasePath (a filesystem path, used in Node) and/or
  * relativePath (a URL prefix prepended to databasePath, used when reading over fetch() in a
@@ -13,7 +25,10 @@ export type RuntimeSettings = {
  * that would leave another record's foreign key pointing at a value that no longer exists -
  * mirroring MySQL's own foreign_key_checks setting, which is also toggleable rather than always
  * on, since strict enforcement isn't always what every consumer wants.
+ *
+ * Changing databasePath while calls are still running or queued throws (see trackDatabaseCall): await them first.
  * @param newSettings
+ * @throws {Error} When databasePath would point to another folder while database calls are in progress.
  */
 export declare const configure: (newSettings: Partial<RuntimeSettings>) => void;
 /**

package/dist/data/utilities/config.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getSetting = exports.configure = void 0;
+exports.trackDatabaseCall = exports.resolveDatabasePath = exports.getSetting = exports.configure = void 0;
 const defaults = {
   databasePath: 'database/',
   relativePath: '',
@@ -12,6 +12,29 @@ const defaults = {
 let settings = {
   ...defaults
 };
+let activeCalls = 0;
+/**
+ * The folder a databasePath points to, so that `database/`, `./database` and its absolute path count as one database.
+ * Node only (only Node calls are counted, see trackDatabaseCall).
+ * @param databasePath
+ */
+const resolveDatabasePath = databasePath => require('path').resolve(databasePath);
+/**
+ * Count a database call (taken by withDatabaseLock as soon as a call is queued) until the returned function is called.
+ * While any call is counted, configure() refuses to point databasePath somewhere else: every step of a call reads
+ * databasePath again, so a change halfway would write part of the call to one folder and the rest to another.
+ */
+exports.resolveDatabasePath = resolveDatabasePath;
+const trackDatabaseCall = () => {
+  activeCalls++;
+  let ended = false;
+  return () => {
+    if (!ended) {
+      ended = true;
+      activeCalls--;
+    }
+  };
+};
 /**
  * Set where this package's data lives: databasePath (a filesystem path, used in Node) and/or
  * relativePath (a URL prefix prepended to databasePath, used when reading over fetch() in a
@@ -22,9 +45,16 @@ let settings = {
  * that would leave another record's foreign key pointing at a value that no longer exists -
  * mirroring MySQL's own foreign_key_checks setting, which is also toggleable rather than always
  * on, since strict enforcement isn't always what every consumer wants.
+ *
+ * Changing databasePath while calls are still running or queued throws (see trackDatabaseCall): await them first.
  * @param newSettings
+ * @throws {Error} When databasePath would point to another folder while database calls are in progress.
  */
+exports.trackDatabaseCall = trackDatabaseCall;
 const configure = newSettings => {
+  if (activeCalls > 0 && typeof newSettings.databasePath !== 'undefined' && resolveDatabasePath(newSettings.databasePath) !== resolveDatabasePath(settings.databasePath)) {
+    throw new Error(`Can't change databasePath while ${activeCalls} database call(s) are still running or queued: await them first`);
+  }
   settings = {
     ...settings,
     ...newSettings

package/dist/data/utilities/config.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.getSetting=exports.configure=void 0;const defaults={databasePath:"database/",relativePath:"",enforceForeignKeys:!0};let settings={...defaults};const configure=t=>{settings={...settings,...t}};exports.configure=configure;const getSetting=(t,e)=>void 0!==settings[t]?settings[t]:e;exports.getSetting=getSetting;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.trackDatabaseCall=exports.resolveDatabasePath=exports.getSetting=exports.configure=void 0;const defaults={databasePath:"database/",relativePath:"",enforceForeignKeys:!0};let settings={...defaults},activeCalls=0;const resolveDatabasePath=t=>require("path").resolve(t);exports.resolveDatabasePath=resolveDatabasePath;const trackDatabaseCall=()=>{activeCalls++;let t=!1;return()=>{t||(t=!0,activeCalls--)}};exports.trackDatabaseCall=trackDatabaseCall;const configure=t=>{if(activeCalls>0&&void 0!==t.databasePath&&resolveDatabasePath(t.databasePath)!==resolveDatabasePath(settings.databasePath))throw new Error(`Can't change databasePath while ${activeCalls} database call(s) are still running or queued: await them first`);settings={...settings,...t}};exports.configure=configure;const getSetting=(t,a)=>void 0!==settings[t]?settings[t]:a;exports.getSetting=getSetting;

package/dist/data/utilities/databaseLock.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Run `task` once every earlier task on the same database (the configured databasePath) has finished, so that calls
+ * never interleave. Every write is several files in turn (an entry, the record's entry list, each index), each read and
+ * rewritten whole, so two writes running at once overwrite each other's changes: ten parallel inserts used to leave
+ * nine of the rows unreadable, and two parallel inserts of one unique value both succeeded. Reads take their turn too,
+ * so a read never sees a write half done. A task that throws still lets the next one run.
+ *
+ * Only the public functions (query, create, drop, describe) take the lock; what they call inside doesn't take it
+ * again, so it can't deadlock. In the browser nothing can be written, so tasks just run.
+ *
+ * The queue is per folder (`database/` and `./database` share one). Every step of a task reads databasePath when it
+ * runs, so configure() refuses to change it while tasks are queued or running (see trackDatabaseCall).
+ * @param task
+ */
+export declare const withDatabaseLock: <T>(task: () => Promise<T>) => Promise<T>;
+//# sourceMappingURL=databaseLock.d.ts.map

package/dist/data/utilities/databaseLock.js

@@ -0,0 +1,63 @@
+"use strict";
+
+require("core-js/modules/esnext.weak-map.delete-all.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withDatabaseLock = void 0;
+require("core-js/modules/esnext.map.delete-all.js");
+require("core-js/modules/esnext.map.every.js");
+require("core-js/modules/esnext.map.filter.js");
+require("core-js/modules/esnext.map.find.js");
+require("core-js/modules/esnext.map.find-key.js");
+require("core-js/modules/esnext.map.includes.js");
+require("core-js/modules/esnext.map.key-of.js");
+require("core-js/modules/esnext.map.map-keys.js");
+require("core-js/modules/esnext.map.map-values.js");
+require("core-js/modules/esnext.map.merge.js");
+require("core-js/modules/esnext.map.reduce.js");
+require("core-js/modules/esnext.map.some.js");
+require("core-js/modules/esnext.map.update.js");
+var jsEnv = _interopRequireWildcard(require("browser-or-node"));
+var _config = require("./config");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+const queues = new Map();
+/**
+ * Run `task` once every earlier task on the same database (the configured databasePath) has finished, so that calls
+ * never interleave. Every write is several files in turn (an entry, the record's entry list, each index), each read and
+ * rewritten whole, so two writes running at once overwrite each other's changes: ten parallel inserts used to leave
+ * nine of the rows unreadable, and two parallel inserts of one unique value both succeeded. Reads take their turn too,
+ * so a read never sees a write half done. A task that throws still lets the next one run.
+ *
+ * Only the public functions (query, create, drop, describe) take the lock; what they call inside doesn't take it
+ * again, so it can't deadlock. In the browser nothing can be written, so tasks just run.
+ *
+ * The queue is per folder (`database/` and `./database` share one). Every step of a task reads databasePath when it
+ * runs, so configure() refuses to change it while tasks are queued or running (see trackDatabaseCall).
+ * @param task
+ */
+const withDatabaseLock = async task => {
+  if (!jsEnv.isNode) {
+    return task();
+  }
+  const database = (0, _config.resolveDatabasePath)((0, _config.getSetting)('databasePath', 'database/'));
+  const ended = (0, _config.trackDatabaseCall)();
+  const previous = queues.get(database) || Promise.resolve();
+  let release;
+  const turn = new Promise(resolve => {
+    release = resolve;
+  });
+  const queued = previous.then(() => turn);
+  queues.set(database, queued);
+  await previous;
+  try {
+    return await task();
+  } finally {
+    ended();
+    release();
+    if (queues.get(database) === queued) {
+      queues.delete(database);
+    }
+  }
+};
+exports.withDatabaseLock = withDatabaseLock;

package/dist/data/utilities/databaseLock.min.js

@@ -0,0 +1 @@
+"use strict";require("core-js/modules/esnext.weak-map.delete-all.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.withDatabaseLock=void 0,require("core-js/modules/esnext.map.delete-all.js"),require("core-js/modules/esnext.map.every.js"),require("core-js/modules/esnext.map.filter.js"),require("core-js/modules/esnext.map.find.js"),require("core-js/modules/esnext.map.find-key.js"),require("core-js/modules/esnext.map.includes.js"),require("core-js/modules/esnext.map.key-of.js"),require("core-js/modules/esnext.map.map-keys.js"),require("core-js/modules/esnext.map.map-values.js"),require("core-js/modules/esnext.map.merge.js"),require("core-js/modules/esnext.map.reduce.js"),require("core-js/modules/esnext.map.some.js"),require("core-js/modules/esnext.map.update.js");var jsEnv=_interopRequireWildcard(require("browser-or-node")),_config=require("./config");function _interopRequireWildcard(e,r){if("function"==typeof WeakMap)var s=new WeakMap,t=new WeakMap;return(_interopRequireWildcard=function(e,r){if(!r&&e&&e.__esModule)return e;var o,a,u={__proto__:null,default:e};if(null===e||"object"!=typeof e&&"function"!=typeof e)return u;if(o=r?t:s){if(o.has(e))return o.get(e);o.set(e,u)}for(const r in e)"default"!==r&&{}.hasOwnProperty.call(e,r)&&((a=(o=Object.defineProperty)&&Object.getOwnPropertyDescriptor(e,r))&&(a.get||a.set)?o(u,r,a):u[r]=e[r]);return u})(e,r)}const queues=new Map,withDatabaseLock=async e=>{if(!jsEnv.isNode)return e();const r=(0,_config.resolveDatabasePath)((0,_config.getSetting)("databasePath","database/")),s=(0,_config.trackDatabaseCall)(),t=queues.get(r)||Promise.resolve();let o;const a=new Promise((e=>{o=e})),u=t.then((()=>a));queues.set(r,u),await t;try{return await e()}finally{s(),o(),queues.get(r)===u&&queues.delete(r)}};exports.withDatabaseLock=withDatabaseLock;

package/dist/data/utilities/fieldType.d.ts

@@ -1,16 +1,16 @@
-import { recordDefinition } from '../introspect/definitions/record';
-import { keyDefinition } from '../introspect/definitions/key';
-/**
- * The declared type of one of a record's fields, or undefined when the record or field is unknown.
- * @param record
- * @param property
- */
-export declare const fieldType: (record: recordDefinition | undefined, property: string) => string | undefined;
-/**
- * The declared type of the value a key indexes: its field's type for a single-field key. A
- * multi-field key's value is a composite (see computeKeyValue), so it has no single declared type.
- * @param record
- * @param key
- */
-export declare const keyValueType: (record: recordDefinition | undefined, key: keyDefinition) => string | undefined;
+import { recordDefinition } from '../introspect/definitions/record';
+import { keyDefinition } from '../introspect/definitions/key';
+/**
+ * The declared type of one of a record's fields, or undefined when the record or field is unknown.
+ * @param record
+ * @param property
+ */
+export declare const fieldType: (record: recordDefinition | undefined, property: string) => string | undefined;
+/**
+ * The declared type of the value a key indexes: its field's type for a single-field key. A
+ * multi-field key's value is a composite (see computeKeyValue), so it has no single declared type.
+ * @param record
+ * @param key
+ */
+export declare const keyValueType: (record: recordDefinition | undefined, key: keyDefinition) => string | undefined;
 //# sourceMappingURL=fieldType.d.ts.map

package/dist/data/utilities/fieldType.js

@@ -1,23 +1,23 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.keyValueType = exports.fieldType = void 0;
-require("core-js/modules/esnext.iterator.constructor.js");
-require("core-js/modules/esnext.iterator.find.js");
-/**
- * The declared type of one of a record's fields, or undefined when the record or field is unknown.
- * @param record
- * @param property
- */
-const fieldType = (record, property) => record?.definition?.find(field => field.name === property)?.type;
-/**
- * The declared type of the value a key indexes: its field's type for a single-field key. A
- * multi-field key's value is a composite (see computeKeyValue), so it has no single declared type.
- * @param record
- * @param key
- */
-exports.fieldType = fieldType;
-const keyValueType = (record, key) => key.fields.length === 1 ? fieldType(record, key.fields[0]) : undefined;
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.keyValueType = exports.fieldType = void 0;
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.find.js");
+/**
+ * The declared type of one of a record's fields, or undefined when the record or field is unknown.
+ * @param record
+ * @param property
+ */
+const fieldType = (record, property) => record?.definition?.find(field => field.name === property)?.type;
+/**
+ * The declared type of the value a key indexes: its field's type for a single-field key. A
+ * multi-field key's value is a composite (see computeKeyValue), so it has no single declared type.
+ * @param record
+ * @param key
+ */
+exports.fieldType = fieldType;
+const keyValueType = (record, key) => key.fields.length === 1 ? fieldType(record, key.fields[0]) : undefined;
 exports.keyValueType = keyValueType;

package/dist/data/utilities/getConditionIndexedList.js

@@ -1,48 +1,48 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getConditionIndexedList = void 0;
-var _isEntityProperty = require("./parsers/isEntityProperty");
-var _splitEntityProperty = require("./parsers/splitEntityProperty");
-var _retrieveRecord = require("./retrieveRecord");
-var _where = require("../queries/where");
-var _retrieveFile = require("./retrieveFile");
-var _getMatchingIndexes = require("./getMatchingIndexes");
-const getConditionIndexedList = async (parsed, recordData, dataSet) => {
-  const reducedConditions = [];
-  for (const condition of parsed.conditions) {
-    let entity = parsed.entity;
-    let property = condition.property;
-    if ((0, _isEntityProperty.isEntityProperty)(property)) {
-      const entityProperty = (0, _splitEntityProperty.splitEntityProperty)(property);
-      entity = entityProperty.entity;
-      property = entityProperty.property;
-    }
-    if (!Object.prototype.hasOwnProperty.call(recordData, entity)) {
-      recordData[entity] = await (0, _retrieveRecord.retrieveRecord)(entity);
-    }
-    const indexed = {};
-    const retrieveMatchedFiles = async (entity, property, recordData, condition, dataSet, indexed) => {
-      const matchedRecords = (0, _where.where)(indexed[entity][property], {
-        property: 'value',
-        comparator: condition.comparator,
-        value: condition.value,
-        type: condition.type
-      });
-      for (const matchedRecord of matchedRecords) {
-        for (const file of matchedRecord.record) {
-          dataSet[entity].push(await (0, _retrieveFile.retrieveFile)(`${entity}/${file}`));
-        }
-      }
-    };
-    const isIndexed = await (0, _getMatchingIndexes.getMatchingIndexes)(entity, property, recordData, condition, dataSet, indexed, retrieveMatchedFiles);
-    if (!isIndexed) {
-      reducedConditions.push(condition);
-    }
-  }
-  parsed.conditions = reducedConditions;
-  return parsed;
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getConditionIndexedList = void 0;
+var _isEntityProperty = require("./parsers/isEntityProperty");
+var _splitEntityProperty = require("./parsers/splitEntityProperty");
+var _retrieveRecord = require("./retrieveRecord");
+var _where = require("../queries/where");
+var _retrieveFile = require("./retrieveFile");
+var _getMatchingIndexes = require("./getMatchingIndexes");
+const getConditionIndexedList = async (parsed, recordData, dataSet) => {
+  const reducedConditions = [];
+  for (const condition of parsed.conditions) {
+    let entity = parsed.entity;
+    let property = condition.property;
+    if ((0, _isEntityProperty.isEntityProperty)(property)) {
+      const entityProperty = (0, _splitEntityProperty.splitEntityProperty)(property);
+      entity = entityProperty.entity;
+      property = entityProperty.property;
+    }
+    if (!Object.prototype.hasOwnProperty.call(recordData, entity)) {
+      recordData[entity] = await (0, _retrieveRecord.retrieveRecord)(entity);
+    }
+    const indexed = {};
+    const retrieveMatchedFiles = async (entity, property, recordData, condition, dataSet, indexed) => {
+      const matchedRecords = (0, _where.where)(indexed[entity][property], {
+        property: 'value',
+        comparator: condition.comparator,
+        value: condition.value,
+        type: condition.type
+      });
+      for (const matchedRecord of matchedRecords) {
+        for (const file of matchedRecord.record) {
+          dataSet[entity].push(await (0, _retrieveFile.retrieveFile)(`${entity}/${file}`));
+        }
+      }
+    };
+    const isIndexed = await (0, _getMatchingIndexes.getMatchingIndexes)(entity, property, recordData, condition, dataSet, indexed, retrieveMatchedFiles);
+    if (!isIndexed) {
+      reducedConditions.push(condition);
+    }
+  }
+  parsed.conditions = reducedConditions;
+  return parsed;
+};
 exports.getConditionIndexedList = getConditionIndexedList;

package/dist/data/utilities/matchIndexedJoins.js

@@ -1,63 +1,63 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.matchIndexedJoins = void 0;
-require("core-js/modules/esnext.iterator.constructor.js");
-require("core-js/modules/esnext.iterator.reduce.js");
-var _siFunciona = _interopRequireDefault(require("si-funciona"));
-var _where = require("../queries/where");
-var _retrieveFile = require("./retrieveFile");
-var _splitEntityProperty = require("./parsers/splitEntityProperty");
-var _fieldType = require("./fieldType");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const matchIndexedJoins = (entity, indexedClone, dataSets) => async (focusEntity, property, recordData, joinClause, filterJoins, indexed) => {
-  const {
-    entity: entityA,
-    property: propertyA
-  } = (0, _splitEntityProperty.splitEntityProperty)(joinClause.propertyA);
-  const {
-    entity: entityB,
-    property: propertyB
-  } = (0, _splitEntityProperty.splitEntityProperty)(joinClause.propertyB);
-  const properties = [{
-    entityFirst: entityA,
-    propertyFirst: propertyA,
-    entitySecond: entityB,
-    propertySecond: propertyB
-  }, {
-    entityFirst: entityB,
-    propertyFirst: propertyB,
-    entitySecond: entityA,
-    propertySecond: propertyA
-  }];
-  for (const checkProp of properties) {
-    if (!Object.prototype.hasOwnProperty.call(indexedClone, checkProp.entitySecond)) {
-      indexedClone[checkProp.entitySecond] = _siFunciona.default.cloneObject(indexed[checkProp.entitySecond]);
-    }
-    const matchedRecords = indexedClone[checkProp.entitySecond][checkProp.propertySecond].reduce((dataA, dataB) => _siFunciona.default.mergeArrays(dataA, (0, _where.where)(indexedClone[checkProp.entityFirst][checkProp.propertyFirst], {
-      property: 'value',
-      comparator: joinClause.comparator,
-      value: dataB.value,
-      type: (0, _fieldType.fieldType)(recordData[checkProp.entityFirst], checkProp.propertyFirst)
-    })), []);
-    const skipPush = checkProp.entityFirst === entity;
-    if (!Object.prototype.hasOwnProperty.call(dataSets, checkProp.entityFirst)) {
-      dataSets[checkProp.entityFirst] = [];
-    }
-    for (const matchedRecord of matchedRecords) {
-      for (const file of matchedRecord.record) {
-        let entityRecord = file;
-        if (typeof file === 'string') {
-          entityRecord = await (0, _retrieveFile.retrieveFile)(`${checkProp.entityFirst}/${file}`);
-        }
-        if (!skipPush) {
-          dataSets[checkProp.entityFirst].push(entityRecord);
-        }
-        filterJoins[checkProp.entityFirst].push(entityRecord);
-      }
-    }
-  }
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.matchIndexedJoins = void 0;
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.reduce.js");
+var _siFunciona = _interopRequireDefault(require("si-funciona"));
+var _where = require("../queries/where");
+var _retrieveFile = require("./retrieveFile");
+var _splitEntityProperty = require("./parsers/splitEntityProperty");
+var _fieldType = require("./fieldType");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const matchIndexedJoins = (entity, indexedClone, dataSets) => async (focusEntity, property, recordData, joinClause, filterJoins, indexed) => {
+  const {
+    entity: entityA,
+    property: propertyA
+  } = (0, _splitEntityProperty.splitEntityProperty)(joinClause.propertyA);
+  const {
+    entity: entityB,
+    property: propertyB
+  } = (0, _splitEntityProperty.splitEntityProperty)(joinClause.propertyB);
+  const properties = [{
+    entityFirst: entityA,
+    propertyFirst: propertyA,
+    entitySecond: entityB,
+    propertySecond: propertyB
+  }, {
+    entityFirst: entityB,
+    propertyFirst: propertyB,
+    entitySecond: entityA,
+    propertySecond: propertyA
+  }];
+  for (const checkProp of properties) {
+    if (!Object.prototype.hasOwnProperty.call(indexedClone, checkProp.entitySecond)) {
+      indexedClone[checkProp.entitySecond] = _siFunciona.default.cloneObject(indexed[checkProp.entitySecond]);
+    }
+    const matchedRecords = indexedClone[checkProp.entitySecond][checkProp.propertySecond].reduce((dataA, dataB) => _siFunciona.default.mergeArrays(dataA, (0, _where.where)(indexedClone[checkProp.entityFirst][checkProp.propertyFirst], {
+      property: 'value',
+      comparator: joinClause.comparator,
+      value: dataB.value,
+      type: (0, _fieldType.fieldType)(recordData[checkProp.entityFirst], checkProp.propertyFirst)
+    })), []);
+    const skipPush = checkProp.entityFirst === entity;
+    if (!Object.prototype.hasOwnProperty.call(dataSets, checkProp.entityFirst)) {
+      dataSets[checkProp.entityFirst] = [];
+    }
+    for (const matchedRecord of matchedRecords) {
+      for (const file of matchedRecord.record) {
+        let entityRecord = file;
+        if (typeof file === 'string') {
+          entityRecord = await (0, _retrieveFile.retrieveFile)(`${checkProp.entityFirst}/${file}`);
+        }
+        if (!skipPush) {
+          dataSets[checkProp.entityFirst].push(entityRecord);
+        }
+        filterJoins[checkProp.entityFirst].push(entityRecord);
+      }
+    }
+  }
+};
 exports.matchIndexedJoins = matchIndexedJoins;