json-fs-query 0.1.0

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

@@ -0,0 +1,12 @@
+/**
+ * Validate (and where sensible, coerce) a value against a field's declared type. Runs only
+ * against values being written by insertEntity/updateEntity - it never re-validates data already
+ * on disk, so a field whose declared type doesn't match its already-stored values (which can
+ * happen, since nothing enforced this before) is left alone until something actually updates it.
+ * An unrecognized type name is treated as unconstrained rather than rejected, so a typo in a
+ * schema's field type can't silently block every write to that field.
+ * @param type
+ * @param value
+ */
+export declare const typeCheck: (type?: string, value?: any) => any;
+//# sourceMappingURL=typeCheck.d.ts.map

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

@@ -0,0 +1,57 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.typeCheck = void 0
+/**
+ * Validate (and where sensible, coerce) a value against a field's declared type. Runs only
+ * against values being written by insertEntity/updateEntity - it never re-validates data already
+ * on disk, so a field whose declared type doesn't match its already-stored values (which can
+ * happen, since nothing enforced this before) is left alone until something actually updates it.
+ * An unrecognized type name is treated as unconstrained rather than rejected, so a typo in a
+ * schema's field type can't silently block every write to that field.
+ * @param type
+ * @param value
+ */
+const typeCheck = (type = 'string', value = undefined) => {
+  if (typeof value === 'undefined') {
+    return value
+  }
+  switch (type) {
+    case 'string':
+      return typeof value === 'string' ? value : String(value)
+    case 'int':
+    {
+      const coerced = Number(value)
+      if (Number.isNaN(coerced) || !Number.isInteger(coerced)) {
+        throw new Error(`Value "${value}" is not a valid int`)
+      }
+      return coerced
+    }
+    case 'boolean':
+      if (typeof value === 'boolean') {
+        return value
+      }
+      if (value === 'true') {
+        return true
+      }
+      if (value === 'false') {
+        return false
+      }
+      throw new Error(`Value "${value}" is not a valid boolean`)
+    case 'object':
+      if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new Error(`Value "${value}" is not a valid object`)
+      }
+      return value
+    case 'array':
+      if (!Array.isArray(value)) {
+        throw new Error(`Value "${value}" is not a valid array`)
+      }
+      return value
+    default:
+      return value
+  }
+}
+exports.typeCheck = typeCheck

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

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

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

@@ -0,0 +1,2 @@
+export declare const typeEnum: (values?: any[], value?: string, optional?: boolean) => boolean;
+//# sourceMappingURL=typeEnum.d.ts.map

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

@@ -0,0 +1,14 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.typeEnum = void 0
+require('core-js/modules/es.array.includes.js')
+const typeEnum = (values = [], value = '', optional = false) => {
+  if (values.includes(value)) {
+    return true
+  }
+  return typeof value === 'undefined' && optional
+}
+exports.typeEnum = typeEnum

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.typeEnum=void 0,require("core-js/modules/es.array.includes.js");const typeEnum=(e=[],s="",t=!1)=>!!e.includes(s)||void 0===s&&t;exports.typeEnum=typeEnum;

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

@@ -0,0 +1,2 @@
+export declare const useDefault: (defaultValue?: string, value?: any) => any;
+//# sourceMappingURL=useDefault.d.ts.map

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

@@ -0,0 +1,13 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.useDefault = void 0
+const useDefault = (defaultValue = '', value = undefined) => {
+  if (typeof value === 'undefined') {
+    return defaultValue
+  }
+  return value
+}
+exports.useDefault = useDefault

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.useDefault=void 0;const useDefault=(e="",t=void 0)=>void 0===t?e:t;exports.useDefault=useDefault;

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

@@ -0,0 +1,2 @@
+export declare const deleteEntity: (entity?: string, dataSet?: Object) => Promise<Object>;
+//# sourceMappingURL=deleteEntity.d.ts.map

package/dist/data/queries/deleteEntity.js

@@ -0,0 +1,79 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.deleteEntity = void 0
+require('core-js/modules/es.json.stringify.js')
+require('core-js/modules/esnext.iterator.constructor.js')
+require('core-js/modules/esnext.iterator.find.js')
+require('core-js/modules/esnext.iterator.map.js')
+require('core-js/modules/esnext.set.add-all.js')
+require('core-js/modules/esnext.set.delete-all.js')
+require('core-js/modules/esnext.set.difference.js')
+require('core-js/modules/esnext.set.every.js')
+require('core-js/modules/esnext.set.filter.js')
+require('core-js/modules/esnext.set.find.js')
+require('core-js/modules/esnext.set.intersection.js')
+require('core-js/modules/esnext.set.is-disjoint-from.js')
+require('core-js/modules/esnext.set.is-subset-of.js')
+require('core-js/modules/esnext.set.is-superset-of.js')
+require('core-js/modules/esnext.set.join.js')
+require('core-js/modules/esnext.set.map.js')
+require('core-js/modules/esnext.set.reduce.js')
+require('core-js/modules/esnext.set.some.js')
+require('core-js/modules/esnext.set.symmetric-difference.js')
+require('core-js/modules/esnext.set.union.js')
+const _retrieveRecord = require('../utilities/retrieveRecord')
+const _retrieveFile = require('../utilities/retrieveFile')
+const _removeFromIndex = require('../utilities/removeFromIndex')
+const gulpConfig = require('js-build-tools/gulp.config')
+const {
+  rm,
+  writeFile
+} = require('fs/promises')
+/**
+ * A record object carries no memory of which entry file it was read from, and files are not
+ * guaranteed to be named after any field's value, so the only reliable way to find a record's
+ * file is to re-scan every entry and match it by its primary key value.
+ * @param entity
+ * @param record
+ * @param primaryField
+ * @param deletedValues
+ */
+const removeMatchingEntries = async (entity, record, primaryField, deletedValues) => {
+  const databasePath = gulpConfig.get('databasePath', 'database/')
+  const remainingEntries = []
+  for (const fileName of record.entries) {
+    const data = await (0, _retrieveFile.retrieveFile)(`${record.path}/${fileName}`)
+    if (!deletedValues.has(data[primaryField])) {
+      remainingEntries.push(fileName)
+      continue
+    }
+    await rm(`${databasePath}${record.path}/${fileName}`)
+    for (const key of record.keys) {
+      if (key.fields.length === 1) {
+        await (0, _removeFromIndex.removeFromIndex)(record.path, key, data[key.fields[0]], fileName)
+      }
+    }
+  }
+  return remainingEntries
+}
+const deleteEntity = async (entity = '', dataSet = {}) => {
+  const databasePath = gulpConfig.get('databasePath', 'database/')
+  const record = await (0, _retrieveRecord.retrieveRecord)(entity)
+  const primaryKey = record.keys.find(key => key.type === 'primary' && key.fields.length === 1)
+  if (!primaryKey) {
+    throw new Error(`Cannot delete from "${entity}" without a single-field primary key`)
+  }
+  const primaryField = primaryKey.fields[0]
+  const toDelete = dataSet[entity] || []
+  if (!toDelete.length) {
+    return dataSet
+  }
+  const deletedValues = new Set(toDelete.map(row => row[primaryField]))
+  record.entries = await removeMatchingEntries(entity, record, primaryField, deletedValues)
+  await writeFile(`${databasePath}${record.path}.json`, JSON.stringify(record, null, 2))
+  return dataSet
+}
+exports.deleteEntity = deleteEntity

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.deleteEntity=void 0,require("core-js/modules/es.json.stringify.js"),require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.find.js"),require("core-js/modules/esnext.iterator.map.js"),require("core-js/modules/esnext.set.add-all.js"),require("core-js/modules/esnext.set.delete-all.js"),require("core-js/modules/esnext.set.difference.js"),require("core-js/modules/esnext.set.every.js"),require("core-js/modules/esnext.set.filter.js"),require("core-js/modules/esnext.set.find.js"),require("core-js/modules/esnext.set.intersection.js"),require("core-js/modules/esnext.set.is-disjoint-from.js"),require("core-js/modules/esnext.set.is-subset-of.js"),require("core-js/modules/esnext.set.is-superset-of.js"),require("core-js/modules/esnext.set.join.js"),require("core-js/modules/esnext.set.map.js"),require("core-js/modules/esnext.set.reduce.js"),require("core-js/modules/esnext.set.some.js"),require("core-js/modules/esnext.set.symmetric-difference.js"),require("core-js/modules/esnext.set.union.js");var _retrieveRecord=require("../utilities/retrieveRecord"),_retrieveFile=require("../utilities/retrieveFile"),_removeFromIndex=require("../utilities/removeFromIndex");const gulpConfig=require("js-build-tools/gulp.config"),{rm:rm,writeFile:writeFile}=require("fs/promises"),removeMatchingEntries=async(e,r,s,t)=>{const i=gulpConfig.get("databasePath","database/"),o=[];for(const e of r.entries){const n=await(0,_retrieveFile.retrieveFile)(`${r.path}/${e}`);if(t.has(n[s])){await rm(`${i}${r.path}/${e}`);for(const s of r.keys)1===s.fields.length&&await(0,_removeFromIndex.removeFromIndex)(r.path,s,n[s.fields[0]],e)}else o.push(e)}return o},deleteEntity=async(e="",r={})=>{const s=gulpConfig.get("databasePath","database/"),t=await(0,_retrieveRecord.retrieveRecord)(e),i=t.keys.find((e=>"primary"===e.type&&1===e.fields.length));if(!i)throw new Error(`Cannot delete from "${e}" without a single-field primary key`);const o=i.fields[0],n=r[e]||[];if(!n.length)return r;const u=new Set(n.map((e=>e[o])));return t.entries=await removeMatchingEntries(0,t,o,u),await writeFile(`${s}${t.path}.json`,JSON.stringify(t,null,2)),r};exports.deleteEntity=deleteEntity;

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

@@ -0,0 +1,2 @@
+export declare const groupBy: (dataSet?: any[], groupProperty?: string) => any;
+//# sourceMappingURL=groupBy.d.ts.map

package/dist/data/queries/groupBy.js

@@ -0,0 +1,22 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.groupBy = void 0
+require('core-js/modules/esnext.iterator.constructor.js')
+require('core-js/modules/esnext.iterator.reduce.js')
+const groupBy = (dataSet = [], groupProperty = '') => {
+  if (!groupProperty) {
+    return dataSet
+  }
+  return dataSet.reduce((groupedData, data) => {
+    const property = data[groupProperty]
+    if (!groupedData.hasOwnProperty(property)) {
+      groupedData[property] = []
+    }
+    groupedData[property].push(data)
+    return groupedData
+  }, {})
+}
+exports.groupBy = groupBy

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.groupBy=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.reduce.js");const groupBy=(e=[],r="")=>r?e.reduce(((e,o)=>{const s=o[r];return e.hasOwnProperty(s)||(e[s]=[]),e[s].push(o),e}),{}):e;exports.groupBy=groupBy;

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

@@ -0,0 +1,2 @@
+export declare const insertEntity: (entity?: string, values?: Object[], dataSet?: Object) => Promise<Object>;
+//# sourceMappingURL=insertEntity.d.ts.map

package/dist/data/queries/insertEntity.js

@@ -0,0 +1,115 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+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')
+const _retrieveRecord = require('../utilities/retrieveRecord')
+const _updateIndex = require('../utilities/updateIndex')
+const _keyGenerate = require('../introspect/policies/keyGenerate')
+const _keyUnique = require('../introspect/policies/keyUnique')
+const _useDefault = require('../introspect/policies/useDefault')
+const _typeCheck = require('../introspect/policies/typeCheck')
+const _foreignKeyExists = require('../introspect/policies/foreignKeyExists')
+const _splitEntityProperty = require('../utilities/parsers/splitEntityProperty')
+const gulpConfig = require('js-build-tools/gulp.config')
+const {
+  writeFile
+} = require('fs/promises')
+/**
+ * Build one entity's stored values from the raw input values, generating any autoGenerate
+ * fields and applying field defaults, then throw if a required field still has no value.
+ * @param entity
+ * @param record
+ * @param rowValues
+ */
+const buildEntityValues = async (entity, record, rowValues = {}) => {
+  const entityValues = {}
+  for (const field of record.definition) {
+    let value = rowValues[field.name]
+    if (field.autoGenerate) {
+      value = await (0, _keyGenerate.keyGenerate)(entity, [field.name])
+    } else if (field.hasOwnProperty('default')) {
+      value = (0, _useDefault.useDefault)(field.default, value)
+    }
+    if (typeof value === 'undefined') {
+      if (!field.optional) {
+        throw new Error(`Missing required field "${field.name}" for ${entity}`)
+      }
+      continue
+    }
+    entityValues[field.name] = (0, _typeCheck.typeCheck)(field.type, value)
+  }
+  return entityValues
+}
+/**
+ * Reject the insert if it collides with an existing primary or unique single-field key value.
+ * @param entity
+ * @param record
+ * @param entityValues
+ */
+const assertUnique = async (entity, record, entityValues) => {
+  for (const key of record.keys) {
+    if (key.type !== 'primary' && key.type !== 'unique' || key.fields.length !== 1) {
+      continue
+    }
+    const isUnique = await (0, _keyUnique.keyUnique)(entity, key.fields, entityValues[key.fields[0]])
+    if (!isUnique) {
+      throw new Error(`Duplicate value for ${key.type} key "${key.fields[0]}" on ${entity}`)
+    }
+  }
+}
+/**
+ * Reject the insert if a single-field foreign key's value doesn't exist in the record it
+ * references.
+ * @param entity
+ * @param record
+ * @param entityValues
+ */
+const assertForeignKeys = async (entity, record, entityValues) => {
+  for (const key of record.keys) {
+    if (key.type !== 'foreign' || key.fields.length !== 1 || !key.references || key.references.length !== 1) {
+      continue
+    }
+    const field = key.fields[0]
+    if (!entityValues.hasOwnProperty(field)) {
+      continue
+    }
+    const {
+      entity: refEntity,
+      property: refProperty
+    } = (0, _splitEntityProperty.splitEntityProperty)(key.references[0].fields[0])
+    const exists = await (0, _foreignKeyExists.foreignKeyExists)(refEntity, refProperty, entityValues[field])
+    if (!exists) {
+      throw new Error(`Foreign key "${field}" on ${entity} references a nonexistent ${refEntity}.${refProperty} = ${entityValues[field]}`)
+    }
+  }
+}
+const insertEntity = async (entity = '', values = [], dataSet = {}) => {
+  const databasePath = gulpConfig.get('databasePath', 'database/')
+  const record = await (0, _retrieveRecord.retrieveRecord)(entity)
+  const primaryKey = record.keys.find(key => key.type === 'primary' && key.fields.length === 1)
+  if (!dataSet.hasOwnProperty(entity)) {
+    dataSet[entity] = []
+  }
+  for (const rowValues of values) {
+    const entityValues = await buildEntityValues(entity, record, rowValues)
+    await assertUnique(entity, record, entityValues)
+    await assertForeignKeys(entity, record, entityValues)
+    const fileName = `${primaryKey ? entityValues[primaryKey.fields[0]] : crypto.randomUUID()}.json`
+    await writeFile(`${databasePath}${record.path}/${fileName}`, JSON.stringify(entityValues, null, 2))
+    record.entries.push(fileName)
+    await writeFile(`${databasePath}${record.path}.json`, JSON.stringify(record, null, 2))
+    for (const key of record.keys) {
+      if (key.fields.length === 1) {
+        await (0, _updateIndex.updateIndex)(record.path, key, entityValues[key.fields[0]], fileName)
+      }
+    }
+    dataSet[entity].push(entityValues)
+  }
+  return dataSet
+}
+exports.insertEntity = insertEntity

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

@@ -0,0 +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");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");const gulpConfig=require("js-build-tools/gulp.config"),{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]):s.hasOwnProperty("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||1!==r.fields.length)continue;if(!await(0,_keyUnique.keyUnique)(e,r.fields,i[r.fields[0]]))throw new Error(`Duplicate value for ${r.type} key "${r.fields[0]}" 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(!i.hasOwnProperty(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=gulpConfig.get("databasePath","database/"),s=await(0,_retrieveRecord.retrieveRecord)(e),n=s.keys.find((e=>"primary"===e.type&&1===e.fields.length));i.hasOwnProperty(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)1===e.fields.length&&await(0,_updateIndex.updateIndex)(s.path,e,t[e.fields[0]],a);i[e].push(t)}return i};exports.insertEntity=insertEntity;

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

@@ -0,0 +1,2 @@
+export declare const joinEntity: (entity: any, joinEntity: any, dataSets?: {}, joinClauses?: any[]) => Promise<{}>;
+//# sourceMappingURL=joinEntity.d.ts.map

package/dist/data/queries/joinEntity.js

@@ -0,0 +1,27 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.joinEntity = void 0
+const _siFunciona = _interopRequireDefault(require('si-funciona'))
+const _readEntity = require('./readEntity')
+const _useJoinClause = require('../utilities/useJoinClause')
+function _interopRequireDefault (e) { return e && e.__esModule ? e : { default: e } }
+const joinEntity = async (entity, joinEntity, dataSets = {}, joinClauses = []) => {
+  dataSets = await (0, _readEntity.readEntity)(entity, dataSets)
+  if (!joinClauses.length) {
+    return dataSets
+  }
+  dataSets = await (0, _readEntity.readEntity)(joinEntity, dataSets)
+  for (const anEntity in dataSets[entity]) {
+    let filterJoins = _siFunciona.default.cloneObject(dataSets)
+    filterJoins[entity] = [dataSets[entity][anEntity]]
+    for (const joinClause of joinClauses) {
+      filterJoins = await (0, _useJoinClause.useJoinClause)(joinClause, dataSets, filterJoins)
+    }
+    dataSets[entity][anEntity][joinEntity] = filterJoins[joinEntity]
+  }
+  return dataSets
+}
+exports.joinEntity = joinEntity

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.joinEntity=void 0;var _siFunciona=_interopRequireDefault(require("si-funciona")),_readEntity=require("./readEntity"),_useJoinClause=require("../utilities/useJoinClause");function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e}}const joinEntity=async(e,t,i={},n=[])=>{if(i=await(0,_readEntity.readEntity)(e,i),!n.length)return i;i=await(0,_readEntity.readEntity)(t,i);for(const r in i[e]){let u=_siFunciona.default.cloneObject(i);u[e]=[i[e][r]];for(let e of n)u=await(0,_useJoinClause.useJoinClause)(e,i,u);i[e][r][t]=u[t]}return i};exports.joinEntity=joinEntity;

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

@@ -0,0 +1,2 @@
+export declare const mergeJoins: (dataSet?: {}, merges?: any[]) => Promise<{}>;
+//# sourceMappingURL=mergeJoins.d.ts.map

package/dist/data/queries/mergeJoins.js

@@ -0,0 +1,19 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.mergeJoins = void 0
+const _mergeJoin = require('../utilities/mergeJoin')
+const _reconcileJoins = require('../utilities/reconcileJoins')
+const mergeJoins = async (dataSet = {}, merges = []) => {
+  if (!merges.length) {
+    return dataSet
+  }
+  for (const merge of merges) {
+    dataSet = await (0, _mergeJoin.mergeJoin)(merge.propertyA, merge.propertyB, dataSet)
+    dataSet = (0, _reconcileJoins.reconcileJoins)(merge.propertyA, merge.propertyB, dataSet)
+  }
+  return dataSet
+}
+exports.mergeJoins = mergeJoins

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.mergeJoins=void 0;var _mergeJoin=require("../utilities/mergeJoin"),_reconcileJoins=require("../utilities/reconcileJoins");const mergeJoins=async(e={},r=[])=>{if(!r.length)return e;for(let i of r)e=await(0,_mergeJoin.mergeJoin)(i.propertyA,i.propertyB,e),e=(0,_reconcileJoins.reconcileJoins)(i.propertyA,i.propertyB,e);return e};exports.mergeJoins=mergeJoins;

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

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

package/dist/data/queries/parser.js

@@ -0,0 +1,30 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.parser = void 0
+const _splitQueries = require('../utilities/parsers/splitQueries')
+const _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 = {}
+    try {
+      parsedQuery = (0, _parseQuery.parseQuery)(mergeQuery)
+      mergeQuery = ''
+    } catch (e) {
+      // attempt to combine queries to fix bad splits
+      continue
+    }
+    parsedQueries.push(parsedQuery)
+  }
+  if (mergeQuery) {
+    throw new Error(`Failed to interpret: ${mergeQuery}`)
+  }
+  return parsedQueries
+}
+exports.parser = parser

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

@@ -0,0 +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(let 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;

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

@@ -0,0 +1,2 @@
+export declare const query: (queryString?: string) => Promise<any[]>;
+//# sourceMappingURL=query.d.ts.map

package/dist/data/queries/query.js

@@ -0,0 +1,18 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.query = void 0
+const _parser = require('./parser')
+const _runQuery = require('../utilities/runQuery')
+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
+}
+exports.query = query

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

@@ -0,0 +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(let r of e){const e=await(0,_runQuery.runQuery)(r);u.push(e[r.entity])}return u};exports.query=query;

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

@@ -0,0 +1,2 @@
+export declare const readEntity: (entity?: string, dataSet?: {}) => Promise<{}>;
+//# sourceMappingURL=readEntity.d.ts.map

package/dist/data/queries/readEntity.js

@@ -0,0 +1,14 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.readEntity = void 0
+const _retrieveRecords = require('../utilities/retrieveRecords')
+const readEntity = async (entity = '', dataSet = {}) => {
+  if (!dataSet.hasOwnProperty(entity) || !dataSet[entity].length) {
+    dataSet[entity] = await (0, _retrieveRecords.retrieveRecords)(entity)
+  }
+  return dataSet
+}
+exports.readEntity = readEntity

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.readEntity=void 0;var _retrieveRecords=require("../utilities/retrieveRecords");const readEntity=async(e="",r={})=>(r.hasOwnProperty(e)&&r[e].length||(r[e]=await(0,_retrieveRecords.retrieveRecords)(e)),r);exports.readEntity=readEntity;

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

@@ -0,0 +1,2 @@
+export declare const sortBy: (dataSet?: any[], sortClauses?: any[]) => any[];
+//# sourceMappingURL=sortBy.d.ts.map

package/dist/data/queries/sortBy.js

@@ -0,0 +1,25 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.sortBy = void 0
+const sortBy = (dataSet = [], sortClauses = []) => {
+  if (!sortClauses.length) {
+    return dataSet
+  }
+  dataSet.sort((a, b) => {
+    for (const sortClause of sortClauses) {
+      const property = sortClause.property
+      const direction = sortClause.direction
+      if (a[property] == b[property]) {
+        continue
+      }
+      const result = a[property] < b[property] ? -1 : 1
+      return direction === 'asc' ? result : result * -1
+    }
+    return 0
+  })
+  return dataSet
+}
+exports.sortBy = sortBy

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.sortBy=void 0;const sortBy=(t=[],o=[])=>o.length?(t.sort(((t,r)=>{for(let e of o){const o=e.property,s=e.direction;if(t[o]==r[o])continue;const n=t[o]<r[o]?-1:1;return"asc"===s?n:-1*n}return 0})),t):t;exports.sortBy=sortBy;

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

@@ -0,0 +1,2 @@
+export declare const updateEntity: (entity?: string, values?: Object, dataSet?: Object) => Promise<Object>;
+//# sourceMappingURL=updateEntity.d.ts.map