@delma/fylo 2.1.0 → 2.1.1

package/tests/integration/join-modes.test.js

@@ -1,154 +0,0 @@
-import { test, expect, describe, beforeAll, afterAll } from 'bun:test'
-import { rm } from 'node:fs/promises'
-import Fylo from '../../src'
-import { albumURL, postsURL } from '../data'
-import { createTestRoot } from '../helpers/root'
-const ALBUMS = 'jm-album'
-const POSTS = 'jm-post'
-const root = await createTestRoot('fylo-join-')
-const fylo = new Fylo({ root })
-beforeAll(async () => {
-    await Promise.all([fylo.createCollection(ALBUMS), fylo.createCollection(POSTS)])
-    try {
-        await Promise.all([
-            fylo.importBulkData(ALBUMS, new URL(albumURL), 100),
-            fylo.importBulkData(POSTS, new URL(postsURL), 100)
-        ])
-    } catch {
-        await fylo.rollback()
-    }
-})
-afterAll(async () => {
-    await Promise.all([fylo.dropCollection(ALBUMS), fylo.dropCollection(POSTS)])
-    await rm(root, { recursive: true, force: true })
-})
-describe('NO-SQL', async () => {
-    test('INNER JOIN — returns only join field values', async () => {
-        const results = await fylo.joinDocs({
-            $leftCollection: ALBUMS,
-            $rightCollection: POSTS,
-            $mode: 'inner',
-            $on: { userId: { $eq: 'userId' } }
-        })
-        const pairs = Object.values(results)
-        expect(pairs.length).toBeGreaterThan(0)
-        for (const pair of pairs) {
-            expect(pair).toHaveProperty('userId')
-            expect(typeof pair.userId).toBe('number')
-        }
-    })
-    test('LEFT JOIN — returns full left-collection document', async () => {
-        const results = await fylo.joinDocs({
-            $leftCollection: ALBUMS,
-            $rightCollection: POSTS,
-            $mode: 'left',
-            $on: { userId: { $eq: 'userId' } }
-        })
-        const docs = Object.values(results)
-        expect(docs.length).toBeGreaterThan(0)
-        for (const doc of docs) {
-            expect(doc).toHaveProperty('title')
-            expect(doc).toHaveProperty('userId')
-        }
-    })
-    test('RIGHT JOIN — returns full right-collection document', async () => {
-        const results = await fylo.joinDocs({
-            $leftCollection: ALBUMS,
-            $rightCollection: POSTS,
-            $mode: 'right',
-            $on: { userId: { $eq: 'userId' } }
-        })
-        const docs = Object.values(results)
-        expect(docs.length).toBeGreaterThan(0)
-        for (const doc of docs) {
-            expect(doc).toHaveProperty('title')
-            expect(doc).toHaveProperty('body')
-            expect(doc).toHaveProperty('userId')
-        }
-    })
-    test('OUTER JOIN — returns merged left + right document', async () => {
-        const results = await fylo.joinDocs({
-            $leftCollection: ALBUMS,
-            $rightCollection: POSTS,
-            $mode: 'outer',
-            $on: { userId: { $eq: 'userId' } }
-        })
-        const docs = Object.values(results)
-        expect(docs.length).toBeGreaterThan(0)
-        for (const doc of docs) {
-            expect(doc).toHaveProperty('userId')
-        }
-    })
-    test('JOIN with $limit — respects the result cap', async () => {
-        const results = await fylo.joinDocs({
-            $leftCollection: ALBUMS,
-            $rightCollection: POSTS,
-            $mode: 'inner',
-            $on: { userId: { $eq: 'userId' } },
-            $limit: 5
-        })
-        expect(Object.keys(results).length).toBe(5)
-    })
-    test('JOIN with $select — only requested fields are returned', async () => {
-        const results = await fylo.joinDocs({
-            $leftCollection: ALBUMS,
-            $rightCollection: POSTS,
-            $mode: 'left',
-            $on: { userId: { $eq: 'userId' } },
-            $select: ['title'],
-            $limit: 10
-        })
-        const docs = Object.values(results)
-        expect(docs.length).toBeGreaterThan(0)
-        for (const doc of docs) {
-            expect(doc).toHaveProperty('title')
-            expect(doc).not.toHaveProperty('userId')
-        }
-    })
-    test('JOIN with $groupby — groups results by field value', async () => {
-        const results = await fylo.joinDocs({
-            $leftCollection: ALBUMS,
-            $rightCollection: POSTS,
-            $mode: 'inner',
-            $on: { userId: { $eq: 'userId' } },
-            $groupby: 'userId'
-        })
-        expect(Object.keys(results).length).toBeGreaterThan(0)
-    })
-    test('JOIN with $onlyIds — returns IDs only', async () => {
-        const results = await fylo.joinDocs({
-            $leftCollection: ALBUMS,
-            $rightCollection: POSTS,
-            $mode: 'inner',
-            $on: { userId: { $eq: 'userId' } },
-            $onlyIds: true,
-            $limit: 10
-        })
-        expect(Array.isArray(results)).toBe(true)
-        expect(results.length).toBeGreaterThan(0)
-    })
-})
-describe('SQL', async () => {
-    test('INNER JOIN', async () => {
-        const results = await fylo.executeSQL(
-            `SELECT * FROM ${ALBUMS} INNER JOIN ${POSTS} ON userId = userId`
-        )
-        expect(Object.keys(results).length).toBeGreaterThan(0)
-    })
-    test('LEFT JOIN', async () => {
-        const results = await fylo.executeSQL(
-            `SELECT * FROM ${ALBUMS} LEFT JOIN ${POSTS} ON userId = userId`
-        )
-        const docs = Object.values(results)
-        expect(docs.length).toBeGreaterThan(0)
-        expect(docs[0]).toHaveProperty('title')
-    })
-    test('RIGHT JOIN', async () => {
-        const results = await fylo.executeSQL(
-            `SELECT * FROM ${ALBUMS} RIGHT JOIN ${POSTS} ON userId = userId`
-        )
-        const docs = Object.values(results)
-        expect(docs.length).toBeGreaterThan(0)
-        expect(docs[0]).toHaveProperty('body')
-    })
-})

package/tests/integration/nested.test.js

@@ -1,144 +0,0 @@
-import { test, expect, describe, beforeAll, afterAll } from 'bun:test'
-import { rm } from 'node:fs/promises'
-import Fylo from '../../src'
-import { usersURL } from '../data'
-import { createTestRoot } from '../helpers/root'
-const USERS = 'nst-user'
-let insertedCount = 0
-let sampleId
-const root = await createTestRoot('fylo-nested-')
-const fylo = new Fylo({ root })
-beforeAll(async () => {
-    await fylo.createCollection(USERS)
-    try {
-        insertedCount = await fylo.importBulkData(USERS, new URL(usersURL))
-    } catch {
-        await fylo.rollback()
-    }
-    for await (const data of fylo.findDocs(USERS, { $limit: 1, $onlyIds: true }).collect()) {
-        sampleId = data
-    }
-})
-afterAll(async () => {
-    await fylo.dropCollection(USERS)
-    await rm(root, { recursive: true, force: true })
-})
-describe('NO-SQL', async () => {
-    test('SELECT ALL — nested documents are returned', async () => {
-        let results = {}
-        for await (const data of fylo.findDocs(USERS).collect()) {
-            results = { ...results, ...data }
-        }
-        expect(Object.keys(results).length).toBe(insertedCount)
-    })
-    test('GET ONE — top-level fields are reconstructed correctly', async () => {
-        const result = await fylo.getDoc(USERS, sampleId).once()
-        const user = result[sampleId]
-        expect(user).toBeDefined()
-        expect(typeof user.name).toBe('string')
-        expect(typeof user.email).toBe('string')
-        expect(typeof user.phone).toBe('string')
-    })
-    test('GET ONE — first-level nested object is reconstructed correctly', async () => {
-        const result = await fylo.getDoc(USERS, sampleId).once()
-        const user = result[sampleId]
-        expect(user.address).toBeDefined()
-        expect(typeof user.address.city).toBe('string')
-        expect(typeof user.address.street).toBe('string')
-        expect(typeof user.address.zipcode).toBe('string')
-    })
-    test('GET ONE — deeply nested object is reconstructed correctly', async () => {
-        const result = await fylo.getDoc(USERS, sampleId).once()
-        const user = result[sampleId]
-        expect(user.address.geo).toBeDefined()
-        expect(typeof user.address.geo.lat).toBe('number')
-        expect(typeof user.address.geo.lng).toBe('number')
-    })
-    test('GET ONE — second nested object is reconstructed correctly', async () => {
-        const result = await fylo.getDoc(USERS, sampleId).once()
-        const user = result[sampleId]
-        expect(user.company).toBeDefined()
-        expect(typeof user.company.name).toBe('string')
-        expect(typeof user.company.catchPhrase).toBe('string')
-        expect(typeof user.company.bs).toBe('string')
-    })
-    test('SELECT — nested values are not corrupted across documents', async () => {
-        for await (const data of fylo.findDocs(USERS).collect()) {
-            const [, user] = Object.entries(data)[0]
-            expect(user.address).toBeDefined()
-            expect(user.address.geo).toBeDefined()
-            expect(typeof user.address.geo.lat).toBe('number')
-            expect(user.company).toBeDefined()
-        }
-    })
-    test('$select — returns only requested top-level fields', async () => {
-        let results = {}
-        for await (const data of fylo.findDocs(USERS, { $select: ['name', 'email'] }).collect()) {
-            results = { ...results, ...data }
-        }
-        const users = Object.values(results)
-        const onlyNameAndEmail = users.every((u) => u.name && u.email && !u.phone && !u.address)
-        expect(onlyNameAndEmail).toBe(true)
-    })
-    test('$eq on nested string field — query by city', async () => {
-        const result = await fylo.getDoc(USERS, sampleId).once()
-        const targetCity = result[sampleId].address.city
-        let results = {}
-        for await (const data of fylo
-            .findDocs(USERS, {
-                $ops: [{ ['address/city']: { $eq: targetCity } }]
-            })
-            .collect()) {
-            results = { ...results, ...data }
-        }
-        const matchingUsers = Object.values(results)
-        const allMatch = matchingUsers.every((u) => u.address.city === targetCity)
-        expect(allMatch).toBe(true)
-        expect(matchingUsers.length).toBeGreaterThan(0)
-    })
-})
-describe('SQL — dot notation', async () => {
-    test('WHERE with dot notation — first-level nested field', async () => {
-        const result = await fylo.getDoc(USERS, sampleId).once()
-        const targetCity = result[sampleId].address.city
-        const results = await fylo.executeSQL(
-            `SELECT * FROM ${USERS} WHERE address.city = '${targetCity}'`
-        )
-        const users = Object.values(results)
-        const allMatch = users.every((u) => u.address.city === targetCity)
-        expect(allMatch).toBe(true)
-        expect(users.length).toBeGreaterThan(0)
-    })
-    test('WHERE with dot notation — deeply nested field', async () => {
-        const result = await fylo.getDoc(USERS, sampleId).once()
-        const targetLat = result[sampleId].address.geo.lat
-        const results = await fylo.executeSQL(
-            `SELECT * FROM ${USERS} WHERE address.geo.lat = '${targetLat}'`
-        )
-        const users = Object.values(results)
-        const allMatch = users.every((u) => u.address.geo.lat === targetLat)
-        expect(allMatch).toBe(true)
-        expect(users.length).toBeGreaterThan(0)
-    })
-    test('WHERE with dot notation — second nested object', async () => {
-        const result = await fylo.getDoc(USERS, sampleId).once()
-        const targetCompany = result[sampleId].company.name
-        const results = await fylo.executeSQL(
-            `SELECT * FROM ${USERS} WHERE company.name = '${targetCompany}'`
-        )
-        const users = Object.values(results)
-        const allMatch = users.every((u) => u.company.name === targetCompany)
-        expect(allMatch).toBe(true)
-        expect(users.length).toBeGreaterThan(0)
-    })
-    test('SELECT with dot notation in WHERE — partial field selection', async () => {
-        const result = await fylo.getDoc(USERS, sampleId).once()
-        const targetCity = result[sampleId].address.city
-        const results = await fylo.executeSQL(
-            `SELECT name, email FROM ${USERS} WHERE address.city = '${targetCity}'`
-        )
-        const users = Object.values(results)
-        expect(users.length).toBeGreaterThan(0)
-        expect(users.every((u) => u.name && u.email && !u.phone)).toBe(true)
-    })
-})

package/tests/integration/operators.test.js

@@ -1,136 +0,0 @@
-import { test, expect, describe, beforeAll, afterAll } from 'bun:test'
-import { rm } from 'node:fs/promises'
-import Fylo from '../../src'
-import { albumURL } from '../data'
-import { createTestRoot } from '../helpers/root'
-const ALBUMS = 'ops-album'
-const root = await createTestRoot('fylo-operators-')
-const fylo = new Fylo({ root })
-beforeAll(async () => {
-    await fylo.createCollection(ALBUMS)
-    try {
-        await fylo.importBulkData(ALBUMS, new URL(albumURL), 100)
-    } catch {
-        await fylo.rollback()
-    }
-})
-afterAll(async () => {
-    await fylo.dropCollection(ALBUMS)
-    await rm(root, { recursive: true, force: true })
-})
-describe('NO-SQL', async () => {
-    test('$ne — excludes matching value', async () => {
-        let results = {}
-        for await (const data of fylo
-            .findDocs(ALBUMS, {
-                $ops: [{ userId: { $ne: 1 } }]
-            })
-            .collect()) {
-            results = { ...results, ...data }
-        }
-        const albums = Object.values(results)
-        const hasUserId1 = albums.some((a) => a.userId === 1)
-        expect(hasUserId1).toBe(false)
-        expect(albums.length).toBe(90)
-    })
-    test('$lt — returns documents where field is less than value', async () => {
-        let results = {}
-        for await (const data of fylo
-            .findDocs(ALBUMS, {
-                $ops: [{ userId: { $lt: 5 } }]
-            })
-            .collect()) {
-            results = { ...results, ...data }
-        }
-        const albums = Object.values(results)
-        const allLessThan5 = albums.every((a) => a.userId < 5)
-        expect(allLessThan5).toBe(true)
-        expect(albums.length).toBe(40)
-    })
-    test('$lte — returns documents where field is less than or equal to value', async () => {
-        let results = {}
-        for await (const data of fylo
-            .findDocs(ALBUMS, {
-                $ops: [{ userId: { $lte: 5 } }]
-            })
-            .collect()) {
-            results = { ...results, ...data }
-        }
-        const albums = Object.values(results)
-        const allLte5 = albums.every((a) => a.userId <= 5)
-        expect(allLte5).toBe(true)
-        expect(albums.length).toBe(50)
-    })
-    test('$gt — returns documents where field is greater than value', async () => {
-        let results = {}
-        for await (const data of fylo
-            .findDocs(ALBUMS, {
-                $ops: [{ userId: { $gt: 5 } }]
-            })
-            .collect()) {
-            results = { ...results, ...data }
-        }
-        const albums = Object.values(results)
-        const allGt5 = albums.every((a) => a.userId > 5)
-        expect(allGt5).toBe(true)
-        expect(albums.length).toBe(50)
-    })
-    test('$gte — returns documents where field is greater than or equal to value', async () => {
-        let results = {}
-        for await (const data of fylo
-            .findDocs(ALBUMS, {
-                $ops: [{ userId: { $gte: 5 } }]
-            })
-            .collect()) {
-            results = { ...results, ...data }
-        }
-        const albums = Object.values(results)
-        const allGte5 = albums.every((a) => a.userId >= 5)
-        expect(allGte5).toBe(true)
-        expect(albums.length).toBe(60)
-    })
-    test('$like — matches substring pattern', async () => {
-        let results = {}
-        for await (const data of fylo
-            .findDocs(ALBUMS, {
-                $ops: [{ title: { $like: '%quidem%' } }]
-            })
-            .collect()) {
-            results = { ...results, ...data }
-        }
-        const albums = Object.values(results)
-        const allMatch = albums.every((a) => a.title.includes('quidem'))
-        expect(allMatch).toBe(true)
-        expect(albums.length).toBeGreaterThan(0)
-    })
-    test('$like — prefix pattern', async () => {
-        let results = {}
-        for await (const data of fylo
-            .findDocs(ALBUMS, {
-                $ops: [{ title: { $like: 'omnis%' } }]
-            })
-            .collect()) {
-            results = { ...results, ...data }
-        }
-        const albums = Object.values(results)
-        const allStartWith = albums.every((a) => a.title.startsWith('omnis'))
-        expect(allStartWith).toBe(true)
-        expect(albums.length).toBeGreaterThan(0)
-    })
-})
-describe('SQL', async () => {
-    test('WHERE != — excludes matching value', async () => {
-        const results = await fylo.executeSQL(`SELECT * FROM ${ALBUMS} WHERE userId != 1`)
-        const albums = Object.values(results)
-        const hasUserId1 = albums.some((a) => a.userId === 1)
-        expect(hasUserId1).toBe(false)
-        expect(albums.length).toBe(90)
-    })
-    test('WHERE LIKE — matches substring pattern', async () => {
-        const results = await fylo.executeSQL(`SELECT * FROM ${ALBUMS} WHERE title LIKE '%quidem%'`)
-        const albums = Object.values(results)
-        const allMatch = albums.every((a) => a.title.includes('quidem'))
-        expect(allMatch).toBe(true)
-        expect(albums.length).toBeGreaterThan(0)
-    })
-})

package/tests/integration/read.test.js

@@ -1,123 +0,0 @@
-import { test, expect, describe, beforeAll, afterAll } from 'bun:test'
-import { rm } from 'node:fs/promises'
-import Fylo from '../../src'
-import { albumURL, postsURL } from '../data'
-import { createTestRoot } from '../helpers/root'
-const POSTS = `post`
-const ALBUMS = `album`
-let count = 0
-const root = await createTestRoot('fylo-read-')
-const fylo = new Fylo({ root })
-beforeAll(async () => {
-    await Promise.all([fylo.createCollection(ALBUMS), fylo.executeSQL(`CREATE TABLE ${POSTS}`)])
-    try {
-        count = await fylo.importBulkData(ALBUMS, new URL(albumURL), 100)
-        await fylo.importBulkData(POSTS, new URL(postsURL), 100)
-    } catch {
-        await fylo.rollback()
-    }
-})
-afterAll(async () => {
-    await Promise.all([fylo.dropCollection(ALBUMS), fylo.dropCollection(POSTS)])
-    await rm(root, { recursive: true, force: true })
-})
-describe('NO-SQL', async () => {
-    test('SELECT ALL', async () => {
-        let results = {}
-        for await (const data of fylo.findDocs(ALBUMS).collect()) {
-            results = { ...results, ...data }
-        }
-        expect(Object.keys(results).length).toBe(count)
-    })
-    test('SELECT PARTIAL', async () => {
-        let results = {}
-        for await (const data of fylo.findDocs(ALBUMS, { $select: ['title'] }).collect()) {
-            results = { ...results, ...data }
-        }
-        const allAlbums = Object.values(results)
-        const onlyTtitle = allAlbums.every((user) => user.title && !user.userId)
-        expect(onlyTtitle).toBe(true)
-    })
-    test('GET ONE', async () => {
-        const ids = []
-        for await (const data of fylo.findDocs(ALBUMS, { $limit: 1, $onlyIds: true }).collect()) {
-            ids.push(data)
-        }
-        const result = await fylo.getDoc(ALBUMS, ids[0]).once()
-        const _id = Object.keys(result).shift()
-        expect(ids[0]).toEqual(_id)
-    })
-    test('SELECT CLAUSE', async () => {
-        let results = {}
-        for await (const data of fylo
-            .findDocs(ALBUMS, {
-                $ops: [{ userId: { $eq: 2 } }]
-            })
-            .collect()) {
-            results = { ...results, ...data }
-        }
-        const allAlbums = Object.values(results)
-        const onlyUserId = allAlbums.every((user) => user.userId === 2)
-        expect(onlyUserId).toBe(true)
-    })
-    test('SELECT LIMIT', async () => {
-        let results = {}
-        for await (const data of fylo.findDocs(ALBUMS, { $limit: 5 }).collect()) {
-            results = { ...results, ...data }
-        }
-        expect(Object.keys(results).length).toBe(5)
-    })
-    test('SELECT GROUP BY', async () => {
-        let results = {}
-        for await (const data of fylo
-            .findDocs(ALBUMS, {
-                $groupby: 'userId',
-                $onlyIds: true
-            })
-            .collect()) {
-            results = Object.appendGroup(results, data)
-        }
-        expect(Object.keys(results).length).toBeGreaterThan(0)
-    })
-    test('SELECT JOIN', async () => {
-        const results = await fylo.joinDocs({
-            $leftCollection: ALBUMS,
-            $rightCollection: POSTS,
-            $mode: 'inner',
-            $on: { userId: { $eq: 'id' } }
-        })
-        expect(Object.keys(results).length).toBeGreaterThan(0)
-    })
-})
-describe('SQL', async () => {
-    test('SELECT PARTIAL', async () => {
-        const results = await fylo.executeSQL(`SELECT title FROM ${ALBUMS}`)
-        const allAlbums = Object.values(results)
-        const onlyTtitle = allAlbums.every((user) => user.title && !user.userId)
-        expect(onlyTtitle).toBe(true)
-    })
-    test('SELECT CLAUSE', async () => {
-        const results = await fylo.executeSQL(`SELECT * FROM ${ALBUMS} WHERE user_id = 2`)
-        const allAlbums = Object.values(results)
-        const onlyUserId = allAlbums.every((user) => user.userId === 2)
-        expect(onlyUserId).toBe(true)
-    })
-    test('SELECT ALL', async () => {
-        const results = await fylo.executeSQL(`SELECT * FROM ${ALBUMS}`)
-        expect(Object.keys(results).length).toBe(count)
-    })
-    test('SELECT LIMIT', async () => {
-        const results = await fylo.executeSQL(`SELECT * FROM ${ALBUMS} LIMIT 5`)
-        expect(Object.keys(results).length).toBe(5)
-    })
-    test('SELECT GROUP BY', async () => {
-        const results = await fylo.executeSQL(`SELECT * FROM ${ALBUMS} GROUP BY userId`)
-        expect(Object.keys(results).length).toBeGreaterThan(0)
-    })
-    test('SELECT JOIN', async () => {
-        const results = await fylo.executeSQL(
-            `SELECT * FROM ${ALBUMS} INNER JOIN ${POSTS} ON userId = id`
-        )
-        expect(Object.keys(results).length).toBeGreaterThan(0)
-    })
-})

package/tests/integration/rollback.test.js

@@ -1,30 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
-import { mkdtemp, rm } from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-import Fylo from '../../src'
-
-const root = await mkdtemp(path.join(os.tmpdir(), 'fylo-rollback-'))
-const POSTS = 'rb-post'
-const fylo = new Fylo({ root })
-
-beforeAll(async () => {
-    await fylo.createCollection(POSTS)
-})
-
-afterAll(async () => {
-    await rm(root, { recursive: true, force: true })
-})
-
-describe('rollback compatibility', () => {
-    test('rollback is a safe no-op in filesystem-first FYLO', async () => {
-        const id = await fylo.putData(POSTS, {
-            title: 'Still here'
-        })
-
-        await expect(fylo.rollback()).resolves.toBeUndefined()
-
-        const after = await fylo.getDoc(POSTS, id).once()
-        expect(after[id].title).toBe('Still here')
-    })
-})

package/tests/integration/s3-files.performance.test.js

@@ -1,75 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
-import { mkdtemp, rm, stat } from 'node:fs/promises'
-import { performance } from 'node:perf_hooks'
-import os from 'node:os'
-import path from 'node:path'
-import Fylo from '../../src'
-
-const runPerf = process.env.FYLO_RUN_PERF_TESTS === 'true'
-
-describe.skipIf(!runPerf)('s3-files engine performance', () => {
-    let root = path.join(os.tmpdir(), `fylo-s3files-perf-${Date.now()}`)
-    const collection = 's3files-perf'
-    let fylo = new Fylo({ root })
-
-    beforeAll(async () => {
-        root = await mkdtemp(root)
-        fylo = new Fylo({ root })
-        await fylo.createCollection(collection)
-    })
-
-    afterAll(async () => {
-        await rm(root, { recursive: true, force: true })
-    })
-
-    test('keeps a single durable index file while querying a large dataset', async () => {
-        const totalDocs = 2000
-        const insertStart = performance.now()
-
-        for (let index = 0; index < totalDocs; index++) {
-            await fylo.putData(collection, {
-                title: `doc-${index}`,
-                group: index % 10,
-                tags: [`tag-${index % 5}`, `batch-${Math.floor(index / 100)}`],
-                meta: { score: index }
-            })
-        }
-
-        const insertMs = performance.now() - insertStart
-
-        const exactStart = performance.now()
-        let exactResults = {}
-        for await (const data of fylo
-            .findDocs(collection, {
-                $ops: [{ title: { $eq: 'doc-1555' } }]
-            })
-            .collect()) {
-            exactResults = { ...exactResults, ...data }
-        }
-        const exactMs = performance.now() - exactStart
-
-        const rangeStart = performance.now()
-        let rangeCount = 0
-        for await (const data of fylo
-            .findDocs(collection, {
-                $ops: [{ ['meta.score']: { $gte: 1900 } }]
-            })
-            .collect()) {
-            rangeCount += Object.keys(data).length
-        }
-        const rangeMs = performance.now() - rangeStart
-
-        const indexFile = path.join(root, collection, '.fylo', 'indexes', `${collection}.idx.json`)
-        const indexStats = await stat(indexFile)
-
-        expect(Object.keys(exactResults)).toHaveLength(1)
-        expect(rangeCount).toBe(100)
-        expect(indexStats.isFile()).toBe(true)
-
-        console.log(
-            `[FYLO perf] docs=${totalDocs} insertMs=${insertMs.toFixed(1)} exactMs=${exactMs.toFixed(
-                1
-            )} rangeMs=${rangeMs.toFixed(1)} indexBytes=${indexStats.size}`
-        )
-    }, 120_000)
-})