json-fs-query 0.1.0

package/src/data/queries/where.ts

@@ -0,0 +1,54 @@
+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
+}
+
+export 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)
+  })
+}

package/src/data/utilities/deregisterRecord.test.js

@@ -0,0 +1,26 @@
+import { registerRecord } from './registerRecord'
+import { deregisterRecord } from './deregisterRecord'
+import { testHelpers } from 'js-build-tools/testHelpers'
+
+const databasePath = 'deregister-record-database/'
+const gulpConfig = testHelpers.gulpConfig
+gulpConfig.set('databasePath', databasePath)
+testHelpers.setDefaults(databasePath)
+
+beforeEach(testHelpers.beforeEach)
+
+afterEach(testHelpers.afterEach)
+
+describe('deregisterRecord', () => {
+  test('does nothing when the registry does not exist yet', async () => {
+    const result = await deregisterRecord('foo')
+    expect(result).toBeNull()
+  })
+
+  test('removes a record from the registry, keeping other entries', async () => {
+    await registerRecord('foo')
+    await registerRecord('bar')
+    const result = await deregisterRecord('foo')
+    expect(result.entries).toEqual(['bar.json'])
+  })
+})

package/src/data/utilities/deregisterRecord.ts

@@ -0,0 +1,24 @@
+import { recordDefinition } from '../introspect/definitions/record'
+
+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
+ */
+export const deregisterRecord = async (recordName: string): Promise<recordDefinition | null> => {
+  const databasePath = gulpConfig.get('databasePath', 'database/')
+  const registryPath = `${databasePath}__RECORDS.json`
+  let registry: recordDefinition
+  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
+}

package/src/data/utilities/getConditionIndexedList.ts

@@ -0,0 +1,43 @@
+import { isEntityProperty } from './parsers/isEntityProperty'
+import { splitEntityProperty } from './parsers/splitEntityProperty'
+import { retrieveRecord } from './retrieveRecord'
+import { where } from '../queries/where'
+import { retrieveFile } from './retrieveFile'
+import { ParsedQuery } from './parsers/parseQuery'
+import { getMatchingIndexes } from './getMatchingIndexes'
+
+export const getConditionIndexedList = async (parsed: ParsedQuery, recordData, dataSet) => {
+  let reducedConditions = []
+  for (let condition of parsed.conditions) {
+    let entity = parsed.entity
+    let property = condition.property
+    if (isEntityProperty(property)) {
+      const entityProperty = splitEntityProperty(property)
+      entity = entityProperty.entity
+      property = entityProperty.property
+    }
+    if (!recordData.hasOwnProperty(entity)) {
+      recordData[entity] = await retrieveRecord(entity)
+    }
+    const indexed = {}
+    const retrieveMatchedFiles = async (entity, property, recordData, condition, dataSet, indexed) => {
+      const matchedRecords = where(indexed[entity][property], {
+        property: 'value',
+        comparator: condition.comparator,
+        value: condition.value
+      })
+      for (let matchedRecord of matchedRecords) {
+        for (let file of matchedRecord.record) {
+          dataSet[entity].push(await retrieveFile(`${entity}/${file}`))
+        }
+      }
+    }
+    let isIndexed = await getMatchingIndexes(entity, property, recordData, condition, dataSet, indexed, retrieveMatchedFiles)
+    if (!isIndexed) {
+      reducedConditions.push(condition)
+    }
+  }
+  parsed.conditions = reducedConditions
+  return parsed
+
+}

package/src/data/utilities/getJoinIndexedList.ts

@@ -0,0 +1,53 @@
+import siFunciona from 'si-funciona'
+import { splitEntityProperty } from './parsers/splitEntityProperty'
+import { retrieveRecord } from './retrieveRecord'
+import { ParsedQuery } from './parsers/parseQuery'
+import { getMatchingIndexes } from './getMatchingIndexes'
+import { matchIndexedJoins } from './matchIndexedJoins'
+import { restrictIndexedList } from './restrictIndexedList'
+
+export const getJoinIndexedList = async (parsed: ParsedQuery, recordData, dataSets) => {
+  let 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
+    let filterJoins = {}
+    filterJoins[entity] = [siFunciona.cloneObject(currentEntity)]
+    for (let joinClause of joinClauses) {
+      let indexedClone = siFunciona.cloneObject(indexed)
+      const { entity: entityA, property: propertyA } = splitEntityProperty(joinClause.propertyA)
+      const { entity: entityB, property: propertyB } = splitEntityProperty(joinClause.propertyB)
+
+      // Get the record for the entities A and B, store on the recordData
+      if (!recordData.hasOwnProperty(entityA)) {
+        recordData[entityA] = await retrieveRecord(entityA)
+      }
+      if (!recordData.hasOwnProperty(entityB)) {
+        recordData[entityB] = await retrieveRecord(entityB)
+      }
+
+      indexedClone = restrictIndexedList(joinClause, filterJoins, indexedClone)
+
+      const retrieveMatchedFiles = matchIndexedJoins(entity, indexedClone, dataSets)
+
+      // Check if there are matching keys for the join condition
+      const matchAResult = await getMatchingIndexes(entityA, propertyA, recordData, joinClause, filterJoins, indexed)
+      const matchBResult = await 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
+}

package/src/data/utilities/getMatchingIndexes.ts

@@ -0,0 +1,21 @@
+import { retrieveIndexes } from './retrieveIndexes'
+
+export const getMatchingIndexes = async (entity: string, property: string, recordData: Object, clause: Object, dataSet: Object, indexed: Object, cb: Function = null): Promise<boolean> => {
+  let isIndexed = false
+  for (let 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 retrieveIndexes(entity, [property], recordData))[property]
+      }
+      if (typeof cb === 'function') {
+        await cb(entity, property, recordData, clause, dataSet, indexed)
+      }
+      isIndexed = true
+    }
+  }
+  return isIndexed
+}

package/src/data/utilities/matchIndexedJoins.ts

@@ -0,0 +1,45 @@
+import siFunciona from 'si-funciona'
+import { where } from '../queries/where'
+import { retrieveFile } from './retrieveFile'
+import { splitEntityProperty } from './parsers/splitEntityProperty'
+
+export const matchIndexedJoins = (entity, indexedClone, dataSets) => async (focusEntity, property, recordData, joinClause, filterJoins, indexed) => {
+  const { entity: entityA, property: propertyA } = splitEntityProperty(joinClause.propertyA)
+  const { entity: entityB, property: propertyB } = splitEntityProperty(joinClause.propertyB)
+  const properties = [
+    { entityFirst: entityA, propertyFirst: propertyA, entitySecond: entityB, propertySecond: propertyB },
+    { entityFirst: entityB, propertyFirst: propertyB, entitySecond: entityA, propertySecond: propertyA },
+  ]
+  for (let checkProp of properties) {
+    if (!indexedClone.hasOwnProperty(checkProp.entitySecond)) {
+      indexedClone[checkProp.entitySecond] = siFunciona.cloneObject(indexed[checkProp.entitySecond])
+    }
+    const matchedRecords = indexedClone[checkProp.entitySecond][checkProp.propertySecond].reduce(
+      (dataA, dataB) => siFunciona.mergeArrays(
+        dataA,
+        where(indexedClone[checkProp.entityFirst][checkProp.propertyFirst], {
+          property: 'value',
+          comparator: joinClause.comparator,
+          value: dataB.value
+        })
+      ),
+      []
+    )
+    let skipPush = checkProp.entityFirst === entity
+    if (!dataSets.hasOwnProperty(checkProp.entityFirst)) {
+      dataSets[checkProp.entityFirst] = []
+    }
+    for (let matchedRecord of matchedRecords) {
+      for (let file of matchedRecord.record) {
+        let entityRecord = file
+        if (typeof file === 'string') {
+          entityRecord = await retrieveFile(`${checkProp.entityFirst}/${file}`)
+        }
+        if (!skipPush) {
+          dataSets[checkProp.entityFirst].push(entityRecord)
+        }
+        filterJoins[checkProp.entityFirst].push(entityRecord)
+      }
+    }
+  }
+}

package/src/data/utilities/mergeJoin.test.js

@@ -0,0 +1,102 @@
+import { mergeJoin } from './mergeJoin'
+import { testHelpers } from 'js-build-tools/testHelpers'
+import { copyDatabase } from '../../../test-data/copyDatabase'
+
+const databasePath = 'merge-join-database/'
+const gulpConfig = testHelpers.gulpConfig
+gulpConfig.set('databasePath', databasePath)
+testHelpers.setDefaults(databasePath)
+
+beforeEach(
+  () => testHelpers.beforeEach()
+    .then(() => copyDatabase(databasePath))
+)
+
+afterEach(testHelpers.afterEach)
+
+describe('mergeJoin', () => {
+  test('can combine both entities', async () => {
+    const results = await mergeJoin('workouts.exercise_id', 'exercises._id')
+    expect(results).toEqual({
+      workouts: [
+        {
+          _id: 1,
+          exercise_id: 1,
+          weight_effort: '115lbs',
+          reps: 10,
+          sets: 3,
+          note: '',
+          order: 0,
+          date: '2024-06-02',
+          'exercises.name': 'Bench Press',
+          'exercises.description': ''
+        },
+        {
+          _id: 2,
+          exercise_id: 2,
+          weight_effort: '155lbs',
+          reps: 10,
+          sets: 3,
+          note: '',
+          order: 1,
+          date: '2024-06-02',
+          'exercises.name': 'Deadlift',
+          'exercises.description': ''
+        },
+        {
+          _id: 3,
+          exercise_id: 3,
+          weight_effort: '155lbs',
+          reps: 10,
+          sets: 3,
+          note: '',
+          order: 2,
+          date: '2024-06-02',
+          'exercises.name': 'Squat',
+          'exercises.description': ''
+        },
+        {
+          _id: 4,
+          exercise_id: 1,
+          weight_effort: '120lbs',
+          reps: 10,
+          sets: 3,
+          note: '',
+          order: 0,
+          date: '2024-06-05',
+          'exercises.name': 'Bench Press',
+          'exercises.description': ''
+        },
+        {
+          _id: 5,
+          exercise_id: 2,
+          weight_effort: '160lbs',
+          reps: 10,
+          sets: 3,
+          note: '',
+          order: 1,
+          date: '2024-06-05',
+          'exercises.name': 'Deadlift',
+          'exercises.description': ''
+        },
+        {
+          _id: 6,
+          exercise_id: 3,
+          weight_effort: '160lbs',
+          reps: 10,
+          sets: 3,
+          note: '',
+          order: 2,
+          date: '2024-06-05',
+          'exercises.name': 'Squat',
+          'exercises.description': ''
+        }
+      ],
+      exercises: [
+        { _id: 1, name: 'Bench Press', description: '' },
+        { _id: 2, name: 'Deadlift', description: '' },
+        { _id: 3, name: 'Squat', description: '' }
+      ]
+    })
+  })
+})

package/src/data/utilities/mergeJoin.ts

@@ -0,0 +1,28 @@
+import { readEntity } from '../queries/readEntity'
+import { splitEntityProperty } from './parsers/splitEntityProperty'
+import { where } from '../queries/where'
+
+export const mergeJoin = async (propertyA = '', propertyB = '', dataSets = {}) => {
+  const { entity: entityA, property: propA } = splitEntityProperty(propertyA)
+  const { entity: entityB, property: propB } = splitEntityProperty(propertyB)
+
+  dataSets = await readEntity(entityA, dataSets)
+  dataSets = await readEntity(entityB, dataSets)
+
+  dataSets[entityA] = dataSets[entityA].map((dataA) => {
+    const matches = where(dataSets[entityB], { property: propB, comparator: '=', value: dataA[propA] })
+    if (!matches.length) {
+      return dataA
+    }
+    const mergeMatch = matches[0]
+    for (let prop in mergeMatch) {
+      if (prop === propB) {
+        // Skip the condition property since it is irrelevant
+        continue
+      }
+      dataA[`${entityB}.${prop}`] = mergeMatch[prop]
+    }
+    return dataA
+  })
+  return dataSets
+}

package/src/data/utilities/parsers/findCommand.ts

@@ -0,0 +1,25 @@
+import { removeFromQuery } from './removeFromQuery'
+import { ParsedQuery } from './parseQuery'
+
+const commandMatch: RegExp = /^(delete|insert|read|update)\s+([a-z0-9_-]+)[\w\n]*/i
+
+export type ParsedCommand = string | 'delete' | 'insert' | 'read' | 'update'
+
+export type ParsedEntity = string
+
+/**
+ * Extract command clauses from the query.
+ * @param parsed
+ * @param query
+ */
+export const findCommand = (parsed: ParsedQuery, query: string): string => {
+  const commandFound: RegExpMatchArray = query.match(commandMatch)
+  parsed['command'] = undefined
+  parsed['entity'] = undefined
+  if (commandFound) {
+    parsed['command'] = commandFound[1]
+    parsed['entity'] = commandFound[2]
+    return removeFromQuery(commandFound[0], query)
+  }
+  return query
+}

package/src/data/utilities/parsers/findConditions.test.js

@@ -0,0 +1,38 @@
+import { findConditions } from './findConditions'
+
+const parse = (query) => {
+  const parsed = { conditions: [] }
+  const remaining = findConditions(parsed, query)
+  return { parsed, remaining }
+}
+
+describe('findConditions', () => {
+  test('extracts a quoted string value', () => {
+    const { parsed, remaining } = parse("where date = '2024-06-02'")
+    expect(parsed.conditions).toEqual([{ property: 'date', comparator: '=', value: '2024-06-02' }])
+    expect(remaining).toBe('')
+  })
+
+  test('extracts an unquoted number as a real number', () => {
+    const { parsed } = parse('where reps > 10')
+    expect(parsed.conditions).toEqual([{ property: 'reps', comparator: '>', value: 10 }])
+  })
+
+  test('extracts an array literal as a real array', () => {
+    const { parsed } = parse('where exercise_id in [1,2,3]')
+    expect(parsed.conditions).toEqual([{ property: 'exercise_id', comparator: 'in', value: [1, 2, 3] }])
+  })
+
+  test('extracts null as the real null value', () => {
+    const { parsed } = parse('where note = null')
+    expect(parsed.conditions).toEqual([{ property: 'note', comparator: '=', value: null }])
+  })
+
+  test('extracts true and false as real booleans', () => {
+    const { parsed } = parse('where active = true where archived = false')
+    expect(parsed.conditions).toEqual([
+      { property: 'active', comparator: '=', value: true },
+      { property: 'archived', comparator: '=', value: false }
+    ])
+  })
+})

package/src/data/utilities/parsers/findConditions.ts

@@ -0,0 +1,32 @@
+import { removeFromQuery } from './removeFromQuery'
+import { parseLiteralValue, LiteralValue } from './parseLiteralValue'
+import { ParsedQuery } from './parseQuery'
+
+const conditionMatch: RegExp = /(and|or)?\s*(where)\s+([a-z0-9_-]+\.?[a-z0-9_-]*)\s+(=|!=|>|<|>=|<=|in|between|like)\s+(["'](.*)['"]|([0-9]+)|(\[.*])|(null)|(true)|(false))/ig
+
+export type ConditionValue = LiteralValue
+
+export type ParsedCondition = {
+  property: string
+  comparator: string
+  value: ConditionValue
+}
+
+/**
+ * Extract condition clauses from the query.
+ * @param parsed
+ * @param query
+ */
+export const findConditions = (parsed: ParsedQuery, query: string): string => {
+  const conditionsFound: IterableIterator<RegExpMatchArray> = query.matchAll(conditionMatch)
+  // @ts-ignore
+  for (let condition of conditionsFound) {
+    parsed['conditions'].push({
+      property: condition[3],
+      comparator: condition[4],
+      value: parseLiteralValue(condition, 6)
+    })
+    query = removeFromQuery(condition[0], query)
+  }
+  return query
+}

package/src/data/utilities/parsers/findGroupBy.ts

@@ -0,0 +1,20 @@
+import { removeFromQuery } from './removeFromQuery'
+import { ParsedQuery } from './parseQuery'
+
+const groupMatch: RegExp = /group\s+by\s+(,?[a-z0-9._-]+)+/i
+
+export type ParsedGroupBy = string
+
+/**
+ * Extract the group by clauses from the query.
+ * @param parsed
+ * @param query
+ */
+export const findGroupBy = (parsed: ParsedQuery, query: string): string => {
+  const groupFound: RegExpMatchArray = query.match(groupMatch)
+  if (groupFound) {
+    parsed['groupBy'] = groupFound ? groupFound[1] : undefined
+    return removeFromQuery(groupFound[0], query)
+  }
+  return query
+}

package/src/data/utilities/parsers/findInsertValues.test.js

@@ -0,0 +1,26 @@
+import { findInsertValues } from './findInsertValues'
+
+const parse = (query) => {
+  const parsed = {}
+  const remaining = findInsertValues(parsed, query)
+  return { parsed, remaining }
+}
+
+describe('findInsertValues', () => {
+  test('extracts a single row, wrapped in a one-element array', () => {
+    const { parsed, remaining } = parse("insert workouts values reps = 12, date = '2024-06-02'")
+    expect(parsed.insertValues).toEqual([{ reps: 12, date: '2024-06-02' }])
+    expect(remaining).toBe('insert workouts')
+  })
+
+  test('extracts every literal shape', () => {
+    const { parsed } = parse('values active = true, tags = [1,2,3], note = null')
+    expect(parsed.insertValues).toEqual([{ active: true, tags: [1, 2, 3], note: null }])
+  })
+
+  test('leaves the query untouched, with an empty insertValues, when there is no values clause', () => {
+    const { parsed, remaining } = parse("read workouts where date = '2024-06-02'")
+    expect(parsed.insertValues).toEqual([])
+    expect(remaining).toBe("read workouts where date = '2024-06-02'")
+  })
+})

package/src/data/utilities/parsers/findInsertValues.ts

@@ -0,0 +1,32 @@
+import { removeFromQuery } from './removeFromQuery'
+import { parseLiteralValue } from './parseLiteralValue'
+import { ParsedQuery } from './parseQuery'
+
+const literal = '(?:["\'][^"\']*[\'"]|[0-9]+|\\[.*?]|null|true|false)'
+const valuesClauseMatch: RegExp = new RegExp(`(values)\\s+([a-z0-9_-]+\\s*=\\s*${literal}(?:\\s*,\\s*[a-z0-9_-]+\\s*=\\s*${literal})*)`, 'i')
+const assignmentMatch: RegExp = /([a-z0-9_-]+)\s*=\s*(["'](.*?)['"]|([0-9]+)|(\[.*?])|(null)|(true)|(false))/ig
+
+export type ParsedInsertRow = { [field: string]: any }
+
+/**
+ * Extract an insert's "values field = value, field2 = value2" clause from the query, the same way
+ * findUpdateValues() does for "set". insertEntity() accepts an array of rows for bulk inserts, but
+ * a query string only describes a single row for now - wrapped in a one-element array to match.
+ * @param parsed
+ * @param query
+ */
+export const findInsertValues = (parsed: ParsedQuery, query: string): string => {
+  const clauseFound: RegExpMatchArray = query.match(valuesClauseMatch)
+  parsed['insertValues'] = []
+  if (!clauseFound) {
+    return query
+  }
+  const row = {}
+  const assignmentsFound: IterableIterator<RegExpMatchArray> = clauseFound[2].matchAll(assignmentMatch)
+  // @ts-ignore
+  for (const assignment of assignmentsFound) {
+    row[assignment[1]] = parseLiteralValue(assignment, 3)
+  }
+  parsed['insertValues'] = [row]
+  return removeFromQuery(clauseFound[0], query)
+}

package/src/data/utilities/parsers/findJoinClauses.ts

@@ -0,0 +1,29 @@
+import { removeFromQuery } from './removeFromQuery'
+import { ParsedQuery } from './parseQuery'
+
+const joinClauseMatch: RegExp = /(and)?\s*on\s+([a-z0-9_-]+\.[a-z0-9_-]+)\s+(=|!=|>|<|>=|<=|in|between|like)\s+([a-z0-9_-]+\.[a-z0-9_-]+)/ig
+
+export type ParsedJoinClause = {
+  propertyA: string
+  comparator: string
+  propertyB: string
+}
+
+/**
+ * Extract condition clauses from the query.
+ * @param parsed
+ * @param query
+ */
+export const findJoinClauses = (parsed: ParsedQuery, query: string): string => {
+  const joinClausesFound: IterableIterator<RegExpMatchArray> = query.matchAll(joinClauseMatch)
+  // @ts-ignore
+  for (let joinClause of joinClausesFound) {
+    parsed['joinClauses'].push({
+      propertyA: joinClause[2],
+      comparator: joinClause[3],
+      propertyB: joinClause[4]
+    })
+    query = removeFromQuery(joinClause[0], query)
+  }
+  return query
+}

package/src/data/utilities/parsers/findJoinEntity.ts

@@ -0,0 +1,20 @@
+import { removeFromQuery } from './removeFromQuery'
+import { ParsedQuery } from './parseQuery'
+
+const joinEntityMatch: RegExp = /\.([a-z0-9_-]+)/i
+
+export type ParsedJoinEntity = string
+
+/**
+ * Extract the main join entity from the query.
+ * @param parsed
+ * @param query
+ */
+export const findJoinEntity = (parsed: ParsedQuery, query: string): string => {
+  const joinEntityFound: RegExpMatchArray = query.match(joinEntityMatch)
+  if (joinEntityFound) {
+    parsed['joinEntity'] = joinEntityFound ? joinEntityFound[1] : undefined
+    return removeFromQuery(joinEntityFound[0], query)
+  }
+  return query
+}

package/src/data/utilities/parsers/findLimit.ts

@@ -0,0 +1,20 @@
+import { removeFromQuery } from './removeFromQuery'
+import { ParsedQuery } from './parseQuery'
+
+const limitMatch: RegExp = /limit\s*(\d+)/i
+
+export type ParsedLimit = number
+
+/**
+ * Extract the limit clauses from the query.
+ * @param parsed
+ * @param query
+ */
+export const findLimit = (parsed: ParsedQuery, query: string): string => {
+  const limitFound: RegExpMatchArray = query.match(limitMatch)
+  if (limitFound) {
+    parsed['limit'] = limitFound ? parseInt(limitFound[1]) : undefined
+    return removeFromQuery(limitFound[0], query)
+  }
+  return query
+}