@delma/fylo 2.0.1 → 2.1.1

package/tests/integration/aws-s3-files.canary.test.js

@@ -1,22 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import Fylo from '../../src'
-const runCanary = process.env.FYLO_RUN_S3FILES_CANARY === 'true'
-const canaryTest = runCanary ? test : test.skip
-describe('aws s3-files canary', () => {
-    canaryTest('mounted S3 Files root handles a real CRUD cycle', async () => {
-        const collection = `canary_${Date.now()}`
-        const fylo = new Fylo({
-            engine: 's3-files',
-            s3FilesRoot: process.env.FYLO_S3FILES_ROOT
-        })
-        await fylo.createCollection(collection)
-        const id = await fylo.putData(collection, {
-            title: 'canary',
-            tags: ['aws', 's3-files']
-        })
-        const doc = await fylo.getDoc(collection, id).once()
-        expect(doc[id].title).toBe('canary')
-        await fylo.delDoc(collection, id)
-        await fylo.dropCollection(collection)
-    })
-})

package/tests/integration/create.test.js

@@ -1,39 +0,0 @@
-import { test, expect, describe, beforeAll, afterAll, mock } from 'bun:test'
-import Fylo from '../../src'
-import { albumURL, postsURL } from '../data'
-import S3Mock from '../mocks/s3'
-import RedisMock from '../mocks/redis'
-const POSTS = `post`
-const ALBUMS = `album`
-let postsCount = 0
-let albumsCount = 0
-const fylo = new Fylo()
-mock.module('../../src/adapters/s3', () => ({ S3: S3Mock }))
-mock.module('../../src/adapters/redis', () => ({ Redis: RedisMock }))
-beforeAll(async () => {
-    await Promise.all([Fylo.createCollection(POSTS), fylo.executeSQL(`CREATE TABLE ${ALBUMS}`)])
-    try {
-        albumsCount = await fylo.importBulkData(ALBUMS, new URL(albumURL), 100)
-        postsCount = await fylo.importBulkData(POSTS, new URL(postsURL), 100)
-    } catch {
-        await fylo.rollback()
-    }
-})
-afterAll(async () => {
-    await Promise.all([Fylo.dropCollection(POSTS), fylo.executeSQL(`DROP TABLE ${ALBUMS}`)])
-})
-describe('NO-SQL', async () => {
-    test('PUT', async () => {
-        let results = {}
-        for await (const data of Fylo.findDocs(POSTS).collect()) {
-            results = { ...results, ...data }
-        }
-        expect(Object.keys(results).length).toEqual(postsCount)
-    })
-})
-describe('SQL', () => {
-    test('INSERT', async () => {
-        const results = await fylo.executeSQL(`SELECT * FROM ${ALBUMS}`)
-        expect(Object.keys(results).length).toEqual(albumsCount)
-    })
-})

package/tests/integration/delete.test.js

@@ -1,95 +0,0 @@
-import { test, expect, describe, beforeAll, afterAll, mock } from 'bun:test'
-import Fylo from '../../src'
-import { commentsURL, usersURL } from '../data'
-import S3Mock from '../mocks/s3'
-import RedisMock from '../mocks/redis'
-const COMMENTS = `comment`
-const USERS = `user`
-let commentsResults = {}
-let usersResults = {}
-const fylo = new Fylo()
-mock.module('../../src/adapters/s3', () => ({ S3: S3Mock }))
-mock.module('../../src/adapters/redis', () => ({ Redis: RedisMock }))
-beforeAll(async () => {
-    await Promise.all([Fylo.createCollection(COMMENTS), fylo.executeSQL(`CREATE TABLE ${USERS}`)])
-    try {
-        await Promise.all([
-            fylo.importBulkData(COMMENTS, new URL(commentsURL), 100),
-            fylo.importBulkData(USERS, new URL(usersURL), 100)
-        ])
-    } catch {
-        await fylo.rollback()
-    }
-    for await (const data of Fylo.findDocs(COMMENTS, { $limit: 1 }).collect()) {
-        commentsResults = { ...commentsResults, ...data }
-    }
-    usersResults = await fylo.executeSQL(`SELECT * FROM ${USERS} LIMIT 1`)
-})
-afterAll(async () => {
-    await Promise.all([Fylo.dropCollection(COMMENTS), fylo.executeSQL(`DROP TABLE ${USERS}`)])
-})
-describe('NO-SQL', async () => {
-    test('DELETE ONE', async () => {
-        const id = Object.keys(commentsResults).shift()
-        try {
-            await fylo.delDoc(COMMENTS, id)
-        } catch {
-            await fylo.rollback()
-        }
-        commentsResults = {}
-        for await (const data of Fylo.findDocs(COMMENTS).collect()) {
-            commentsResults = { ...commentsResults, ...data }
-        }
-        const idx = Object.keys(commentsResults).findIndex((_id) => _id === id)
-        expect(idx).toEqual(-1)
-    })
-    test('DELETE CLAUSE', async () => {
-        try {
-            await fylo.delDocs(COMMENTS, { $ops: [{ name: { $like: '%et%' } }] })
-        } catch (e) {
-            console.error(e)
-            await fylo.rollback()
-        }
-        commentsResults = {}
-        for await (const data of Fylo.findDocs(COMMENTS, {
-            $ops: [{ name: { $like: '%et%' } }]
-        }).collect()) {
-            commentsResults = { ...commentsResults, ...data }
-        }
-        expect(Object.keys(commentsResults).length).toEqual(0)
-    })
-    test('DELETE ALL', async () => {
-        try {
-            await fylo.delDocs(COMMENTS)
-        } catch {
-            await fylo.rollback()
-        }
-        commentsResults = {}
-        for await (const data of Fylo.findDocs(COMMENTS).collect()) {
-            commentsResults = { ...commentsResults, ...data }
-        }
-        expect(Object.keys(commentsResults).length).toEqual(0)
-    })
-})
-describe('SQL', async () => {
-    test('DELETE CLAUSE', async () => {
-        const name = Object.values(usersResults).shift().name
-        try {
-            await fylo.executeSQL(`DELETE FROM ${USERS} WHERE name = '${name}'`)
-        } catch {
-            await fylo.rollback()
-        }
-        usersResults = await fylo.executeSQL(`SELECT * FROM ${USERS} WHERE name = '${name}'`)
-        const idx = Object.values(usersResults).findIndex((com) => com.name === name)
-        expect(idx).toBe(-1)
-    })
-    test('DELETE ALL', async () => {
-        try {
-            await fylo.executeSQL(`DELETE FROM ${USERS}`)
-        } catch {
-            await fylo.rollback()
-        }
-        usersResults = await fylo.executeSQL(`SELECT * FROM ${USERS}`)
-        expect(Object.keys(usersResults).length).toBe(0)
-    })
-})

package/tests/integration/edge-cases.test.js

@@ -1,158 +0,0 @@
-import { test, expect, describe, beforeAll, afterAll, mock } from 'bun:test'
-import Fylo from '../../src'
-import TTID from '@delma/ttid'
-import S3Mock from '../mocks/s3'
-import RedisMock from '../mocks/redis'
-const COLLECTION = 'ec-test'
-const fylo = new Fylo()
-mock.module('../../src/adapters/s3', () => ({ S3: S3Mock }))
-mock.module('../../src/adapters/redis', () => ({ Redis: RedisMock }))
-beforeAll(async () => {
-    await Fylo.createCollection(COLLECTION)
-})
-afterAll(async () => {
-    await Fylo.dropCollection(COLLECTION)
-})
-describe('NO-SQL', () => {
-    test('GET ONE — non-existent ID returns empty object', async () => {
-        const fakeId = TTID.generate()
-        const result = await Fylo.getDoc(COLLECTION, fakeId).once()
-        expect(Object.keys(result).length).toBe(0)
-    })
-    test('PUT / GET — forward slashes in values round-trip correctly', async () => {
-        const original = {
-            userId: 1,
-            id: 1,
-            title: 'Slash Test',
-            body: 'https://example.com/api/v1/resource'
-        }
-        const _id = await fylo.putData(COLLECTION, original)
-        const result = await Fylo.getDoc(COLLECTION, _id).once()
-        const doc = result[_id]
-        expect(doc.body).toBe(original.body)
-        await fylo.delDoc(COLLECTION, _id)
-    })
-    test('PUT / GET — values with multiple consecutive slashes round-trip correctly', async () => {
-        const original = {
-            userId: 1,
-            id: 2,
-            title: 'Double Slash',
-            body: 'https://cdn.example.com//assets//image.png'
-        }
-        const _id = await fylo.putData(COLLECTION, original)
-        const result = await Fylo.getDoc(COLLECTION, _id).once()
-        expect(result[_id].body).toBe(original.body)
-        await fylo.delDoc(COLLECTION, _id)
-    })
-    test('$ops — multiple conditions act as OR union', async () => {
-        const cleanFylo = new Fylo()
-        const id1 = await cleanFylo.putData(COLLECTION, {
-            userId: 10,
-            id: 100,
-            title: 'Alpha',
-            body: 'first'
-        })
-        const id2 = await cleanFylo.putData(COLLECTION, {
-            userId: 20,
-            id: 200,
-            title: 'Beta',
-            body: 'second'
-        })
-        const results = {}
-        for await (const data of Fylo.findDocs(COLLECTION, {
-            $ops: [{ userId: { $eq: 10 } }, { userId: { $eq: 20 } }]
-        }).collect()) {
-            Object.assign(results, data)
-        }
-        expect(results[id1]).toBeDefined()
-        expect(results[id2]).toBeDefined()
-        await cleanFylo.delDoc(COLLECTION, id1)
-        await cleanFylo.delDoc(COLLECTION, id2)
-    })
-    test('$rename — renames fields in query output', async () => {
-        const cleanFylo = new Fylo()
-        const _id = await cleanFylo.putData(COLLECTION, {
-            userId: 1,
-            id: 300,
-            title: 'Rename Me',
-            body: 'some body'
-        })
-        let renamed = {}
-        for await (const data of Fylo.findDocs(COLLECTION, {
-            $ops: [{ id: { $eq: 300 } }],
-            $rename: { title: 'name' }
-        }).collect()) {
-            renamed = Object.values(data)[0]
-        }
-        expect(renamed.name).toBe('Rename Me')
-        expect(renamed.title).toBeUndefined()
-        await cleanFylo.delDoc(COLLECTION, _id)
-    })
-    test('versioned putData — preserves creation-time prefix in TTID', async () => {
-        const cleanFylo = new Fylo()
-        const _id1 = await cleanFylo.putData(COLLECTION, {
-            userId: 1,
-            id: 400,
-            title: 'Original',
-            body: 'v1'
-        })
-        const _id2 = await cleanFylo.putData(COLLECTION, {
-            [_id1]: { userId: 1, id: 400, title: 'Updated', body: 'v2' }
-        })
-        expect(_id2.split('-')[0]).toBe(_id1.split('-')[0])
-        const result = await Fylo.getDoc(COLLECTION, _id2).once()
-        const doc = result[_id2]
-        expect(doc).toBeDefined()
-        expect(doc.title).toBe('Updated')
-        await cleanFylo.delDoc(COLLECTION, _id1)
-        await cleanFylo.delDoc(COLLECTION, _id2)
-    })
-    test('versioned putData — original version is no longer retrievable by old full TTID', async () => {
-        const cleanFylo = new Fylo()
-        const _id1 = await cleanFylo.putData(COLLECTION, {
-            userId: 1,
-            id: 500,
-            title: 'Old Version',
-            body: 'original'
-        })
-        const _id2 = await cleanFylo.putData(COLLECTION, {
-            [_id1]: { userId: 1, id: 500, title: 'New Version', body: 'updated' }
-        })
-        expect(_id1).not.toBe(_id2)
-        await cleanFylo.delDoc(COLLECTION, _id2)
-    })
-})
-describe('SQL', () => {
-    test('UPDATE ONE — update a single document by querying its unique field', async () => {
-        const cleanFylo = new Fylo()
-        await cleanFylo.putData(COLLECTION, {
-            userId: 1,
-            id: 600,
-            title: 'Before SQL Update',
-            body: 'original'
-        })
-        const updated = await cleanFylo.executeSQL(
-            `UPDATE ${COLLECTION} SET title = 'After SQL Update' WHERE id = 600`
-        )
-        expect(updated).toBe(1)
-        const results = await cleanFylo.executeSQL(
-            `SELECT * FROM ${COLLECTION} WHERE title = 'After SQL Update'`
-        )
-        expect(Object.keys(results).length).toBe(1)
-        expect(Object.values(results)[0].title).toBe('After SQL Update')
-    })
-    test('DELETE ONE — delete a single document by querying its unique field', async () => {
-        const cleanFylo = new Fylo()
-        await cleanFylo.putData(COLLECTION, {
-            userId: 1,
-            id: 700,
-            title: 'Delete Via SQL',
-            body: 'should be removed'
-        })
-        await cleanFylo.executeSQL(`DELETE FROM ${COLLECTION} WHERE title = 'Delete Via SQL'`)
-        const results = await cleanFylo.executeSQL(
-            `SELECT * FROM ${COLLECTION} WHERE title = 'Delete Via SQL'`
-        )
-        expect(Object.keys(results).length).toBe(0)
-    })
-})

package/tests/integration/encryption.test.js

@@ -1,131 +0,0 @@
-import { test, expect, describe, beforeAll, afterAll, mock } from 'bun:test'
-import Fylo from '../../src'
-import S3Mock from '../mocks/s3'
-import RedisMock from '../mocks/redis'
-import { CipherMock } from '../mocks/cipher'
-const COLLECTION = 'encrypted-test'
-const fylo = new Fylo()
-mock.module('../../src/adapters/s3', () => ({ S3: S3Mock }))
-mock.module('../../src/adapters/redis', () => ({ Redis: RedisMock }))
-mock.module('../../src/adapters/cipher', () => ({ Cipher: CipherMock }))
-beforeAll(async () => {
-    await Fylo.createCollection(COLLECTION)
-    await CipherMock.configure('test-secret-key')
-    CipherMock.registerFields(COLLECTION, ['email', 'ssn', 'address'])
-})
-afterAll(async () => {
-    CipherMock.reset()
-    await Fylo.dropCollection(COLLECTION)
-})
-describe('Encryption', () => {
-    let docId
-    test('PUT encrypted document', async () => {
-        docId = await fylo.putData(COLLECTION, {
-            name: 'Alice',
-            email: 'alice@example.com',
-            ssn: '123-45-6789',
-            age: 30
-        })
-        expect(docId).toBeDefined()
-    })
-    test('GET decrypts fields transparently', async () => {
-        const result = await Fylo.getDoc(COLLECTION, docId).once()
-        const doc = Object.values(result)[0]
-        expect(doc.name).toBe('Alice')
-        expect(doc.email).toBe('alice@example.com')
-        expect(doc.ssn).toBe('123-45-6789')
-        expect(doc.age).toBe(30)
-    })
-    test('encrypted values stored in S3 keys are not plaintext', () => {
-        const bucket = S3Mock.getBucketFormat(COLLECTION)
-        expect(bucket).toBeDefined()
-    })
-    test('$eq query works on encrypted field', async () => {
-        let found = false
-        for await (const data of Fylo.findDocs(COLLECTION, {
-            $ops: [{ email: { $eq: 'alice@example.com' } }]
-        }).collect()) {
-            if (typeof data === 'object') {
-                const doc = Object.values(data)[0]
-                expect(doc.email).toBe('alice@example.com')
-                found = true
-            }
-        }
-        expect(found).toBe(true)
-    })
-    test('$ne throws on encrypted field', async () => {
-        try {
-            const iter = Fylo.findDocs(COLLECTION, {
-                $ops: [{ email: { $ne: 'bob@example.com' } }]
-            }).collect()
-            await iter.next()
-            expect(true).toBe(false)
-        } catch (e) {
-            expect(e.message).toContain('not supported on encrypted field')
-        }
-    })
-    test('$gt throws on encrypted field', async () => {
-        try {
-            const iter = Fylo.findDocs(COLLECTION, {
-                $ops: [{ ssn: { $gt: 0 } }]
-            }).collect()
-            await iter.next()
-            expect(true).toBe(false)
-        } catch (e) {
-            expect(e.message).toContain('not supported on encrypted field')
-        }
-    })
-    test('$like throws on encrypted field', async () => {
-        try {
-            const iter = Fylo.findDocs(COLLECTION, {
-                $ops: [{ email: { $like: '%@example.com' } }]
-            }).collect()
-            await iter.next()
-            expect(true).toBe(false)
-        } catch (e) {
-            expect(e.message).toContain('not supported on encrypted field')
-        }
-    })
-    test('non-encrypted fields remain queryable with all operators', async () => {
-        let found = false
-        for await (const data of Fylo.findDocs(COLLECTION, {
-            $ops: [{ name: { $eq: 'Alice' } }]
-        }).collect()) {
-            if (typeof data === 'object') {
-                const doc = Object.values(data)[0]
-                expect(doc.name).toBe('Alice')
-                found = true
-            }
-        }
-        expect(found).toBe(true)
-    })
-    test('nested encrypted field (address.city)', async () => {
-        const id = await fylo.putData(COLLECTION, {
-            name: 'Bob',
-            email: 'bob@example.com',
-            ssn: '987-65-4321',
-            age: 25,
-            address: { city: 'Toronto', zip: 'M5V 2T6' }
-        })
-        const result = await Fylo.getDoc(COLLECTION, id).once()
-        const doc = Object.values(result)[0]
-        expect(doc.address.city).toBe('Toronto')
-        expect(doc.address.zip).toBe('M5V 2T6')
-    })
-    test('UPDATE preserves encryption', async () => {
-        await fylo.patchDoc(COLLECTION, {
-            [docId]: { email: 'alice-new@example.com' }
-        })
-        let found = false
-        for await (const data of Fylo.findDocs(COLLECTION, {
-            $ops: [{ email: { $eq: 'alice-new@example.com' } }]
-        }).collect()) {
-            if (typeof data === 'object') {
-                const doc = Object.values(data)[0]
-                expect(doc.email).toBe('alice-new@example.com')
-                found = true
-            }
-        }
-        expect(found).toBe(true)
-    })
-})

package/tests/integration/export.test.js

@@ -1,46 +0,0 @@
-import { test, expect, describe, beforeAll, afterAll, mock } from 'bun:test'
-import Fylo from '../../src'
-import { postsURL } from '../data'
-import S3Mock from '../mocks/s3'
-import RedisMock from '../mocks/redis'
-const POSTS = 'exp-post'
-const IMPORT_LIMIT = 20
-let importedCount = 0
-const fylo = new Fylo()
-mock.module('../../src/adapters/s3', () => ({ S3: S3Mock }))
-mock.module('../../src/adapters/redis', () => ({ Redis: RedisMock }))
-beforeAll(async () => {
-    await Fylo.createCollection(POSTS)
-    try {
-        importedCount = await fylo.importBulkData(POSTS, new URL(postsURL), IMPORT_LIMIT)
-    } catch {
-        await fylo.rollback()
-    }
-})
-afterAll(async () => {
-    await Fylo.dropCollection(POSTS)
-})
-describe('NO-SQL', () => {
-    test('EXPORT count matches import', async () => {
-        let exported = 0
-        for await (const _doc of Fylo.exportBulkData(POSTS)) {
-            exported++
-        }
-        expect(exported).toBe(importedCount)
-    })
-    test('EXPORT document shape', async () => {
-        for await (const doc of Fylo.exportBulkData(POSTS)) {
-            expect(doc).toHaveProperty('title')
-            expect(doc).toHaveProperty('userId')
-            expect(doc).toHaveProperty('body')
-            break
-        }
-    })
-    test('EXPORT all documents are valid posts', async () => {
-        for await (const doc of Fylo.exportBulkData(POSTS)) {
-            expect(typeof doc.title).toBe('string')
-            expect(typeof doc.userId).toBe('number')
-            expect(doc.userId).toBeGreaterThan(0)
-        }
-    })
-})

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

@@ -1,154 +0,0 @@
-import { test, expect, describe, beforeAll, afterAll, mock } from 'bun:test'
-import Fylo from '../../src'
-import { albumURL, postsURL } from '../data'
-import S3Mock from '../mocks/s3'
-import RedisMock from '../mocks/redis'
-const ALBUMS = 'jm-album'
-const POSTS = 'jm-post'
-const fylo = new Fylo()
-mock.module('../../src/adapters/s3', () => ({ S3: S3Mock }))
-mock.module('../../src/adapters/redis', () => ({ Redis: RedisMock }))
-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)])
-})
-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/migration.test.js

@@ -1,38 +0,0 @@
-import { afterAll, beforeAll, describe, expect, mock, test } from 'bun:test'
-import { mkdtemp, rm } from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-import S3Mock from '../mocks/s3'
-import RedisMock from '../mocks/redis'
-mock.module('../../src/adapters/s3', () => ({ S3: S3Mock }))
-mock.module('../../src/adapters/redis', () => ({ Redis: RedisMock }))
-const { default: Fylo, migrateLegacyS3ToS3Files } = await import('../../src')
-const root = await mkdtemp(path.join(os.tmpdir(), 'fylo-migrate-'))
-const legacyFylo = new Fylo({ engine: 'legacy-s3' })
-const s3FilesFylo = new Fylo({ engine: 's3-files', s3FilesRoot: root })
-const COLLECTION = 'migration-posts'
-describe('legacy-s3 to s3-files migration', () => {
-    beforeAll(async () => {
-        await Fylo.createCollection(COLLECTION)
-        await legacyFylo.putData(COLLECTION, { id: 1, title: 'Alpha' })
-        await legacyFylo.putData(COLLECTION, { id: 2, title: 'Beta' })
-    })
-    afterAll(async () => {
-        await rm(root, { recursive: true, force: true })
-    })
-    test('migrates legacy data and verifies parity', async () => {
-        const summary = await migrateLegacyS3ToS3Files({
-            collections: [COLLECTION],
-            s3FilesRoot: root,
-            verify: true
-        })
-        expect(summary[COLLECTION].migrated).toBe(2)
-        expect(summary[COLLECTION].verified).toBe(true)
-        const migrated = await s3FilesFylo.executeSQL(`SELECT * FROM ${COLLECTION}`)
-        expect(
-            Object.values(migrated)
-                .map((item) => item.title)
-                .sort()
-        ).toEqual(['Alpha', 'Beta'])
-    })
-})