json-fs-query 1.0.3 → 1.0.5

package/dist/data/utilities/restrictIndexedList.js

@@ -1,45 +1,45 @@
-'use strict'
+"use strict";
 
-Object.defineProperty(exports, '__esModule', {
+Object.defineProperty(exports, "__esModule", {
   value: true
-})
-exports.restrictIndexedList = void 0
-const _splitEntityProperty = require('./parsers/splitEntityProperty')
+});
+exports.restrictIndexedList = void 0;
+var _splitEntityProperty = require("./parsers/splitEntityProperty");
 const restrictIndexedList = (joinClause, filterJoins, indexedClone) => {
   const {
     entity: entityA,
     property: propertyA
-  } = (0, _splitEntityProperty.splitEntityProperty)(joinClause.propertyA)
+  } = (0, _splitEntityProperty.splitEntityProperty)(joinClause.propertyA);
   const {
     entity: entityB,
     property: propertyB
-  } = (0, _splitEntityProperty.splitEntityProperty)(joinClause.propertyB)
+  } = (0, _splitEntityProperty.splitEntityProperty)(joinClause.propertyB);
   if (Object.prototype.hasOwnProperty.call(filterJoins, entityA)) {
-    const existingEntities = filterJoins[entityA]
+    const existingEntities = filterJoins[entityA];
     if (!Object.prototype.hasOwnProperty.call(indexedClone, entityA)) {
-      indexedClone[entityA] = {}
+      indexedClone[entityA] = {};
     }
     if (!Object.prototype.hasOwnProperty.call(indexedClone[entityA], propertyA)) {
-      indexedClone[entityA][propertyA] = {}
+      indexedClone[entityA][propertyA] = {};
     }
     indexedClone[entityA][propertyA] = [{
       value: existingEntities[0][propertyA],
       record: existingEntities
-    }]
+    }];
   }
   if (Object.prototype.hasOwnProperty.call(filterJoins, entityB)) {
-    const existingEntities = filterJoins[entityB]
+    const existingEntities = filterJoins[entityB];
     if (!Object.prototype.hasOwnProperty.call(indexedClone, entityB)) {
-      indexedClone[entityB] = {}
+      indexedClone[entityB] = {};
     }
     if (!Object.prototype.hasOwnProperty.call(indexedClone[entityB], propertyB)) {
-      indexedClone[entityB][propertyB] = {}
+      indexedClone[entityB][propertyB] = {};
     }
     indexedClone[entityB][propertyB] = [{
       value: existingEntities[0][propertyB],
       record: existingEntities
-    }]
+    }];
   }
-  return indexedClone
-}
-exports.restrictIndexedList = restrictIndexedList
+  return indexedClone;
+};
+exports.restrictIndexedList = restrictIndexedList;

package/dist/data/utilities/retrieveFile.js

@@ -1,28 +1,28 @@
-'use strict'
+"use strict";
 
-require('core-js/modules/esnext.weak-map.delete-all.js')
-Object.defineProperty(exports, '__esModule', {
+require("core-js/modules/esnext.weak-map.delete-all.js");
+Object.defineProperty(exports, "__esModule", {
   value: true
-})
-exports.retrieveFile = void 0
-const jsEnv = _interopRequireWildcard(require('browser-or-node'))
-const _config = require('./config')
-function _interopRequireWildcard (e, t) { if (typeof WeakMap === 'function') var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; let o; let i; const f = { __proto__: null, default: e }; if (e === null || typeof e !== 'object' && typeof e !== 'function') return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f) } for (const t in e) t !== 'default' && {}.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) }
+});
+exports.retrieveFile = void 0;
+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 retrieveFile = async path => {
-  let retrieveFn = url => fetch(url).then(res => res.json())
-  const relativePath = jsEnv.isBrowser ? (0, _config.getSetting)('relativePath', '') : ''
+  let retrieveFn = url => fetch(url).then(res => res.json());
+  const relativePath = jsEnv.isBrowser ? (0, _config.getSetting)('relativePath', '') : '';
   if (jsEnv.isNode) {
     const {
       readFile
-    } = require('fs/promises')
-    retrieveFn = url => readFile(url).then(res => JSON.parse(res))
+    } = require('fs/promises');
+    retrieveFn = url => readFile(url).then(res => JSON.parse(res));
   }
-  const databasePath = (0, _config.getSetting)('databasePath', 'database/')
-  const fetchUrl = `${relativePath}${databasePath}${path}`
-  const recordInfo = await retrieveFn(fetchUrl).catch(err => console.error(err))
+  const databasePath = (0, _config.getSetting)('databasePath', 'database/');
+  const fetchUrl = `${relativePath}${databasePath}${path}`;
+  const recordInfo = await retrieveFn(fetchUrl).catch(err => console.error(err));
   if (!recordInfo) {
-    throw new Error(`Could not read ${path}`)
+    throw new Error(`Could not read ${path}`);
   }
-  return recordInfo
-}
-exports.retrieveFile = retrieveFile
+  return recordInfo;
+};
+exports.retrieveFile = retrieveFile;

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

@@ -1 +1 @@
-"use strict";require("core-js/modules/esnext.weak-map.delete-all.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.retrieveFile=void 0;var jsEnv=_interopRequireWildcard(require("browser-or-node")),_config=require("./config");function _interopRequireWildcard(e,r){if("function"==typeof WeakMap)var t=new WeakMap,i=new WeakMap;return(_interopRequireWildcard=function(e,r){if(!r&&e&&e.__esModule)return e;var o,n,a={__proto__:null,default:e};if(null===e||"object"!=typeof e&&"function"!=typeof e)return a;if(o=r?i:t){if(o.has(e))return o.get(e);o.set(e,a)}for(const r in e)"default"!==r&&{}.hasOwnProperty.call(e,r)&&((n=(o=Object.defineProperty)&&Object.getOwnPropertyDescriptor(e,r))&&(n.get||n.set)?o(a,r,n):a[r]=e[r]);return a})(e,r)}const retrieveFile=async e=>{let r=e=>fetch(e).then((e=>e.json())),t=jsEnv.isBrowser?(0,_config.getSetting)("relativePath",""):"";if(jsEnv.isNode){const{readFile:e}=require("fs/promises");r=r=>e(r).then((e=>JSON.parse(e)))}const i=`${t}${(0,_config.getSetting)("databasePath","database/")}${e}`,o=await r(i).catch((e=>console.error(e)));if(!o)throw new Error(`Could not read ${e}`);return o};exports.retrieveFile=retrieveFile;
+"use strict";require("core-js/modules/esnext.weak-map.delete-all.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.retrieveFile=void 0;var jsEnv=_interopRequireWildcard(require("browser-or-node")),_config=require("./config");function _interopRequireWildcard(e,r){if("function"==typeof WeakMap)var t=new WeakMap,i=new WeakMap;return(_interopRequireWildcard=function(e,r){if(!r&&e&&e.__esModule)return e;var o,n,a={__proto__:null,default:e};if(null===e||"object"!=typeof e&&"function"!=typeof e)return a;if(o=r?i:t){if(o.has(e))return o.get(e);o.set(e,a)}for(const r in e)"default"!==r&&{}.hasOwnProperty.call(e,r)&&((n=(o=Object.defineProperty)&&Object.getOwnPropertyDescriptor(e,r))&&(n.get||n.set)?o(a,r,n):a[r]=e[r]);return a})(e,r)}const retrieveFile=async e=>{let r=e=>fetch(e).then((e=>e.json()));const t=jsEnv.isBrowser?(0,_config.getSetting)("relativePath",""):"";if(jsEnv.isNode){const{readFile:e}=require("fs/promises");r=r=>e(r).then((e=>JSON.parse(e)))}const i=`${t}${(0,_config.getSetting)("databasePath","database/")}${e}`,o=await r(i).catch((e=>console.error(e)));if(!o)throw new Error(`Could not read ${e}`);return o};exports.retrieveFile=retrieveFile;

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

@@ -1,2 +1,2 @@
-export declare const retrieveIndexes: (entity?: string, properties?: any[], recordData?: {}) => Promise<{}>;
+export declare const retrieveIndexes: (entity?: string, properties?: any[], recordData?: {}) => Promise<{}>;
 //# sourceMappingURL=retrieveIndexes.d.ts.map

package/dist/data/utilities/retrieveIndexes.js

@@ -1,24 +1,24 @@
-'use strict'
+"use strict";
 
-Object.defineProperty(exports, '__esModule', {
+Object.defineProperty(exports, "__esModule", {
   value: true
-})
-exports.retrieveIndexes = void 0
-require('core-js/modules/es.array.includes.js')
-const _retrieveFile = require('./retrieveFile')
-const _retrieveRecord = require('./retrieveRecord')
+});
+exports.retrieveIndexes = void 0;
+require("core-js/modules/es.array.includes.js");
+var _retrieveFile = require("./retrieveFile");
+var _retrieveRecord = require("./retrieveRecord");
 const retrieveIndexes = async (entity = '', properties = [], recordData = {}) => {
   if (!Object.prototype.hasOwnProperty.call(recordData, entity)) {
-    recordData[entity] = await (0, _retrieveRecord.retrieveRecord)(entity)
+    recordData[entity] = await (0, _retrieveRecord.retrieveRecord)(entity);
   }
-  const indexSet = {}
+  const indexSet = {};
   for (const property of properties) {
     for (const key of recordData[entity].keys) {
       if (key.fields.includes(property)) {
-        indexSet[property] = await (0, _retrieveFile.retrieveFile)(`__indexes/${entity}/${key.lookup}`)
+        indexSet[property] = await (0, _retrieveFile.retrieveFile)(`__indexes/${entity}/${key.lookup}`);
       }
     }
   }
-  return indexSet
-}
-exports.retrieveIndexes = retrieveIndexes
+  return indexSet;
+};
+exports.retrieveIndexes = retrieveIndexes;

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.retrieveIndexes=void 0,require("core-js/modules/es.array.includes.js");var _retrieveFile=require("./retrieveFile"),_retrieveRecord=require("./retrieveRecord");const retrieveIndexes=async(e="",r=[],t={})=>{Object.prototype.hasOwnProperty.call(t,e)||(t[e]=await(0,_retrieveRecord.retrieveRecord)(e));const i={};for(let o of r)for(let r of t[e].keys)r.fields.includes(o)&&(i[o]=await(0,_retrieveFile.retrieveFile)(`__indexes/${e}/${r.lookup}`));return i};exports.retrieveIndexes=retrieveIndexes;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.retrieveIndexes=void 0,require("core-js/modules/es.array.includes.js");var _retrieveFile=require("./retrieveFile"),_retrieveRecord=require("./retrieveRecord");const retrieveIndexes=async(e="",r=[],t={})=>{Object.prototype.hasOwnProperty.call(t,e)||(t[e]=await(0,_retrieveRecord.retrieveRecord)(e));const i={};for(const o of r)for(const r of t[e].keys)r.fields.includes(o)&&(i[o]=await(0,_retrieveFile.retrieveFile)(`__indexes/${e}/${r.lookup}`));return i};exports.retrieveIndexes=retrieveIndexes;

package/dist/data/utilities/retrieveRecord.js

@@ -1,9 +1,9 @@
-'use strict'
+"use strict";
 
-Object.defineProperty(exports, '__esModule', {
+Object.defineProperty(exports, "__esModule", {
   value: true
-})
-exports.retrieveRecord = void 0
-const _retrieveFile = require('./retrieveFile')
-const retrieveRecord = async (entity = '') => await (0, _retrieveFile.retrieveFile)(`${entity}.json`)
-exports.retrieveRecord = retrieveRecord
+});
+exports.retrieveRecord = void 0;
+var _retrieveFile = require("./retrieveFile");
+const retrieveRecord = async (entity = '') => await (0, _retrieveFile.retrieveFile)(`${entity}.json`);
+exports.retrieveRecord = retrieveRecord;

package/dist/data/utilities/retrieveRecords.js

@@ -1,21 +1,21 @@
-'use strict'
+"use strict";
 
-Object.defineProperty(exports, '__esModule', {
+Object.defineProperty(exports, "__esModule", {
   value: true
-})
-exports.retrieveRecords = void 0
-const _retrieveFile = require('./retrieveFile')
-const _retrieveRecord = require('./retrieveRecord')
+});
+exports.retrieveRecords = void 0;
+var _retrieveFile = require("./retrieveFile");
+var _retrieveRecord = require("./retrieveRecord");
 const retrieveRecords = async (entity = '') => {
-  const recordFile = await (0, _retrieveRecord.retrieveRecord)(entity)
-  const dataSet = []
+  const recordFile = await (0, _retrieveRecord.retrieveRecord)(entity);
+  const dataSet = [];
   for (const file of recordFile.entries) {
-    const data = await (0, _retrieveFile.retrieveFile)(`${recordFile.path}/${file}`).catch(err => console.error(err))
+    const data = await (0, _retrieveFile.retrieveFile)(`${recordFile.path}/${file}`).catch(err => console.error(err));
     if (!data) {
-      throw new Error(`Could not read entity ${file}`)
+      throw new Error(`Could not read entity ${file}`);
     }
-    dataSet.push(data)
+    dataSet.push(data);
   }
-  return dataSet
-}
-exports.retrieveRecords = retrieveRecords
+  return dataSet;
+};
+exports.retrieveRecords = retrieveRecords;

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.retrieveRecords=void 0;var _retrieveFile=require("./retrieveFile"),_retrieveRecord=require("./retrieveRecord");const retrieveRecords=async(e="")=>{const r=await(0,_retrieveRecord.retrieveRecord)(e),t=[];for(let e of r.entries){const i=await(0,_retrieveFile.retrieveFile)(`${r.path}/${e}`).catch((e=>console.error(e)));if(!i)throw new Error(`Could not read entity ${e}`);t.push(i)}return t};exports.retrieveRecords=retrieveRecords;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.retrieveRecords=void 0;var _retrieveFile=require("./retrieveFile"),_retrieveRecord=require("./retrieveRecord");const retrieveRecords=async(e="")=>{const r=await(0,_retrieveRecord.retrieveRecord)(e),t=[];for(const e of r.entries){const o=await(0,_retrieveFile.retrieveFile)(`${r.path}/${e}`).catch((e=>console.error(e)));if(!o)throw new Error(`Could not read entity ${e}`);t.push(o)}return t};exports.retrieveRecords=retrieveRecords;

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

@@ -1,2 +1,2 @@
-export declare const runQuery: (parsed: any) => Promise<any>;
+export declare const runQuery: (parsed: any) => Promise<any>;
 //# sourceMappingURL=runQuery.d.ts.map

package/dist/data/utilities/runQuery.js

@@ -1,87 +1,87 @@
-'use strict'
+"use strict";
 
-Object.defineProperty(exports, '__esModule', {
+Object.defineProperty(exports, "__esModule", {
   value: true
-})
-exports.runQuery = void 0
-require('core-js/modules/esnext.iterator.constructor.js')
-require('core-js/modules/esnext.iterator.reduce.js')
-const _deleteEntity = require('../queries/deleteEntity')
-const _insertEntity = require('../queries/insertEntity')
-const _readEntity = require('../queries/readEntity')
-const _updateEntity = require('../queries/updateEntity')
-const _joinEntity = require('../queries/joinEntity')
-const _mergeJoins = require('../queries/mergeJoins')
-const _where = require('../queries/where')
-const _sortBy = require('../queries/sortBy')
-const _groupBy = require('../queries/groupBy')
-const _limitOffset = require('../queries/limitOffset')
-const _selectFields = require('../queries/selectFields')
-const _retrieveRecord = require('./retrieveRecord')
-const _getConditionIndexedList = require('./getConditionIndexedList')
-const _getJoinIndexedList = require('./getJoinIndexedList')
+});
+exports.runQuery = void 0;
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.reduce.js");
+var _deleteEntity = require("../queries/deleteEntity");
+var _insertEntity = require("../queries/insertEntity");
+var _readEntity = require("../queries/readEntity");
+var _updateEntity = require("../queries/updateEntity");
+var _joinEntity = require("../queries/joinEntity");
+var _mergeJoins = require("../queries/mergeJoins");
+var _where = require("../queries/where");
+var _sortBy = require("../queries/sortBy");
+var _groupBy = require("../queries/groupBy");
+var _limitOffset = require("../queries/limitOffset");
+var _selectFields = require("../queries/selectFields");
+var _retrieveRecord = require("./retrieveRecord");
+var _getConditionIndexedList = require("./getConditionIndexedList");
+var _getJoinIndexedList = require("./getJoinIndexedList");
 const runQuery = async parsed => {
   const recordData = {
     [parsed.entity]: await (0, _retrieveRecord.retrieveRecord)(parsed.entity)
-  }
+  };
   if (typeof parsed.joinEntity !== 'undefined') {
-    recordData[parsed.joinEntity] = await (0, _retrieveRecord.retrieveRecord)(parsed.joinEntity)
+    recordData[parsed.joinEntity] = await (0, _retrieveRecord.retrieveRecord)(parsed.joinEntity);
   }
   let dataSet = {
     [parsed.entity]: []
-  }
+  };
   // A condition that's indexed but genuinely matches nothing leaves dataSet[entity] at [] - the
   // same state it starts in before anything has looked at it at all. readEntity() (below) can't
   // tell those two states apart on its own (it reloads whenever the array is empty, regardless of
   // why), so capture here, before that ambiguity can happen, whether every condition actually got
   // resolved this way - if so, dataSet[entity] is already correct and must not be reloaded.
-  const hadConditions = parsed.conditions.length > 0
-  parsed = await (0, _getConditionIndexedList.getConditionIndexedList)(parsed, recordData, dataSet)
-  const conditionsFullyIndexed = hadConditions && parsed.conditions.length === 0
-  parsed = await (0, _getJoinIndexedList.getJoinIndexedList)(parsed, recordData, dataSet)
+  const hadConditions = parsed.conditions.length > 0;
+  parsed = await (0, _getConditionIndexedList.getConditionIndexedList)(parsed, recordData, dataSet);
+  const conditionsFullyIndexed = hadConditions && parsed.conditions.length === 0;
+  parsed = await (0, _getJoinIndexedList.getJoinIndexedList)(parsed, recordData, dataSet);
   // delete/update act on whatever is already in dataSet[entity] - unlike read, which loads
   // everything and lets the where-reduce below narrow it down afterward, they never get a second
   // pass. So the matching rows have to be fully resolved (indexed conditions already are, via
   // getConditionIndexedList above; anything left in parsed.conditions is not) before either runs.
   if (parsed.command === 'delete' || parsed.command === 'update') {
     if (!conditionsFullyIndexed) {
-      dataSet = await (0, _readEntity.readEntity)(parsed.entity, dataSet)
+      dataSet = await (0, _readEntity.readEntity)(parsed.entity, dataSet);
     }
-    dataSet[parsed.entity] = parsed.conditions.reduce((remainingData, condition) => (0, _where.where)(remainingData, condition), dataSet[parsed.entity])
+    dataSet[parsed.entity] = parsed.conditions.reduce((remainingData, condition) => (0, _where.where)(remainingData, condition), dataSet[parsed.entity]);
   }
   switch (parsed.command) {
     case 'delete':
-      dataSet = await (0, _deleteEntity.deleteEntity)(parsed.entity, dataSet)
-      break
+      dataSet = await (0, _deleteEntity.deleteEntity)(parsed.entity, dataSet);
+      break;
     case 'insert':
-      dataSet = await (0, _insertEntity.insertEntity)(parsed.entity, parsed.insertValues, dataSet)
-      break
+      dataSet = await (0, _insertEntity.insertEntity)(parsed.entity, parsed.insertValues, dataSet);
+      break;
     case 'read':
       if (!conditionsFullyIndexed) {
-        dataSet = await (0, _readEntity.readEntity)(parsed.entity, dataSet)
+        dataSet = await (0, _readEntity.readEntity)(parsed.entity, dataSet);
       }
-      break
+      break;
     case 'update':
-      dataSet = await (0, _updateEntity.updateEntity)(parsed.entity, parsed.updateValues, dataSet)
-      break
+      dataSet = await (0, _updateEntity.updateEntity)(parsed.entity, parsed.updateValues, dataSet);
+      break;
     default:
-      throw new Error(`Unknown command: ${parsed.command}`)
+      throw new Error(`Unknown command: ${parsed.command}`);
   }
-  dataSet = await (0, _joinEntity.joinEntity)(parsed.entity, parsed.joinEntity, dataSet, parsed.joinClauses, conditionsFullyIndexed)
-  dataSet = await (0, _mergeJoins.mergeJoins)(dataSet, parsed.mergeJoins)
+  dataSet = await (0, _joinEntity.joinEntity)(parsed.entity, parsed.joinEntity, dataSet, parsed.joinClauses, conditionsFullyIndexed);
+  dataSet = await (0, _mergeJoins.mergeJoins)(dataSet, parsed.mergeJoins);
   // delete/update already had parsed.conditions applied above, before they ran. Re-applying the
   // same conditions here would be wrong, not just redundant, for update specifically: if the
   // update just changed the very field a condition filters on, re-checking that condition against
   // the now-changed data would filter the just-updated rows back out.
   if (parsed.command !== 'delete' && parsed.command !== 'update') {
     dataSet[parsed.entity] = parsed.conditions.reduce((remainingData, condition) => {
-      return (0, _where.where)(remainingData, condition)
-    }, dataSet[parsed.entity])
+      return (0, _where.where)(remainingData, condition);
+    }, dataSet[parsed.entity]);
   }
-  dataSet[parsed.entity] = (0, _sortBy.sortBy)(dataSet[parsed.entity], parsed.sortClauses)
-  dataSet[parsed.entity] = (0, _limitOffset.limitOffset)(dataSet[parsed.entity], parsed.offset, parsed.limit)
-  dataSet[parsed.entity] = (0, _groupBy.groupBy)(dataSet[parsed.entity], parsed.groupBy)
-  dataSet[parsed.entity] = (0, _selectFields.selectFields)(dataSet[parsed.entity], parsed.selectClauses)
-  return dataSet
-}
-exports.runQuery = runQuery
+  dataSet[parsed.entity] = (0, _sortBy.sortBy)(dataSet[parsed.entity], parsed.sortClauses);
+  dataSet[parsed.entity] = (0, _limitOffset.limitOffset)(dataSet[parsed.entity], parsed.offset, parsed.limit);
+  dataSet[parsed.entity] = (0, _groupBy.groupBy)(dataSet[parsed.entity], parsed.groupBy);
+  dataSet[parsed.entity] = (0, _selectFields.selectFields)(dataSet[parsed.entity], parsed.selectClauses);
+  return dataSet;
+};
+exports.runQuery = runQuery;

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

@@ -1,17 +1,17 @@
-import { keyDefinition } from '../introspect/definitions/key';
-import { recordPath } from '../introspect/definitions/record';
-export type indexEntry = {
-    value: any;
-    record: string[];
-};
-/**
- * Add a single entry file to the index that backs one of a record's keys, creating the index
- * file (and its __indexes/{record} directory) the first time a value is indexed. Keys with no
- * lookup (multi-field keys are not indexed here) are left untouched.
- * @param path
- * @param key
- * @param value
- * @param fileName
- */
-export declare const updateIndex: (path?: recordPath, key?: keyDefinition, value?: any, fileName?: string) => Promise<indexEntry[] | null>;
+import { keyDefinition } from '../introspect/definitions/key';
+import { recordPath } from '../introspect/definitions/record';
+export type indexEntry = {
+    value: any;
+    record: string[];
+};
+/**
+ * Add a single entry file to the index that backs one of a record's keys, creating the index
+ * file (and its __indexes/{record} directory) the first time a value is indexed. Keys with no
+ * lookup (multi-field keys are not indexed here) are left untouched.
+ * @param path
+ * @param key
+ * @param value
+ * @param fileName
+ */
+export declare const updateIndex: (path?: recordPath, key?: keyDefinition, value?: any, fileName?: string) => Promise<indexEntry[] | null>;
 //# sourceMappingURL=updateIndex.d.ts.map

package/dist/data/utilities/updateIndex.js

@@ -1,19 +1,19 @@
-'use strict'
+"use strict";
 
-Object.defineProperty(exports, '__esModule', {
+Object.defineProperty(exports, "__esModule", {
   value: true
-})
-exports.updateIndex = void 0
-require('core-js/modules/es.array.includes.js')
-require('core-js/modules/es.json.stringify.js')
-require('core-js/modules/esnext.iterator.constructor.js')
-require('core-js/modules/esnext.iterator.find.js')
-const _config = require('./config')
+});
+exports.updateIndex = void 0;
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/es.json.stringify.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.find.js");
+var _config = require("./config");
 const {
   readFile,
   writeFile,
   mkdir
-} = require('fs/promises')
+} = require('fs/promises');
 /**
  * Add a single entry file to the index that backs one of a record's keys, creating the index
  * file (and its __indexes/{record} directory) the first time a value is indexed. Keys with no
@@ -25,32 +25,32 @@ const {
  */
 const updateIndex = async (path = '', key = null, value = undefined, fileName = '') => {
   if (!key || !key.lookup) {
-    return null
+    return null;
   }
-  const databasePath = (0, _config.getSetting)('databasePath', 'database/')
-  const indexDir = `${databasePath}__indexes/${path}`
-  const indexPath = `${indexDir}/${key.lookup}`
-  let index = []
+  const databasePath = (0, _config.getSetting)('databasePath', 'database/');
+  const indexDir = `${databasePath}__indexes/${path}`;
+  const indexPath = `${indexDir}/${key.lookup}`;
+  let index = [];
   try {
-    index = JSON.parse(await readFile(indexPath, 'utf8'))
+    index = JSON.parse(await readFile(indexPath, 'utf8'));
   } catch (err) {
-    index = []
+    index = [];
   }
-  const existingEntry = index.find(entry => entry.value == value)
+  const existingEntry = index.find(entry => entry.value == value);
   if (existingEntry) {
     if (!existingEntry.record.includes(fileName)) {
-      existingEntry.record.push(fileName)
+      existingEntry.record.push(fileName);
     }
   } else {
     index.push({
       value,
       record: [fileName]
-    })
+    });
   }
   await mkdir(indexDir, {
     recursive: true
-  })
-  await writeFile(indexPath, JSON.stringify(index, null, 2))
-  return index
-}
-exports.updateIndex = updateIndex
+  });
+  await writeFile(indexPath, JSON.stringify(index, null, 2));
+  return index;
+};
+exports.updateIndex = updateIndex;

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

@@ -1,6 +1,6 @@
-export declare const useJoinClause: ({ propertyA, comparator, propertyB }?: {
-    propertyA?: any;
-    comparator?: string;
-    propertyB?: any;
-}, dataSets?: {}, filterJoins?: {}) => Promise<{}>;
+export declare const useJoinClause: ({ propertyA, comparator, propertyB }?: {
+    propertyA?: any;
+    comparator?: string;
+    propertyB?: any;
+}, dataSets?: {}, filterJoins?: {}) => Promise<{}>;
 //# sourceMappingURL=useJoinClause.d.ts.map

package/dist/data/utilities/useJoinClause.js

@@ -1,16 +1,16 @@
-'use strict'
+"use strict";
 
-Object.defineProperty(exports, '__esModule', {
+Object.defineProperty(exports, "__esModule", {
   value: true
-})
-exports.useJoinClause = void 0
-require('core-js/modules/esnext.iterator.constructor.js')
-require('core-js/modules/esnext.iterator.reduce.js')
-const _readEntity = require('../queries/readEntity')
-const _where = require('../queries/where')
-const _splitEntityProperty = require('./parsers/splitEntityProperty')
-const _siFunciona = _interopRequireDefault(require('si-funciona'))
-function _interopRequireDefault (e) { return e && e.__esModule ? e : { default: e } }
+});
+exports.useJoinClause = void 0;
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.reduce.js");
+var _readEntity = require("../queries/readEntity");
+var _where = require("../queries/where");
+var _splitEntityProperty = require("./parsers/splitEntityProperty");
+var _siFunciona = _interopRequireDefault(require("si-funciona"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const useJoinClause = async ({
   propertyA = null,
   comparator = '=',
@@ -19,33 +19,33 @@ const useJoinClause = async ({
   const {
     entity: entityA,
     property: propA
-  } = (0, _splitEntityProperty.splitEntityProperty)(propertyA)
+  } = (0, _splitEntityProperty.splitEntityProperty)(propertyA);
   const {
     entity: entityB,
     property: propB
-  } = (0, _splitEntityProperty.splitEntityProperty)(propertyB)
+  } = (0, _splitEntityProperty.splitEntityProperty)(propertyB);
   if (!Object.prototype.hasOwnProperty.call(dataSets, entityA)) {
-    dataSets = await (0, _readEntity.readEntity)(entityA, dataSets)
+    dataSets = await (0, _readEntity.readEntity)(entityA, dataSets);
   }
   if (!Object.prototype.hasOwnProperty.call(dataSets, entityB)) {
-    dataSets = await (0, _readEntity.readEntity)(entityB, dataSets)
+    dataSets = await (0, _readEntity.readEntity)(entityB, dataSets);
   }
   if (!Object.prototype.hasOwnProperty.call(filterJoins, entityA)) {
-    filterJoins[entityA] = _siFunciona.default.cloneObject(dataSets[entityA])
+    filterJoins[entityA] = _siFunciona.default.cloneObject(dataSets[entityA]);
   }
   if (!Object.prototype.hasOwnProperty.call(filterJoins, entityB)) {
-    filterJoins[entityB] = _siFunciona.default.cloneObject(dataSets[entityB])
+    filterJoins[entityB] = _siFunciona.default.cloneObject(dataSets[entityB]);
   }
   filterJoins[entityA] = filterJoins[entityB].reduce((dataA, dataB) => _siFunciona.default.mergeArrays(dataA, (0, _where.where)(filterJoins[entityA], {
     property: propA,
     comparator,
     value: dataB[propB]
-  })), [])
+  })), []);
   filterJoins[entityB] = filterJoins[entityA].reduce((dataB, dataA) => _siFunciona.default.mergeArrays(dataB, (0, _where.where)(filterJoins[entityB], {
     property: propB,
     comparator,
     value: dataA[propA]
-  })), [])
-  return filterJoins
-}
-exports.useJoinClause = useJoinClause
+  })), []);
+  return filterJoins;
+};
+exports.useJoinClause = useJoinClause;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export { query } from './data/queries/query';
-export { create, drop, describe } from './data/introspect';
-export { configure } from './data/utilities/config';
-export { fieldProperties, fieldDefinition, fieldName, keyProperties, keyDefinition, indexType, indexLocation, referenceProperties, reference, recordProperties, recordDefinition, recordPath, entityPath } from './data/introspect';
+export { query } from './data/queries/query';
+export { create, drop, describe } from './data/introspect';
+export { configure } from './data/utilities/config';
+export { fieldProperties, fieldDefinition, fieldName, keyProperties, keyDefinition, indexType, indexLocation, referenceProperties, reference, recordProperties, recordDefinition, recordPath, entityPath } from './data/introspect';
 //# sourceMappingURL=index.d.ts.map