@owlmeans/mongo-resource 0.1.18-rc.8 → 0.1.18

package/tests/criteria.spec.ts

@@ -0,0 +1,116 @@
+import { describe, expect, test } from 'bun:test'
+import { UnsupportedArgumentError } from '@owlmeans/resource'
+import { ObjectId } from 'mongodb'
+
+import { mongoCriteriaHelper } from '../src/utils/criteria.js'
+import type { MongoReference } from '../src/types.js'
+
+const { criteriaToFilter, sortToMongo } = mongoCriteriaHelper
+
+const HEX = '6712abcdef0123456789abcd'
+const OTHER = '6712abcdef0123456789abce'
+
+const refs = (...fields: string[]): Map<string, MongoReference> =>
+  new Map(fields.map(field => [field, { field }]))
+
+describe('criteria translation', () => {
+  test('reads a bare value as equality, a bare array as membership and null as absence', () => {
+    expect(criteriaToFilter({ title: 'a' }, refs())).toEqual({ title: 'a' })
+    expect(criteriaToFilter({ title: ['a', 'b'] }, refs())).toEqual({ title: { $in: ['a', 'b'] } })
+    expect(criteriaToFilter({ title: null }, refs())).toEqual({ title: { $eq: null } })
+  })
+
+  test('skips an undefined value rather than demanding one', () => {
+    /** An untouched filter must never empty a list. */
+    expect(criteriaToFilter({ title: undefined }, refs())).toEqual({})
+    expect(criteriaToFilter(undefined, refs())).toEqual({})
+    expect(criteriaToFilter({ title: 'a', slug: undefined }, refs())).toEqual({ title: 'a' })
+  })
+
+  test('reads sibling fields as a conjunction', () => {
+    expect(criteriaToFilter({ title: 'a', slug: 'b' }, refs())).toEqual({ title: 'a', slug: 'b' })
+  })
+
+  test('passes mongo\'s own operators through and merges them per field', () => {
+    expect(criteriaToFilter({ age: { $gte: 1, $lt: 5 } }, refs())).toEqual({ age: { $gte: 1, $lt: 5 } })
+    expect(criteriaToFilter({ title: { $nin: ['a'] } }, refs())).toEqual({ title: { $nin: ['a'] } })
+  })
+
+  test('answers presence as a comparison against null, the way the other stores do', () => {
+    expect(criteriaToFilter({ slug: { $null: true } }, refs())).toEqual({ slug: { $eq: null } })
+    expect(criteriaToFilter({ slug: { $null: false } }, refs())).toEqual({ slug: { $ne: null } })
+    expect(criteriaToFilter({ slug: { $exists: true } }, refs())).toEqual({ slug: { $ne: null } })
+    expect(criteriaToFilter({ slug: { $exists: false } }, refs())).toEqual({ slug: { $eq: null } })
+  })
+
+  test('turns the text operators into anchored regular expressions', () => {
+    expect(criteriaToFilter({ title: { $like: 'ab_%' } }, refs()))
+      .toEqual({ title: { $regex: '^ab..*$' } })
+    expect(criteriaToFilter({ title: { $ilike: 'a%' } }, refs()))
+      .toEqual({ title: { $regex: '^a.*$', $options: 'i' } })
+    expect(criteriaToFilter({ title: { $startsWith: 'a.b' } }, refs()))
+      .toEqual({ title: { $regex: '^a\\.b' } })
+    expect(criteriaToFilter({ title: { $endsWith: 'a.b' } }, refs()))
+      .toEqual({ title: { $regex: 'a\\.b$' } })
+  })
+
+  test('splits two operators that would claim the same mongo key', () => {
+    expect(criteriaToFilter({ title: { $startsWith: 'a', $endsWith: 'z' } }, refs()))
+      .toEqual({ title: { $regex: '^a' }, $and: [{ title: { $regex: 'z$' } }] })
+  })
+
+  test('turns a range into its bounds and refuses a malformed one', () => {
+    expect(criteriaToFilter({ age: { $between: [1, 5] } }, refs()))
+      .toEqual({ age: { $gte: 1, $lte: 5 } })
+    expect(() => criteriaToFilter({ age: { $between: [1] } }, refs()))
+      .toThrow(UnsupportedArgumentError)
+  })
+
+  test('maps the array operators onto their mongo counterparts', () => {
+    expect(criteriaToFilter({ tags: { $contains: ['a', 'b'] } }, refs()))
+      .toEqual({ tags: { $all: ['a', 'b'] } })
+    expect(criteriaToFilter({ tags: { $overlaps: ['a', 'b'] } }, refs()))
+      .toEqual({ tags: { $in: ['a', 'b'] } })
+    expect(criteriaToFilter({ tags: { $contained: ['a', 'b'] } }, refs()))
+      .toEqual({ tags: { $not: { $elemMatch: { $nin: ['a', 'b'] } }, $ne: null } })
+  })
+
+  test('carries the logical branches over, negating through $nor', () => {
+    expect(criteriaToFilter({ $or: [{ title: 'a' }, { title: 'b' }] }, refs()))
+      .toEqual({ $or: [{ title: 'a' }, { title: 'b' }] })
+    expect(criteriaToFilter({ $and: [{ title: 'a', slug: 'b' }] }, refs()))
+      .toEqual({ $and: [{ title: 'a', slug: 'b' }] })
+    /** Mongo has no top level `$not`. */
+    expect(criteriaToFilter({ $not: { title: 'a' } }, refs()))
+      .toEqual({ $nor: [{ title: 'a' }] })
+  })
+
+  test('refuses an operator this store cannot answer', () => {
+    expect(() => criteriaToFilter({ title: { $nope: 1 } }, refs())).toThrow(UnsupportedArgumentError)
+  })
+
+  test('converts ids and declared references on the way through', () => {
+    expect(criteriaToFilter({ id: HEX }, refs())).toEqual({ _id: new ObjectId(HEX) })
+    expect(criteriaToFilter({ ownerId: [HEX, OTHER] }, refs('ownerId')))
+      .toEqual({ ownerId: { $in: [new ObjectId(HEX), new ObjectId(OTHER)] } })
+    expect(criteriaToFilter({ ownerIds: { $contains: [HEX] } }, refs('ownerIds')))
+      .toEqual({ ownerIds: { $all: [new ObjectId(HEX)] } })
+    /** Not a mongo id — probes tolerantly, matching nothing rather than throwing. */
+    expect(criteriaToFilter({ ownerId: 'ext:key' }, refs('ownerId'))).toEqual({ ownerId: 'ext:key' })
+    /** A 24-hex value on a field that was never declared a reference stays a string. */
+    expect(criteriaToFilter({ title: HEX }, refs('ownerId'))).toEqual({ title: HEX })
+  })
+})
+
+describe('sort translation', () => {
+  test('reads a bare field as ascending and maps id onto _id', () => {
+    expect(sortToMongo(['createdAt', { field: 'title', order: 'desc' }, 'id']))
+      .toEqual({ createdAt: 1, title: -1, _id: 1 })
+    expect(sortToMongo([{ field: 'title' }])).toEqual({ title: 1 })
+  })
+
+  test('answers nothing when nothing is asked for', () => {
+    expect(sortToMongo()).toBeUndefined()
+    expect(sortToMongo([])).toBeUndefined()
+  })
+})

package/tests/crud.spec.ts

@@ -1,12 +1,12 @@
 import { afterAll, describe, expect, test } from 'bun:test'
-import { runCleanups } from '@owlmeans/test-integration'
 import { getTestEnv } from './context.js'
+import { cleanupHelper } from '@owlmeans/test-integration'
 
 const env = getTestEnv()
 const it = env.gate.skip ? test.skip : test
 
 afterAll(async () => {
-  await runCleanups()
+  await cleanupHelper.runCleanups()
 })
 
 describe('@owlmeans/mongo-resource — connection round-trip', () => {

package/tests/indexes.spec.ts

@@ -0,0 +1,42 @@
+import { describe, expect, test } from 'bun:test'
+import { mongoIndexUtils } from '../src/utils/indexes.js'
+
+const { indexChanged } = mongoIndexUtils
+
+/**
+ * No gate: this is the pure decision behind `updateIndexes`, and the case that matters needs no
+ * database — an index the server reports back is compared against the declaration it came from.
+ */
+describe('@owlmeans/mongo-resource — index comparison', () => {
+  const declared = { key: { currentJobId: 1 }, sparse: true, unique: true }
+
+  test('the same index reported in the server\'s own option order is unchanged', () => {
+    // What the server answers for exactly this declaration — options in its order, plus `v`.
+    expect(indexChanged({ v: 2, key: { currentJobId: 1 }, unique: true, sparse: true }, declared)).toBe(false)
+  })
+
+  test('fields the server reports rather than the declaration asks for are not a change', () => {
+    const reported = {
+      v: 2, key: { currentJobId: 1 }, unique: true, sparse: true, background: false,
+      collation: { locale: 'en', strength: 2 },
+    }
+    expect(indexChanged(reported, declared)).toBe(false)
+  })
+
+  test('a changed option, a dropped option and a changed key are changes', () => {
+    expect(indexChanged({ v: 2, key: { currentJobId: 1 }, unique: false, sparse: true }, declared)).toBe(true)
+    expect(indexChanged({ v: 2, key: { currentJobId: 1 }, unique: true }, declared)).toBe(true)
+    expect(indexChanged({ v: 2, key: { currentJobId: -1 }, unique: true, sparse: true }, declared)).toBe(true)
+  })
+
+  test('a compound index compares its key in order', () => {
+    const compound = { key: { entityId: 1, createdAt: -1 } }
+    expect(indexChanged({ v: 2, key: { entityId: 1, createdAt: -1 } }, compound)).toBe(false)
+    expect(indexChanged({ v: 2, key: { createdAt: -1, entityId: 1 } }, compound)).toBe(true)
+  })
+
+  test('a text index is never recreated', () => {
+    const text = { v: 2, key: { _fts: 'text', _ftsx: 1 }, weights: { title: 1 }, textIndexVersion: 3 }
+    expect(indexChanged(text, { key: { title: 'text' } })).toBe(false)
+  })
+})

package/tests/refs.spec.ts

@@ -2,11 +2,13 @@ import { describe, expect, test } from 'bun:test'
 import { MisshapedRecord } from '@owlmeans/resource'
 import { ObjectId } from 'mongodb'
 
-import {
+import { mongoRefHelper } from '../src/utils/refs.js'
+import type { MongoReference } from '../src/types.js'
+
+const {
   demarshalReference, demarshalRefs, identityCriteria, isObjectIdHex, marshalCriteria,
   marshalReference, refMigrationName
-} from '../src/utils/refs.js'
-import type { MongoReference } from '../src/types.js'
+} = mongoRefHelper
 
 const HEX = '6712abcdef0123456789abcd'
 const OTHER = '6712abcdef0123456789abce'