json-fs-query 0.1.0

package/src/data/queries/sortBy.test.js

@@ -0,0 +1,131 @@
+import { sortBy } from './sortBy'
+
+describe('sortBy', () => {
+  test('applies sorting', () => {
+    const dataSet = [
+      {
+        _id: 2,
+        exercise_id: 2,
+        weight_effort: '155lbs',
+        reps: 10,
+        sets: 3,
+        note: '',
+        order: 1,
+        date: '2024-06-02'
+      },
+      {
+        _id: 1,
+        exercise_id: 1,
+        weight_effort: '115lbs',
+        reps: 10,
+        sets: 3,
+        note: '',
+        order: 0,
+        date: '2024-06-02'
+      },
+      {
+        _id: 1,
+        exercise_id: 1,
+        weight_effort: '115lbs',
+        reps: 10,
+        sets: 3,
+        note: '',
+        order: 0,
+        date: '2024-06-05'
+      },
+      {
+        _id: 3,
+        exercise_id: 3,
+        weight_effort: '155lbs',
+        reps: 10,
+        sets: 3,
+        note: '',
+        order: 2,
+        date: '2024-06-02'
+      },
+      {
+        _id: 2,
+        exercise_id: 2,
+        weight_effort: '155lbs',
+        reps: 10,
+        sets: 3,
+        note: '',
+        order: 1,
+        date: '2024-06-05'
+      },
+      {
+        _id: 3,
+        exercise_id: 3,
+        weight_effort: '155lbs',
+        reps: 10,
+        sets: 3,
+        note: '',
+        order: 2,
+        date: '2024-06-05'
+      }
+    ]
+    const result = sortBy(dataSet, [{ property: 'date', direction: 'desc' }, { property: 'order', direction: 'asc' }])
+    expect(result).toEqual([
+      {
+        _id: 1,
+        exercise_id: 1,
+        weight_effort: '115lbs',
+        reps: 10,
+        sets: 3,
+        note: '',
+        order: 0,
+        date: '2024-06-05'
+      },
+      {
+        _id: 2,
+        exercise_id: 2,
+        weight_effort: '155lbs',
+        reps: 10,
+        sets: 3,
+        note: '',
+        order: 1,
+        date: '2024-06-05'
+      },
+      {
+        _id: 3,
+        exercise_id: 3,
+        weight_effort: '155lbs',
+        reps: 10,
+        sets: 3,
+        note: '',
+        order: 2,
+        date: '2024-06-05'
+      },
+      {
+        _id: 1,
+        exercise_id: 1,
+        weight_effort: '115lbs',
+        reps: 10,
+        sets: 3,
+        note: '',
+        order: 0,
+        date: '2024-06-02'
+      },
+      {
+        _id: 2,
+        exercise_id: 2,
+        weight_effort: '155lbs',
+        reps: 10,
+        sets: 3,
+        note: '',
+        order: 1,
+        date: '2024-06-02'
+      },
+      {
+        _id: 3,
+        exercise_id: 3,
+        weight_effort: '155lbs',
+        reps: 10,
+        sets: 3,
+        note: '',
+        order: 2,
+        date: '2024-06-02'
+      }
+    ])
+  })
+})

package/src/data/queries/sortBy.ts

@@ -0,0 +1,18 @@
+export const sortBy = (dataSet = [], sortClauses = []) => {
+  if (!sortClauses.length) {
+    return dataSet
+  }
+  dataSet.sort((a, b) => {
+    for (let 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
+}

package/src/data/queries/updateEntity.test.js

@@ -0,0 +1,228 @@
+import { create } from '../introspect/create'
+import { insertEntity } from './insertEntity'
+import { updateEntity } from './updateEntity'
+import { testHelpers } from 'js-build-tools/testHelpers'
+
+const { readFile } = require('fs/promises')
+
+const databasePath = 'update-entity-database/'
+const gulpConfig = testHelpers.gulpConfig
+gulpConfig.set('databasePath', databasePath)
+testHelpers.setDefaults(databasePath)
+
+beforeEach(testHelpers.beforeEach)
+
+afterEach(testHelpers.afterEach)
+
+const definition = [
+  { name: '_id', type: 'string', optional: false, autoGenerate: true },
+  { name: 'bar', type: 'string', optional: true, autoGenerate: false },
+  { name: 'note', type: 'string', optional: true, autoGenerate: false }
+]
+
+const keys = [
+  { type: 'primary', fields: ['_id'], lookup: 'pk__id.json' }
+]
+
+describe('updateEntity', () => {
+  test('does nothing when dataSet has no rows to update', async () => {
+    await create('foo', definition, keys)
+    const result = await updateEntity('foo', { bar: 'changed' }, { foo: [] })
+    expect(result).toEqual({ foo: [] })
+  })
+
+  test('throws when the record has no single-field primary key', async () => {
+    await create('foo', definition, [])
+    await expect(updateEntity('foo', { bar: 'x' }, { foo: [{ _id: '1' }] }))
+      .rejects.toThrow('Cannot update "foo" without a single-field primary key')
+  })
+
+  test('throws when no entry matches the row being updated', async () => {
+    await create('foo', definition, keys)
+    await expect(updateEntity('foo', { bar: 'x' }, { foo: [{ _id: 'missing' }] }))
+      .rejects.toThrow('Could not find entry for foo where "_id" = missing')
+  })
+
+  test('merges the given values onto the existing entry file, leaving other fields intact', async () => {
+    await create('foo', definition, keys)
+    const inserted = await insertEntity('foo', [{ bar: 'one', note: 'keep me' }], {})
+    const row = inserted.foo[0]
+
+    const result = await updateEntity('foo', { bar: 'updated' }, { foo: [row] })
+
+    expect(result.foo).toEqual([{ _id: row._id, bar: 'updated', note: 'keep me' }])
+    const onDisk = JSON.parse(await readFile(`${databasePath}foo/${row._id}.json`, 'utf8'))
+    expect(onDisk).toEqual({ _id: row._id, bar: 'updated', note: 'keep me' })
+  })
+
+  test('finds the right file to update even when a filename does not match the primary key', async () => {
+    await create('foo', definition, keys)
+    const inserted = await insertEntity('foo', [{ bar: 'one' }], {})
+    const row = inserted.foo[0]
+    const { rename, writeFile } = require('fs/promises')
+    await rename(`${databasePath}foo/${row._id}.json`, `${databasePath}foo/custom-name.json`)
+    const recordFile = JSON.parse(await readFile(`${databasePath}foo.json`, 'utf8'))
+    recordFile.entries = ['custom-name.json']
+    await writeFile(`${databasePath}foo.json`, JSON.stringify(recordFile))
+
+    const result = await updateEntity('foo', { bar: 'moved' }, { foo: [row] })
+    expect(result.foo[0].bar).toBe('moved')
+    const onDisk = JSON.parse(await readFile(`${databasePath}foo/custom-name.json`, 'utf8'))
+    expect(onDisk.bar).toBe('moved')
+  })
+
+  test('throws when the update would remove a required field', async () => {
+    const definitionRequiringBar = [
+      { name: '_id', type: 'string', optional: false, autoGenerate: true },
+      { name: 'bar', type: 'string', optional: false, autoGenerate: false }
+    ]
+    await create('foo', definitionRequiringBar, keys)
+    const inserted = await insertEntity('foo', [{ bar: 'one' }], {})
+    await expect(updateEntity('foo', { bar: undefined }, { foo: [inserted.foo[0]] }))
+      .rejects.toThrow('Missing required field "bar" for foo')
+  })
+
+  test('moves a changed unique key value to a new index entry', async () => {
+    const uniqueDefinition = [
+      { name: '_id', type: 'string', optional: false, autoGenerate: true },
+      { name: 'email', type: 'string', optional: false, autoGenerate: false }
+    ]
+    const uniqueKeys = [
+      { type: 'primary', fields: ['_id'], lookup: 'pk__id.json' },
+      { type: 'unique', fields: ['email'], lookup: 'unique_email.json' }
+    ]
+    await create('foo', uniqueDefinition, uniqueKeys)
+    const inserted = await insertEntity('foo', [{ email: 'old@example.com' }], {})
+    const row = inserted.foo[0]
+
+    await updateEntity('foo', { email: 'new@example.com' }, { foo: [row] })
+
+    const emailIndex = JSON.parse(await readFile(`${databasePath}__indexes/foo/unique_email.json`, 'utf8'))
+    expect(emailIndex).toEqual([{ value: 'new@example.com', record: [`${row._id}.json`] }])
+  })
+
+  test('rejects an update that collides with another record\'s unique value', async () => {
+    const uniqueDefinition = [
+      { name: '_id', type: 'string', optional: false, autoGenerate: true },
+      { name: 'email', type: 'string', optional: false, autoGenerate: false }
+    ]
+    const uniqueKeys = [
+      { type: 'primary', fields: ['_id'], lookup: 'pk__id.json' },
+      { type: 'unique', fields: ['email'], lookup: 'unique_email.json' }
+    ]
+    await create('foo', uniqueDefinition, uniqueKeys)
+    const inserted = await insertEntity('foo', [{ email: 'first@example.com' }, { email: 'second@example.com' }], {})
+
+    await expect(updateEntity('foo', { email: 'second@example.com' }, { foo: [inserted.foo[0]] }))
+      .rejects.toThrow('Duplicate value for unique key "email" on foo')
+  })
+
+  test('coerces a value to match its field\'s declared type', async () => {
+    const definitionWithInt = [
+      { name: '_id', type: 'string', optional: false, autoGenerate: true },
+      { name: 'reps', type: 'int', optional: false, autoGenerate: false }
+    ]
+    await create('foo', definitionWithInt, keys)
+    const inserted = await insertEntity('foo', [{ reps: 10 }], {})
+    const result = await updateEntity('foo', { reps: '12' }, { foo: [inserted.foo[0]] })
+    expect(result.foo[0].reps).toBe(12)
+  })
+
+  test('rejects a value that does not match its field\'s declared type', async () => {
+    const definitionWithInt = [
+      { name: '_id', type: 'string', optional: false, autoGenerate: true },
+      { name: 'reps', type: 'int', optional: false, autoGenerate: false }
+    ]
+    await create('foo', definitionWithInt, keys)
+    const inserted = await insertEntity('foo', [{ reps: 10 }], {})
+    await expect(updateEntity('foo', { reps: 'twelve' }, { foo: [inserted.foo[0]] }))
+      .rejects.toThrow('Value "twelve" is not a valid int')
+  })
+
+  test('does not re-validate a field the update never touches, even if it is already stored with a mismatched type', async () => {
+    await create('foo', definition, keys)
+    const inserted = await insertEntity('foo', [{ bar: 'one' }], {})
+    const row = inserted.foo[0]
+    // Simulate data that predates any type checking - _id is declared type "string" but stored
+    // as a real number, exactly like the project's own real fixture data.
+    const { writeFile } = require('fs/promises')
+    await writeFile(`${databasePath}foo/${row._id}.json`, JSON.stringify({ _id: 1, bar: 'one', note: null }))
+
+    const result = await updateEntity('foo', { bar: 'updated' }, { foo: [{ ...row, _id: 1 }] })
+    expect(result.foo[0].bar).toBe('updated')
+    expect(result.foo[0]._id).toBe(1)
+  })
+
+  describe('foreign keys', () => {
+    const exerciseDefinition = [
+      { name: '_id', type: 'string', optional: false, autoGenerate: true },
+      { name: 'name', type: 'string', optional: true, autoGenerate: false }
+    ]
+    const exerciseKeys = [
+      { type: 'primary', fields: ['_id'], lookup: 'pk__id.json' }
+    ]
+    const workoutDefinition = [
+      { name: '_id', type: 'string', optional: false, autoGenerate: true },
+      { name: 'exercise_id', type: 'string', optional: true, autoGenerate: false }
+    ]
+    const workoutKeys = [
+      { type: 'primary', fields: ['_id'], lookup: 'pk__id.json' },
+      {
+        type: 'foreign',
+        fields: ['exercise_id'],
+        lookup: 'fk_exercise_id.json',
+        references: [{ fields: ['exercises._id'], lookup: 'exercises.json' }]
+      }
+    ]
+
+    test('accepts changing a foreign key to a value that exists in the referenced record', async () => {
+      await create('exercises', exerciseDefinition, exerciseKeys)
+      const exercises = await insertEntity('exercises', [{ name: 'Bench Press' }, { name: 'Squat' }], {})
+      await create('workouts', workoutDefinition, workoutKeys)
+      const inserted = await insertEntity('workouts', [{ exercise_id: exercises.exercises[0]._id }], {})
+
+      const result = await updateEntity('workouts', { exercise_id: exercises.exercises[1]._id }, { workouts: [inserted.workouts[0]] })
+      expect(result.workouts[0].exercise_id).toBe(exercises.exercises[1]._id)
+    })
+
+    test('rejects changing a foreign key to a value that does not exist in the referenced record', async () => {
+      await create('exercises', exerciseDefinition, exerciseKeys)
+      const exercises = await insertEntity('exercises', [{ name: 'Bench Press' }], {})
+      await create('workouts', workoutDefinition, workoutKeys)
+      const inserted = await insertEntity('workouts', [{ exercise_id: exercises.exercises[0]._id }], {})
+
+      await expect(updateEntity('workouts', { exercise_id: 'does-not-exist' }, { workouts: [inserted.workouts[0]] }))
+        .rejects.toThrow('Foreign key "exercise_id" on workouts references a nonexistent exercises._id = does-not-exist')
+    })
+
+    test('does not re-check an unchanged foreign key value, even if its referenced record was since removed', async () => {
+      await create('exercises', exerciseDefinition, exerciseKeys)
+      const exercises = await insertEntity('exercises', [{ name: 'Bench Press' }], {})
+      await create('workouts', workoutDefinition, workoutKeys)
+      const inserted = await insertEntity('workouts', [{ exercise_id: exercises.exercises[0]._id }], {})
+
+      const { rm } = require('fs/promises')
+      await rm(`${databasePath}exercises/${exercises.exercises[0]._id}.json`)
+
+      const result = await updateEntity('workouts', { exercise_id: exercises.exercises[0]._id }, { workouts: [inserted.workouts[0]] })
+      expect(result.workouts[0].exercise_id).toBe(exercises.exercises[0]._id)
+    })
+  })
+
+  test('re-updating a row to its own existing unique value does not falsely collide', async () => {
+    const uniqueDefinition = [
+      { name: '_id', type: 'string', optional: false, autoGenerate: true },
+      { name: 'email', type: 'string', optional: false, autoGenerate: false }
+    ]
+    const uniqueKeys = [
+      { type: 'primary', fields: ['_id'], lookup: 'pk__id.json' },
+      { type: 'unique', fields: ['email'], lookup: 'unique_email.json' }
+    ]
+    await create('foo', uniqueDefinition, uniqueKeys)
+    const inserted = await insertEntity('foo', [{ email: 'same@example.com' }], {})
+    const row = inserted.foo[0]
+
+    const result = await updateEntity('foo', { email: 'same@example.com' }, { foo: [row] })
+    expect(result.foo[0].email).toBe('same@example.com')
+  })
+})

package/src/data/queries/updateEntity.ts

@@ -0,0 +1,162 @@
+import { retrieveRecord } from '../utilities/retrieveRecord'
+import { retrieveFile } from '../utilities/retrieveFile'
+import { updateIndex } from '../utilities/updateIndex'
+import { removeFromIndex } from '../utilities/removeFromIndex'
+import { keyUnique } from '../introspect/policies/keyUnique'
+import { typeCheck } from '../introspect/policies/typeCheck'
+import { foreignKeyExists } from '../introspect/policies/foreignKeyExists'
+import { splitEntityProperty } from '../utilities/parsers/splitEntityProperty'
+import { recordDefinition } from '../introspect/definitions/record'
+
+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: recordDefinition, primaryField: string, primaryValue: any): Promise<string | null> => {
+  for (const fileName of record.entries) {
+    const data = await 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: string, record: recordDefinition, oldData: Object, newValues: Object): Promise<void> => {
+  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 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: string, record: recordDefinition, oldData: Object, newValues: Object): Promise<void> => {
+  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 } = splitEntityProperty(key.references[0].fields[0])
+    const exists = await 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: recordDefinition, oldData: Object, newData: Object, newValues: Object, fileName: string): Promise<void> => {
+  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 removeFromIndex(record.path, key, oldData[field], fileName)
+    await updateIndex(record.path, key, newData[field], fileName)
+  }
+}
+
+const assertRequiredFields = (entity: string, record: recordDefinition, newData: Object): void => {
+  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: recordDefinition, values: Object): Object => {
+  const typedValues = Object.assign({}, values)
+  for (const field of record.definition) {
+    if (typedValues.hasOwnProperty(field.name)) {
+      typedValues[field.name] = typeCheck(field.type, typedValues[field.name])
+    }
+  }
+  return typedValues
+}
+
+export const updateEntity = async (entity: string = '', values: Object = {}, dataSet: Object = {}): Promise<Object> => {
+  const databasePath = gulpConfig.get('databasePath', 'database/')
+  const record = await 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 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
+}

package/src/data/queries/where.test.js

@@ -0,0 +1,129 @@
+import { where } from './where'
+
+
+const dataSet = [
+  {
+    _id: 1,
+    exercise_id: 1,
+    weight_effort: '115lbs',
+    reps: 10,
+    sets: 3,
+    note: '',
+    date: '2024-06-02'
+  },
+  {
+    _id: 2,
+    exercise_id: 2,
+    weight_effort: '155lbs',
+    reps: 10,
+    sets: 3,
+    note: '',
+    date: '2024-06-02'
+  },
+  {
+    _id: 3,
+    exercise_id: 3,
+    weight_effort: '155lbs',
+    reps: 10,
+    sets: 3,
+    note: '',
+    date: '2024-06-02'
+  }
+]
+
+describe('where', () => {
+  test('will find with given data', () => {
+    const result = where(dataSet, {
+      property: 'date',
+      comparator: '=',
+      value: '2024-06-02'
+    })
+    expect(result).toEqual(dataSet)
+  })
+
+  test('will return no matches', () => {
+    const result = where(dataSet, {
+      property: 'date',
+      comparator: '=',
+      value: '2021-06-02'
+    })
+    expect(result).toEqual([])
+  })
+
+  test('only one match', () => {
+    const result = where(dataSet, {
+      property: 'exercise_id',
+      comparator: '=',
+      value: '2'
+    })
+    expect(result).toEqual([{
+      _id: 2,
+      exercise_id: 2,
+      weight_effort: '155lbs',
+      reps: 10,
+      sets: 3,
+      note: '',
+      date: '2024-06-02'
+    }])
+  })
+
+  test('!= excludes the matching record', () => {
+    const result = where(dataSet, { property: 'exercise_id', comparator: '!=', value: 2 })
+    expect(result.map(r => r._id)).toEqual([1, 3])
+  })
+
+  test('<> excludes the matching record', () => {
+    const result = where(dataSet, { property: 'exercise_id', comparator: '<>', value: 2 })
+    expect(result.map(r => r._id)).toEqual([1, 3])
+  })
+
+  test('> finds records above the value', () => {
+    const result = where(dataSet, { property: 'exercise_id', comparator: '>', value: 1 })
+    expect(result.map(r => r._id)).toEqual([2, 3])
+  })
+
+  test('>= finds records at or above the value', () => {
+    const result = where(dataSet, { property: 'exercise_id', comparator: '>=', value: 2 })
+    expect(result.map(r => r._id)).toEqual([2, 3])
+  })
+
+  test('< finds records below the value', () => {
+    const result = where(dataSet, { property: 'exercise_id', comparator: '<', value: 3 })
+    expect(result.map(r => r._id)).toEqual([1, 2])
+  })
+
+  test('<= finds records at or below the value', () => {
+    const result = where(dataSet, { property: 'exercise_id', comparator: '<=', value: 2 })
+    expect(result.map(r => r._id)).toEqual([1, 2])
+  })
+
+  test('in finds records whose value is in the given list', () => {
+    const result = where(dataSet, { property: 'exercise_id', comparator: 'in', value: [1, 3] })
+    expect(result.map(r => r._id)).toEqual([1, 3])
+  })
+
+  test('in returns no matches when value is not a list', () => {
+    const result = where(dataSet, { property: 'exercise_id', comparator: 'in', value: 1 })
+    expect(result).toEqual([])
+  })
+
+  test('between finds records within the inclusive range', () => {
+    const result = where(dataSet, { property: 'exercise_id', comparator: 'between', value: [2, 3] })
+    expect(result.map(r => r._id)).toEqual([2, 3])
+  })
+
+  test('like matches a % wildcard pattern', () => {
+    const result = where(dataSet, { property: 'weight_effort', comparator: 'like', value: '15%' })
+    expect(result.map(r => r._id)).toEqual([2, 3])
+  })
+
+  test('like matches a _ single-character wildcard', () => {
+    const result = where(dataSet, { property: 'weight_effort', comparator: 'like', value: '1_5lbs' })
+    expect(result.map(r => r._id)).toEqual([1, 2, 3])
+  })
+
+  test('like is case-insensitive and escapes regex-special characters', () => {
+    const result = where(dataSet, { property: 'date', comparator: 'like', value: '2024-06-02' })
+    expect(result).toEqual(dataSet)
+  })
+})