@delma/fylo 1.1.2 → 2.0.1

package/tests/integration/nested.test.js

@@ -0,0 +1,142 @@
+import { test, expect, describe, beforeAll, afterAll, mock } from 'bun:test'
+import Fylo from '../../src'
+import { usersURL } from '../data'
+import S3Mock from '../mocks/s3'
+import RedisMock from '../mocks/redis'
+const USERS = 'nst-user'
+let insertedCount = 0
+let sampleId
+const fylo = new Fylo()
+mock.module('../../src/adapters/s3', () => ({ S3: S3Mock }))
+mock.module('../../src/adapters/redis', () => ({ Redis: RedisMock }))
+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)
+})
+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

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

@@ -2,98 +2,82 @@ import { test, expect, describe, beforeAll, afterAll, mock } from 'bun:test'
 import Fylo from '../../src'
 import S3Mock from '../mocks/s3'
 import RedisMock from '../mocks/redis'
-
 const POSTS = 'queued-post'
-
 mock.module('../../src/adapters/s3', () => ({ S3: S3Mock }))
 mock.module('../../src/adapters/redis', () => ({ Redis: RedisMock }))
-
 const fylo = new Fylo()
-
 beforeAll(async () => {
     await Fylo.createCollection(POSTS)
 })
-
 afterAll(async () => {
     await Fylo.dropCollection(POSTS)
 })
-
 describe('queue writes', () => {
     test('queuePutData enqueues and worker commits insert', async () => {
         const queued = await fylo.queuePutData(POSTS, {
             title: 'Queued Title',
             body: 'Queued Body'
         })
-
         const queuedStatus = await fylo.getJobStatus(queued.jobId)
         expect(queuedStatus?.status).toBe('queued')
-
         const processed = await fylo.processQueuedWrites(1)
         expect(processed).toBe(1)
-
-        const doc = await Fylo.getDoc<_post>(POSTS, queued.docId, false).once()
+        const doc = await Fylo.getDoc(POSTS, queued.docId, false).once()
         expect(Object.keys(doc).length).toBe(1)
     })
-
     test('putData can return immediately when wait is false', async () => {
-        const queued = await fylo.putData(POSTS, {
-            title: 'Async Title',
-            body: 'Async Body'
-        } as _post, { wait: false })
-
+        const queued = await fylo.putData(
+            POSTS,
+            {
+                title: 'Async Title',
+                body: 'Async Body'
+            },
+            { wait: false }
+        )
         expect(typeof queued).toBe('object')
         expect('jobId' in queued).toBe(true)
-
-        const before = await Fylo.getDoc<_post>(POSTS, queued.docId, false).once()
+        const before = await Fylo.getDoc(POSTS, queued.docId, false).once()
         expect(Object.keys(before).length).toBe(0)
-
         const processed = await fylo.processQueuedWrites(1)
         expect(processed).toBe(1)
-
         const stats = await fylo.getQueueStats()
         expect(stats.deadLetters).toBe(0)
-
-        const after = await Fylo.getDoc<_post>(POSTS, queued.docId, false).once()
+        const after = await Fylo.getDoc(POSTS, queued.docId, false).once()
         expect(Object.keys(after).length).toBe(1)
     })
-
     test('failed jobs can be recovered and eventually dead-lettered', async () => {
         const originalExecute = fylo.executeQueuedWrite.bind(fylo)
-        ;(fylo as any).executeQueuedWrite = async () => {
+        fylo.executeQueuedWrite = async () => {
             throw new Error('simulated write failure')
         }
-
         try {
-            const queued = await fylo.putData(POSTS, {
-                title: 'Broken Title',
-                body: 'Broken Body'
-            } as _post, { wait: false })
-
+            const queued = await fylo.putData(
+                POSTS,
+                {
+                    title: 'Broken Title',
+                    body: 'Broken Body'
+                },
+                { wait: false }
+            )
             expect(await fylo.processQueuedWrites(1)).toBe(0)
             expect((await fylo.getJobStatus(queued.jobId))?.status).toBe('failed')
-
             await Bun.sleep(15)
             expect(await fylo.processQueuedWrites(1, true)).toBe(0)
             expect((await fylo.getJobStatus(queued.jobId))?.status).toBe('failed')
-
             await Bun.sleep(25)
             expect(await fylo.processQueuedWrites(1, true)).toBe(0)
             expect((await fylo.getJobStatus(queued.jobId))?.status).toBe('dead-letter')
-
             const deadLetters = await fylo.getDeadLetters()
             expect((await fylo.getQueueStats()).deadLetters).toBeGreaterThan(0)
-            expect(deadLetters.some(item => item.job.jobId === queued.jobId)).toBe(true)
-
-            ;(fylo as any).executeQueuedWrite = originalExecute
-
-            const replayed = await fylo.replayDeadLetter(deadLetters[0]!.streamId)
+            expect(deadLetters.some((item) => item.job.jobId === queued.jobId)).toBe(true)
+            fylo.executeQueuedWrite = originalExecute
+            const replayed = await fylo.replayDeadLetter(deadLetters[0].streamId)
             expect(replayed?.jobId).toBe(queued.jobId)
             expect((await fylo.getQueueStats()).deadLetters).toBe(0)
-
             expect(await fylo.processQueuedWrites(1)).toBe(1)
             expect((await fylo.getJobStatus(queued.jobId))?.status).toBe('committed')
         } finally {
-            ;(fylo as any).executeQueuedWrite = originalExecute
+            fylo.executeQueuedWrite = originalExecute
         }
     })
 })

package/tests/integration/read.test.js

@@ -0,0 +1,119 @@
+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 count = 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(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)])
+})
+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

@@ -0,0 +1,60 @@
+import { test, expect, describe, beforeAll, afterAll, mock } from 'bun:test'
+import Fylo from '../../src'
+import S3Mock from '../mocks/s3'
+import RedisMock from '../mocks/redis'
+const POSTS = 'rb-post'
+const fylo = new Fylo()
+mock.module('../../src/adapters/s3', () => ({ S3: S3Mock }))
+mock.module('../../src/adapters/redis', () => ({ Redis: RedisMock }))
+beforeAll(async () => {
+    await Fylo.createCollection(POSTS)
+})
+afterAll(async () => {
+    await Fylo.dropCollection(POSTS)
+})
+describe('NO-SQL', () => {
+    test('INSERT then rollback — document is not retrievable', async () => {
+        const _id = await fylo.putData(POSTS, {
+            userId: 99,
+            id: 9001,
+            title: 'Rollback Me',
+            body: 'This document should disappear after rollback'
+        })
+        const before = await Fylo.getDoc(POSTS, _id).once()
+        expect(Object.keys(before).length).toBe(1)
+        await fylo.rollback()
+        const after = await Fylo.getDoc(POSTS, _id).once()
+        expect(Object.keys(after).length).toBe(0)
+    })
+    test('DELETE then rollback — document is restored', async () => {
+        const freshFylo = new Fylo()
+        const _id = await freshFylo.putData(POSTS, {
+            userId: 99,
+            id: 9002,
+            title: 'Restore Me',
+            body: 'This document should reappear after delete rollback'
+        })
+        const deleteInstance = new Fylo()
+        await deleteInstance.delDoc(POSTS, _id)
+        const after = await Fylo.getDoc(POSTS, _id).once()
+        expect(Object.keys(after).length).toBe(0)
+        await deleteInstance.rollback()
+        const restored = await Fylo.getDoc(POSTS, _id).once()
+        expect(Object.keys(restored).length).toBe(1)
+        expect(restored[_id].title).toBe('Restore Me')
+    })
+    test('batch INSERT then rollback — all documents are removed', async () => {
+        const batchFylo = new Fylo()
+        const batch = [
+            { userId: 98, id: 9003, title: 'Batch A', body: 'body a' },
+            { userId: 98, id: 9004, title: 'Batch B', body: 'body b' },
+            { userId: 98, id: 9005, title: 'Batch C', body: 'body c' }
+        ]
+        const ids = await batchFylo.batchPutData(POSTS, batch)
+        const beforeResults = await Promise.all(ids.map((id) => Fylo.getDoc(POSTS, id).once()))
+        expect(beforeResults.every((r) => Object.keys(r).length === 1)).toBe(true)
+        await batchFylo.rollback()
+        const afterResults = await Promise.all(ids.map((id) => Fylo.getDoc(POSTS, id).once()))
+        expect(afterResults.every((r) => Object.keys(r).length === 0)).toBe(true)
+    })
+})