json-fs-query 0.1.0 → 0.1.1

package/src/data/utilities/getJoinIndexedList.ts

@@ -1,53 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,102 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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
-}

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

@@ -1,27 +0,0 @@
-import { removeFromQuery } from './removeFromQuery'
-import { ParsedQuery } from './parseQuery'
-
-const mergeJoinMatch: RegExp = /(and)?\s*merge\s+([a-z0-9_-]+\.[a-z0-9_-]+)\s+with\s+([a-z0-9_-]+\.[a-z0-9_-]+)/ig
-
-export type ParsedMergeJoin = {
-  propertyA: string
-  propertyB: string
-}
-
-/**
- * Extract merge-join clauses from the query.
- * @param parsed
- * @param query
- */
-export const findMergeJoins = (parsed: ParsedQuery, query: string): string => {
-  const mergeJoinsFound: IterableIterator<RegExpMatchArray> = query.matchAll(mergeJoinMatch)
-  // @ts-ignore
-  for (let mergeJoin of mergeJoinsFound) {
-    parsed['mergeJoins'].push({
-      propertyA: mergeJoin[2],
-      propertyB: mergeJoin[3]
-    })
-    query = removeFromQuery(mergeJoin[0].trim(), query)
-  }
-  return query
-}

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

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

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

@@ -1,31 +0,0 @@
-import { removeFromQuery } from './removeFromQuery'
-import { ParsedQuery } from './parseQuery'
-
-const selectClausesMatch: RegExp = /select\s+([a-z0-9=._-]+\s*(as\s+)?([a-z0-9_-]+)?)+\s*(,\s*[a-z0-9=._-]+\s*(as\s*[a-z0-9_-]+)?)*/i
-const selectClauseMatch: RegExp = /(select)?\s*,?\s*([a-z0-9=._-]+)\s*(as\s+)?([a-z0-9_-]+)?/ig
-
-export type ParsedSelect = {
-  property: string
-  alias: string | undefined
-}
-
-/**
- * Extract select clauses from the query.
- * @param parsed
- * @param query
- */
-export const findSelects = (parsed: ParsedQuery, query: string): string => {
-  const selectsFound: RegExpMatchArray = query.match(selectClausesMatch)
-  if (selectsFound) {
-    const selectClausesFound: IterableIterator<RegExpMatchArray> = selectsFound[0].matchAll(selectClauseMatch)
-    // @ts-ignore
-    for (let selectClause of selectClausesFound) {
-      parsed['selectClauses'].push({
-        property: selectClause[2],
-        alias: selectClause[4],
-      })
-    }
-    return removeFromQuery(selectsFound[0], query)
-  }
-  return query
-}

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

@@ -1,31 +0,0 @@
-import { removeFromQuery } from './removeFromQuery'
-import { ParsedQuery } from './parseQuery'
-
-const sortMatch: RegExp = /sort\s+([a-z0-9._-]+\s*(asc|desc)?)+\s*(,\s*[a-z0-9._-]+\s*(asc|desc)?)*/i
-const sortRuleMatch: RegExp = /(sort)?\s*,?\s*([a-z0-9._-]+)\s*(asc|desc)?/ig
-
-export type ParsedSortClause = {
-  property: string
-  direction: string | 'asc' | 'desc'
-}
-
-/**
- * Extract sort clauses from the query.
- * @param parsed
- * @param query
- */
-export const findSortClauses = (parsed: ParsedQuery, query: string): string => {
-  const sortFound: RegExpMatchArray = query.match(sortMatch)
-  if (sortFound) {
-    const sortRulesFound: IterableIterator<RegExpMatchArray> = sortFound[0].matchAll(sortRuleMatch)
-    // @ts-ignore
-    for (let sortClause of sortRulesFound) {
-      parsed['sortClauses'].push({
-        property: sortClause[2],
-        direction: sortClause[3] || 'asc',
-      })
-    }
-    return removeFromQuery(sortFound[0], query)
-  }
-  return query
-}

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

@@ -1,37 +0,0 @@
-import { findUpdateValues } from './findUpdateValues'
-
-const parse = (query) => {
-  const parsed = {}
-  const remaining = findUpdateValues(parsed, query)
-  return { parsed, remaining }
-}
-
-describe('findUpdateValues', () => {
-  test('extracts a single assignment', () => {
-    const { parsed, remaining } = parse("update workouts set reps = 12")
-    expect(parsed.updateValues).toEqual({ reps: 12 })
-    expect(remaining).toBe('update workouts')
-  })
-
-  test('extracts multiple comma-separated assignments', () => {
-    const { parsed } = parse("set reps = 12, note = 'done'")
-    expect(parsed.updateValues).toEqual({ reps: 12, note: 'done' })
-  })
-
-  test('stops before a following where clause', () => {
-    const { parsed, remaining } = parse("set reps = 12 where date = '2024-06-02'")
-    expect(parsed.updateValues).toEqual({ reps: 12 })
-    expect(remaining).toBe("where date = '2024-06-02'")
-  })
-
-  test('extracts every literal shape', () => {
-    const { parsed } = parse('set active = true, archived = false, note = null, tags = [1,2,3]')
-    expect(parsed.updateValues).toEqual({ active: true, archived: false, note: null, tags: [1, 2, 3] })
-  })
-
-  test('leaves the query untouched, with an empty updateValues, when there is no set clause', () => {
-    const { parsed, remaining } = parse("read workouts where date = '2024-06-02'")
-    expect(parsed.updateValues).toEqual({})
-    expect(remaining).toBe("read workouts where date = '2024-06-02'")
-  })
-})