json-fs-query 0.1.0

package/dist/data/queries/updateEntity.js

@@ -0,0 +1,164 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+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')
+const _retrieveRecord = require('../utilities/retrieveRecord')
+const _retrieveFile = require('../utilities/retrieveFile')
+const _updateIndex = require('../utilities/updateIndex')
+const _removeFromIndex = require('../utilities/removeFromIndex')
+const _keyUnique = require('../introspect/policies/keyUnique')
+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')
+/**
+ * Same reasoning as deleteEntity: a record object carries no memory of which entry file it came
+ * from, so re-scan entries[] and match by the record's own primary key value.
+ * @param record
+ * @param primaryField
+ * @param primaryValue
+ */
+const findEntryFile = async (record, primaryField, primaryValue) => {
+  for (const fileName of record.entries) {
+    const data = await (0, _retrieveFile.retrieveFile)(`${record.path}/${fileName}`)
+    if (data[primaryField] == primaryValue) {
+      return fileName
+    }
+  }
+  return null
+}
+/**
+ * Only check uniqueness for a single-field primary/unique key 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.
+ * @param entity
+ * @param record
+ * @param oldData
+ * @param newValues
+ */
+const assertUniqueForUpdate = async (entity, record, oldData, newValues) => {
+  for (const key of record.keys) {
+    if (key.type !== 'primary' && key.type !== 'unique' || key.fields.length !== 1) {
+      continue
+    }
+    const field = key.fields[0]
+    if (!newValues.hasOwnProperty(field) || newValues[field] == oldData[field]) {
+      continue
+    }
+    const isUnique = await (0, _keyUnique.keyUnique)(entity, key.fields, newValues[field])
+    if (!isUnique) {
+      throw new Error(`Duplicate value for ${key.type} key "${field}" on ${entity}`)
+    }
+  }
+}
+/**
+ * Move a single-field key's index entry from the old value to the new one wherever the update
+ * actually changed that field.
+ * @param record
+ * @param oldData
+ * @param newData
+ * @param newValues
+ * @param fileName
+ */
+/**
+ * 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.
+ * @param entity
+ * @param record
+ * @param oldData
+ * @param newValues
+ */
+const assertForeignKeysForUpdate = async (entity, record, oldData, newValues) => {
+  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 (!newValues.hasOwnProperty(field) || newValues[field] == oldData[field]) {
+      continue
+    }
+    const {
+      entity: refEntity,
+      property: refProperty
+    } = (0, _splitEntityProperty.splitEntityProperty)(key.references[0].fields[0])
+    const exists = await (0, _foreignKeyExists.foreignKeyExists)(refEntity, refProperty, newValues[field])
+    if (!exists) {
+      throw new Error(`Foreign key "${field}" on ${entity} references a nonexistent ${refEntity}.${refProperty} = ${newValues[field]}`)
+    }
+  }
+}
+const reconcileIndexes = async (record, oldData, newData, newValues, fileName) => {
+  for (const key of record.keys) {
+    if (key.fields.length !== 1) {
+      continue
+    }
+    const field = key.fields[0]
+    if (!newValues.hasOwnProperty(field) || newValues[field] == oldData[field]) {
+      continue
+    }
+    await (0, _removeFromIndex.removeFromIndex)(record.path, key, oldData[field], fileName)
+    await (0, _updateIndex.updateIndex)(record.path, key, newData[field], fileName)
+  }
+}
+const assertRequiredFields = (entity, record, newData) => {
+  for (const field of record.definition) {
+    if (!field.optional && typeof newData[field.name] === 'undefined') {
+      throw new Error(`Missing required field "${field.name}" for ${entity}`)
+    }
+  }
+}
+/**
+ * Type-check (and coerce) only the fields actually present in an update's values, never the rest
+ * of the merged record - a field whose already-stored value doesn't match its declared type
+ * (nothing enforced this before typeCheck() existed) must not block an update that never touches
+ * that field.
+ * @param record
+ * @param values
+ */
+const applyFieldTypes = (record, values) => {
+  const typedValues = Object.assign({}, values)
+  for (const field of record.definition) {
+    if (typedValues.hasOwnProperty(field.name)) {
+      typedValues[field.name] = (0, _typeCheck.typeCheck)(field.type, typedValues[field.name])
+    }
+  }
+  return typedValues
+}
+const updateEntity = 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 (!primaryKey) {
+    throw new Error(`Cannot update "${entity}" without a single-field primary key`)
+  }
+  const primaryField = primaryKey.fields[0]
+  const typedValues = applyFieldTypes(record, values)
+  const toUpdate = dataSet[entity] || []
+  const updatedRows = []
+  for (const row of toUpdate) {
+    const fileName = await findEntryFile(record, primaryField, row[primaryField])
+    if (!fileName) {
+      throw new Error(`Could not find entry for ${entity} where "${primaryField}" = ${row[primaryField]}`)
+    }
+    const oldData = await (0, _retrieveFile.retrieveFile)(`${record.path}/${fileName}`)
+    await assertUniqueForUpdate(entity, record, oldData, typedValues)
+    await assertForeignKeysForUpdate(entity, record, oldData, typedValues)
+    const newData = Object.assign({}, oldData, typedValues)
+    assertRequiredFields(entity, record, newData)
+    await reconcileIndexes(record, oldData, newData, typedValues, fileName)
+    await writeFile(`${databasePath}${record.path}/${fileName}`, JSON.stringify(newData, null, 2))
+    updatedRows.push(newData)
+  }
+  dataSet[entity] = updatedRows
+  return dataSet
+}
+exports.updateEntity = updateEntity

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

@@ -0,0 +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");var _retrieveRecord=require("../utilities/retrieveRecord"),_retrieveFile=require("../utilities/retrieveFile"),_updateIndex=require("../utilities/updateIndex"),_removeFromIndex=require("../utilities/removeFromIndex"),_keyUnique=require("../introspect/policies/keyUnique"),_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"),findEntryFile=async(e,t,r)=>{for(const i of e.entries){if((await(0,_retrieveFile.retrieveFile)(`${e.path}/${i}`))[t]==r)return i}return null},assertUniqueForUpdate=async(e,t,r,i)=>{for(const n of t.keys){if("primary"!==n.type&&"unique"!==n.type||1!==n.fields.length)continue;const t=n.fields[0];if(!i.hasOwnProperty(t)||i[t]==r[t])continue;if(!await(0,_keyUnique.keyUnique)(e,n.fields,i[t]))throw new Error(`Duplicate value for ${n.type} key "${t}" on ${e}`)}},assertForeignKeysForUpdate=async(e,t,r,i)=>{for(const n of t.keys){if("foreign"!==n.type||1!==n.fields.length||!n.references||1!==n.references.length)continue;const t=n.fields[0];if(!i.hasOwnProperty(t)||i[t]==r[t])continue;const{entity:s,property:o}=(0,_splitEntityProperty.splitEntityProperty)(n.references[0].fields[0]);if(!await(0,_foreignKeyExists.foreignKeyExists)(s,o,i[t]))throw new Error(`Foreign key "${t}" on ${e} references a nonexistent ${s}.${o} = ${i[t]}`)}},reconcileIndexes=async(e,t,r,i,n)=>{for(const s of e.keys){if(1!==s.fields.length)continue;const o=s.fields[0];i.hasOwnProperty(o)&&i[o]!=t[o]&&(await(0,_removeFromIndex.removeFromIndex)(e.path,s,t[o],n),await(0,_updateIndex.updateIndex)(e.path,s,r[o],n))}},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)r.hasOwnProperty(t.name)&&(r[t.name]=(0,_typeCheck.typeCheck)(t.type,r[t.name]));return r},updateEntity=async(e="",t={},r={})=>{const i=gulpConfig.get("databasePath","database/"),n=await(0,_retrieveRecord.retrieveRecord)(e),s=n.keys.find((e=>"primary"===e.type&&1===e.fields.length));if(!s)throw new Error(`Cannot update "${e}" without a single-field primary key`);const o=s.fields[0],a=applyFieldTypes(n,t),p=r[e]||[],l=[];for(const t of p){const r=await findEntryFile(n,o,t[o]);if(!r)throw new Error(`Could not find entry for ${e} where "${o}" = ${t[o]}`);const s=await(0,_retrieveFile.retrieveFile)(`${n.path}/${r}`);await assertUniqueForUpdate(e,n,s,a),await assertForeignKeysForUpdate(e,n,s,a);const p=Object.assign({},s,a);assertRequiredFields(e,n,p),await reconcileIndexes(n,s,p,a,r),await writeFile(`${i}${n.path}/${r}`,JSON.stringify(p,null,2)),l.push(p)}return r[e]=l,r};exports.updateEntity=updateEntity;

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

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

package/dist/data/queries/where.js

@@ -0,0 +1,56 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+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 = (dataValue, pattern) => {
+  if (typeof dataValue !== 'string' || typeof pattern !== 'string') {
+    return false
+  }
+  const regexPattern = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/%/g, '.*').replace(/_/g, '.')
+  return new RegExp(`^${regexPattern}$`, 'i').test(dataValue)
+}
+const makeCondition = (data, property, comparator, value) => {
+  if (!data.hasOwnProperty(property)) {
+    return false
+  }
+  const dataValue = data[property]
+  switch (comparator) {
+    case '=':
+      return dataValue == value
+    case '!=':
+    case '<>':
+      return dataValue != value
+    case '>':
+      return dataValue > value
+    case '>=':
+      return dataValue >= value
+    case '<':
+      return dataValue < value
+    case '<=':
+      return dataValue <= value
+    case 'in':
+      return Array.isArray(value) && value.includes(dataValue)
+    case 'between':
+      return Array.isArray(value) && value.length === 2 && dataValue >= value[0] && dataValue <= value[1]
+    case 'like':
+      return likeMatch(dataValue, value)
+  }
+  return false
+}
+const where = (dataSet = [], {
+  property = '',
+  joinEntity = undefined,
+  comparator = '=',
+  value = null
+} = {}) => {
+  return dataSet.filter(data => {
+    const testProperty = joinEntity ? `${joinEntity}.${property}` : property
+    return makeCondition(data, testProperty, comparator, value)
+  })
+}
+exports.where = where

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

@@ -0,0 +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(!e.hasOwnProperty(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;

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

@@ -0,0 +1,8 @@
+import { recordDefinition } from '../introspect/definitions/record';
+/**
+ * Remove a record's filename from the __RECORDS registry. A missing registry file is left
+ * untouched rather than created, since there's nothing to remove from it.
+ * @param recordName
+ */
+export declare const deregisterRecord: (recordName: string) => Promise<recordDefinition | null>;
+//# sourceMappingURL=deregisterRecord.d.ts.map

package/dist/data/utilities/deregisterRecord.js

@@ -0,0 +1,34 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.deregisterRecord = void 0
+require('core-js/modules/es.json.stringify.js')
+require('core-js/modules/esnext.iterator.constructor.js')
+require('core-js/modules/esnext.iterator.filter.js')
+const gulpConfig = require('js-build-tools/gulp.config')
+const {
+  readFile,
+  writeFile
+} = require('fs/promises')
+/**
+ * Remove a record's filename from the __RECORDS registry. A missing registry file is left
+ * untouched rather than created, since there's nothing to remove from it.
+ * @param recordName
+ */
+const deregisterRecord = async recordName => {
+  const databasePath = gulpConfig.get('databasePath', 'database/')
+  const registryPath = `${databasePath}__RECORDS.json`
+  let registry
+  try {
+    registry = JSON.parse(await readFile(registryPath, 'utf8'))
+  } catch (err) {
+    return null
+  }
+  const fileName = `${recordName}.json`
+  registry.entries = registry.entries.filter(entry => entry !== fileName)
+  await writeFile(registryPath, JSON.stringify(registry, null, 2))
+  return registry
+}
+exports.deregisterRecord = deregisterRecord

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.deregisterRecord=void 0,require("core-js/modules/es.json.stringify.js"),require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.js");const gulpConfig=require("js-build-tools/gulp.config"),{readFile:readFile,writeFile:writeFile}=require("fs/promises"),deregisterRecord=async e=>{const r=`${gulpConfig.get("databasePath","database/")}__RECORDS.json`;let t;try{t=JSON.parse(await readFile(r,"utf8"))}catch(e){return null}const s=`${e}.json`;return t.entries=t.entries.filter((e=>e!==s)),await writeFile(r,JSON.stringify(t,null,2)),t};exports.deregisterRecord=deregisterRecord;

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

@@ -0,0 +1,3 @@
+import { ParsedQuery } from './parsers/parseQuery';
+export declare const getConditionIndexedList: (parsed: ParsedQuery, recordData: any, dataSet: any) => Promise<ParsedQuery>;
+//# sourceMappingURL=getConditionIndexedList.d.ts.map

package/dist/data/utilities/getConditionIndexedList.js

@@ -0,0 +1,47 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.getConditionIndexedList = void 0
+const _isEntityProperty = require('./parsers/isEntityProperty')
+const _splitEntityProperty = require('./parsers/splitEntityProperty')
+const _retrieveRecord = require('./retrieveRecord')
+const _where = require('../queries/where')
+const _retrieveFile = require('./retrieveFile')
+const _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 (!recordData.hasOwnProperty(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
+      })
+      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/getConditionIndexedList.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.getConditionIndexedList=void 0;var _isEntityProperty=require("./parsers/isEntityProperty"),_splitEntityProperty=require("./parsers/splitEntityProperty"),_retrieveRecord=require("./retrieveRecord"),_where=require("../queries/where"),_retrieveFile=require("./retrieveFile"),_getMatchingIndexes=require("./getMatchingIndexes");const getConditionIndexedList=async(e,t,r)=>{let i=[];for(let o of e.conditions){let n=e.entity,s=o.property;if((0,_isEntityProperty.isEntityProperty)(s)){const e=(0,_splitEntityProperty.splitEntityProperty)(s);n=e.entity,s=e.property}t.hasOwnProperty(n)||(t[n]=await(0,_retrieveRecord.retrieveRecord)(n));const p={},d=async(e,t,r,i,o,n)=>{const s=(0,_where.where)(n[e][t],{property:"value",comparator:i.comparator,value:i.value});for(let t of s)for(let r of t.record)o[e].push(await(0,_retrieveFile.retrieveFile)(`${e}/${r}`))};await(0,_getMatchingIndexes.getMatchingIndexes)(n,s,t,o,r,p,d)||i.push(o)}return e.conditions=i,e};exports.getConditionIndexedList=getConditionIndexedList;

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

@@ -0,0 +1,3 @@
+import { ParsedQuery } from './parsers/parseQuery';
+export declare const getJoinIndexedList: (parsed: ParsedQuery, recordData: any, dataSets: any) => Promise<ParsedQuery>;
+//# sourceMappingURL=getJoinIndexedList.d.ts.map

package/dist/data/utilities/getJoinIndexedList.js

@@ -0,0 +1,59 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.getJoinIndexedList = void 0
+const _siFunciona = _interopRequireDefault(require('si-funciona'))
+const _splitEntityProperty = require('./parsers/splitEntityProperty')
+const _retrieveRecord = require('./retrieveRecord')
+const _getMatchingIndexes = require('./getMatchingIndexes')
+const _matchIndexedJoins = require('./matchIndexedJoins')
+const _restrictIndexedList = require('./restrictIndexedList')
+function _interopRequireDefault (e) { return e && e.__esModule ? e : { default: e } }
+const getJoinIndexedList = async (parsed, recordData, dataSets) => {
+  const reducedJoins = []
+  const indexed = {}
+  let firstIteration = true
+  const entity = parsed.entity
+  const joinEntity = parsed.joinEntity
+  const joinClauses = parsed.joinClauses
+  for (const anEntity in dataSets[entity]) {
+    const currentEntity = dataSets[entity][anEntity]
+    // Loop over each of the main entities
+    const filterJoins = {}
+    filterJoins[entity] = [_siFunciona.default.cloneObject(currentEntity)]
+    for (const joinClause of joinClauses) {
+      let indexedClone = _siFunciona.default.cloneObject(indexed)
+      const {
+        entity: entityA,
+        property: propertyA
+      } = (0, _splitEntityProperty.splitEntityProperty)(joinClause.propertyA)
+      const {
+        entity: entityB,
+        property: propertyB
+      } = (0, _splitEntityProperty.splitEntityProperty)(joinClause.propertyB)
+      // Get the record for the entities A and B, store on the recordData
+      if (!recordData.hasOwnProperty(entityA)) {
+        recordData[entityA] = await (0, _retrieveRecord.retrieveRecord)(entityA)
+      }
+      if (!recordData.hasOwnProperty(entityB)) {
+        recordData[entityB] = await (0, _retrieveRecord.retrieveRecord)(entityB)
+      }
+      indexedClone = (0, _restrictIndexedList.restrictIndexedList)(joinClause, filterJoins, indexedClone)
+      const retrieveMatchedFiles = (0, _matchIndexedJoins.matchIndexedJoins)(entity, indexedClone, dataSets)
+      // Check if there are matching keys for the join condition
+      const matchAResult = await (0, _getMatchingIndexes.getMatchingIndexes)(entityA, propertyA, recordData, joinClause, filterJoins, indexed)
+      const matchBResult = await (0, _getMatchingIndexes.getMatchingIndexes)(entityB, propertyB, recordData, joinClause, filterJoins, indexed, retrieveMatchedFiles)
+      const isIndexed = matchAResult || matchBResult
+      if (!isIndexed && firstIteration) {
+        reducedJoins.push(joinClause)
+        firstIteration = false
+      }
+    }
+    dataSets[entity][anEntity][joinEntity] = filterJoins[joinEntity]
+  }
+  parsed.joinClauses = reducedJoins
+  return parsed
+}
+exports.getJoinIndexedList = getJoinIndexedList

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.getJoinIndexedList=void 0;var _siFunciona=_interopRequireDefault(require("si-funciona")),_splitEntityProperty=require("./parsers/splitEntityProperty"),_retrieveRecord=require("./retrieveRecord"),_getMatchingIndexes=require("./getMatchingIndexes"),_matchIndexedJoins=require("./matchIndexedJoins"),_restrictIndexedList=require("./restrictIndexedList");function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e}}const getJoinIndexedList=async(e,t,r)=>{let i=[];const n={};let s=!0;const o=e.entity,d=e.joinEntity,c=e.joinClauses;for(const e in r[o]){const a=r[o][e];let p={};p[o]=[_siFunciona.default.cloneObject(a)];for(let e of c){let d=_siFunciona.default.cloneObject(n);const{entity:c,property:a}=(0,_splitEntityProperty.splitEntityProperty)(e.propertyA),{entity:u,property:y}=(0,_splitEntityProperty.splitEntityProperty)(e.propertyB);t.hasOwnProperty(c)||(t[c]=await(0,_retrieveRecord.retrieveRecord)(c)),t.hasOwnProperty(u)||(t[u]=await(0,_retrieveRecord.retrieveRecord)(u)),d=(0,_restrictIndexedList.restrictIndexedList)(e,p,d);const l=(0,_matchIndexedJoins.matchIndexedJoins)(o,d,r),_=await(0,_getMatchingIndexes.getMatchingIndexes)(c,a,t,e,p,n),x=await(0,_getMatchingIndexes.getMatchingIndexes)(u,y,t,e,p,n,l);!(_||x)&&s&&(i.push(e),s=!1)}r[o][e][d]=p[d]}return e.joinClauses=i,e};exports.getJoinIndexedList=getJoinIndexedList;

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

@@ -0,0 +1,2 @@
+export declare const getMatchingIndexes: (entity: string, property: string, recordData: Object, clause: Object, dataSet: Object, indexed: Object, cb?: Function) => Promise<boolean>;
+//# sourceMappingURL=getMatchingIndexes.d.ts.map

package/dist/data/utilities/getMatchingIndexes.js

@@ -0,0 +1,28 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.getMatchingIndexes = void 0
+require('core-js/modules/es.array.includes.js')
+const _retrieveIndexes = require('./retrieveIndexes')
+const getMatchingIndexes = async (entity, property, recordData, clause, dataSet, indexed, cb = null) => {
+  let isIndexed = false
+  for (const key of recordData[entity].keys) {
+    if (key.fields.includes(property)) {
+      dataSet[entity] = []
+      if (!indexed.hasOwnProperty(entity)) {
+        indexed[entity] = {}
+      }
+      if (!indexed[entity].hasOwnProperty(property)) {
+        indexed[entity][property] = (await (0, _retrieveIndexes.retrieveIndexes)(entity, [property], recordData))[property]
+      }
+      if (typeof cb === 'function') {
+        await cb(entity, property, recordData, clause, dataSet, indexed)
+      }
+      isIndexed = true
+    }
+  }
+  return isIndexed
+}
+exports.getMatchingIndexes = getMatchingIndexes

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.getMatchingIndexes=void 0,require("core-js/modules/es.array.includes.js");var _retrieveIndexes=require("./retrieveIndexes");const getMatchingIndexes=async(e,r,t,s,n,i,a=null)=>{let d=!1;for(let o of t[e].keys)o.fields.includes(r)&&(n[e]=[],i.hasOwnProperty(e)||(i[e]={}),i[e].hasOwnProperty(r)||(i[e][r]=(await(0,_retrieveIndexes.retrieveIndexes)(e,[r],t))[r]),"function"==typeof a&&await a(e,r,t,s,n,i),d=!0);return d};exports.getMatchingIndexes=getMatchingIndexes;

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

@@ -0,0 +1,2 @@
+export declare const matchIndexedJoins: (entity: any, indexedClone: any, dataSets: any) => (focusEntity: any, property: any, recordData: any, joinClause: any, filterJoins: any, indexed: any) => Promise<void>;
+//# sourceMappingURL=matchIndexedJoins.d.ts.map

package/dist/data/utilities/matchIndexedJoins.js

@@ -0,0 +1,61 @@
+'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')
+const _siFunciona = _interopRequireDefault(require('si-funciona'))
+const _where = require('../queries/where')
+const _retrieveFile = require('./retrieveFile')
+const _splitEntityProperty = require('./parsers/splitEntityProperty')
+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 (!indexedClone.hasOwnProperty(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
+    })), [])
+    const skipPush = checkProp.entityFirst === entity
+    if (!dataSets.hasOwnProperty(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

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),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")),_where=require("../queries/where"),_retrieveFile=require("./retrieveFile"),_splitEntityProperty=require("./parsers/splitEntityProperty");function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e}}const matchIndexedJoins=(e,t,r)=>async(i,o,n,s,p,y)=>{const{entity:c,property:u}=(0,_splitEntityProperty.splitEntityProperty)(s.propertyA),{entity:a,property:d}=(0,_splitEntityProperty.splitEntityProperty)(s.propertyB),l=[{entityFirst:c,propertyFirst:u,entitySecond:a,propertySecond:d},{entityFirst:a,propertyFirst:d,entitySecond:c,propertySecond:u}];for(let i of l){t.hasOwnProperty(i.entitySecond)||(t[i.entitySecond]=_siFunciona.default.cloneObject(y[i.entitySecond]));const o=t[i.entitySecond][i.propertySecond].reduce(((e,r)=>_siFunciona.default.mergeArrays(e,(0,_where.where)(t[i.entityFirst][i.propertyFirst],{property:"value",comparator:s.comparator,value:r.value}))),[]);let n=i.entityFirst===e;r.hasOwnProperty(i.entityFirst)||(r[i.entityFirst]=[]);for(let e of o)for(let t of e.record){let e=t;"string"==typeof t&&(e=await(0,_retrieveFile.retrieveFile)(`${i.entityFirst}/${t}`)),n||r[i.entityFirst].push(e),p[i.entityFirst].push(e)}}};exports.matchIndexedJoins=matchIndexedJoins;

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

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

package/dist/data/utilities/mergeJoin.js

@@ -0,0 +1,44 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.mergeJoin = void 0
+require('core-js/modules/esnext.iterator.constructor.js')
+require('core-js/modules/esnext.iterator.map.js')
+const _readEntity = require('../queries/readEntity')
+const _splitEntityProperty = require('./parsers/splitEntityProperty')
+const _where = require('../queries/where')
+const mergeJoin = async (propertyA = '', propertyB = '', dataSets = {}) => {
+  const {
+    entity: entityA,
+    property: propA
+  } = (0, _splitEntityProperty.splitEntityProperty)(propertyA)
+  const {
+    entity: entityB,
+    property: propB
+  } = (0, _splitEntityProperty.splitEntityProperty)(propertyB)
+  dataSets = await (0, _readEntity.readEntity)(entityA, dataSets)
+  dataSets = await (0, _readEntity.readEntity)(entityB, dataSets)
+  dataSets[entityA] = dataSets[entityA].map(dataA => {
+    const matches = (0, _where.where)(dataSets[entityB], {
+      property: propB,
+      comparator: '=',
+      value: dataA[propA]
+    })
+    if (!matches.length) {
+      return dataA
+    }
+    const mergeMatch = matches[0]
+    for (const prop in mergeMatch) {
+      if (prop === propB) {
+        // Skip the condition property since it is irrelevant
+        continue
+      }
+      dataA[`${entityB}.${prop}`] = mergeMatch[prop]
+    }
+    return dataA
+  })
+  return dataSets
+}
+exports.mergeJoin = mergeJoin

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.mergeJoin=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.map.js");var _readEntity=require("../queries/readEntity"),_splitEntityProperty=require("./parsers/splitEntityProperty"),_where=require("../queries/where");const mergeJoin=async(e="",r="",t={})=>{const{entity:i,property:o}=(0,_splitEntityProperty.splitEntityProperty)(e),{entity:n,property:s}=(0,_splitEntityProperty.splitEntityProperty)(r);return t=await(0,_readEntity.readEntity)(i,t),(t=await(0,_readEntity.readEntity)(n,t))[i]=t[i].map((e=>{const r=(0,_where.where)(t[n],{property:s,comparator:"=",value:e[o]});if(!r.length)return e;const i=r[0];for(let r in i)r!==s&&(e[`${n}.${r}`]=i[r]);return e})),t};exports.mergeJoin=mergeJoin;

package/dist/data/utilities/parsers/findCommand.d.ts

@@ -0,0 +1,10 @@
+import { ParsedQuery } from './parseQuery';
+export type ParsedCommand = string | 'delete' | 'insert' | 'read' | 'update';
+export type ParsedEntity = string;
+/**
+ * Extract command clauses from the query.
+ * @param parsed
+ * @param query
+ */
+export declare const findCommand: (parsed: ParsedQuery, query: string) => string;
+//# sourceMappingURL=findCommand.d.ts.map

package/dist/data/utilities/parsers/findCommand.js

@@ -0,0 +1,25 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.findCommand = void 0
+const _removeFromQuery = require('./removeFromQuery')
+const commandMatch = /^(delete|insert|read|update)\s+([a-z0-9_-]+)[\w\n]*/i
+/**
+ * Extract command clauses from the query.
+ * @param parsed
+ * @param query
+ */
+const findCommand = (parsed, query) => {
+  const commandFound = query.match(commandMatch)
+  parsed.command = undefined
+  parsed.entity = undefined
+  if (commandFound) {
+    parsed.command = commandFound[1]
+    parsed.entity = commandFound[2]
+    return (0, _removeFromQuery.removeFromQuery)(commandFound[0], query)
+  }
+  return query
+}
+exports.findCommand = findCommand

package/dist/data/utilities/parsers/findCommand.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.findCommand=void 0;var _removeFromQuery=require("./removeFromQuery");const commandMatch=/^(delete|insert|read|update)\s+([a-z0-9_-]+)[\w\n]*/i,findCommand=(e,o)=>{const m=o.match(commandMatch);return e.command=void 0,e.entity=void 0,m?(e.command=m[1],e.entity=m[2],(0,_removeFromQuery.removeFromQuery)(m[0],o)):o};exports.findCommand=findCommand;

package/dist/data/utilities/parsers/findConditions.d.ts

@@ -0,0 +1,15 @@
+import { LiteralValue } from './parseLiteralValue';
+import { ParsedQuery } from './parseQuery';
+export type ConditionValue = LiteralValue;
+export type ParsedCondition = {
+    property: string;
+    comparator: string;
+    value: ConditionValue;
+};
+/**
+ * Extract condition clauses from the query.
+ * @param parsed
+ * @param query
+ */
+export declare const findConditions: (parsed: ParsedQuery, query: string) => string;
+//# sourceMappingURL=findConditions.d.ts.map