@delma/fylo 1.1.1 → 2.0.0

package/tests/integration/read.test.ts

@@ -1,203 +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 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<_post>(`CREATE TABLE ${POSTS}`)])
-
-    try {
-        count = await fylo.importBulkData<_album>(ALBUMS, new URL(albumURL), 100)
-        await fylo.importBulkData<_post>(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: Record<_ttid, _album> = {}
-
-        for await (const data of Fylo.findDocs<_album>(ALBUMS).collect()) { 
-
-            results = { ...results, ... data as Record<_ttid, _album> }
-        }
-
-        //console.format(results)
-
-        expect(Object.keys(results).length).toBe(count)
-    })
-
-    test("SELECT PARTIAL", async () => {
-
-        let results: Record<_ttid, _album> = {}
-
-        for await (const data of Fylo.findDocs<_album>(ALBUMS, { $select: ["title"] }).collect()) {
-
-            results = { ...results, ... data as Record<_ttid, _album> }
-        }
-
-        //console.format(results)
-        
-        const allAlbums = Object.values(results)
-
-        const onlyTtitle = allAlbums.every(user => user.title && !user.userId)
-
-        expect(onlyTtitle).toBe(true)
-
-    })
-
-    test("GET ONE", async () => {
-
-        const ids: _ttid[] = []
-
-        for await (const data of Fylo.findDocs<_album>(ALBUMS, { $limit: 1, $onlyIds: true }).collect()) {
-
-            ids.push(data as _ttid)
-        }
-
-        const result = await Fylo.getDoc<_album>(ALBUMS, ids[0]).once()
-        
-        const _id = Object.keys(result).shift()!
-
-        expect(ids[0]).toEqual(_id)
-    })
-
-    test("SELECT CLAUSE", async () => {
-
-        let results: Record<_ttid, _album> = {}
-
-        for await (const data of Fylo.findDocs<_album>(ALBUMS, { $ops: [{ userId: { $eq: 2 } }] }).collect()) {
-
-            results = { ...results, ...data as Record<_ttid, _album> }
-        }
-
-        //console.format(results)
-
-        const allAlbums = Object.values(results)
-        
-        const onlyUserId = allAlbums.every(user => user.userId === 2)
-
-        expect(onlyUserId).toBe(true)
-    })
-
-    test("SELECT LIMIT", async () => {
-
-        let results: Record<_ttid, _album> = {}
-
-        for await (const data of Fylo.findDocs<_album>(ALBUMS, { $limit: 5 }).collect()) {
-
-            results = { ...results, ...data as Record<_ttid, _album> }
-        }
-
-        //console.format(results)
-
-        expect(Object.keys(results).length).toBe(5)
-    })
-
-    test("SELECT GROUP BY", async () => {
-
-        let results: Record<_album[keyof _album], Record<_ttid, Partial<_album>>> = {} as Record<_album[keyof _album], Record<_ttid, Partial<_album>>>
-
-        for await (const data of Fylo.findDocs<_album>(ALBUMS, { $groupby: "userId", $onlyIds: true }).collect()) {
-            
-            results = Object.appendGroup(results, (data as unknown as Record<string, Record<string, Record<_ttid, null>>>)) 
-        }
-
-        //console.format(results)
-
-        expect(Object.keys(results).length).toBeGreaterThan(0)
-    })
-
-    test("SELECT JOIN", async () => {
-
-        const results = await Fylo.joinDocs<_album, _post>({ $leftCollection: ALBUMS, $rightCollection: POSTS, $mode: "inner",  $on: { "userId": { $eq: "id" } } }) as Record<`${_ttid}, ${_ttid}`, _album | _post>
-        
-        //console.format(results)
-        
-        expect(Object.keys(results).length).toBeGreaterThan(0)
-    })
-})
-
-describe("SQL", async () => {
-
-    test("SELECT PARTIAL", async () => {
-
-        const results = await fylo.executeSQL<_album>(`SELECT title FROM ${ALBUMS}`) as Record<_ttid, _album>
-        
-        //console.format(results)
-        
-        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<_album>(`SELECT * FROM ${ALBUMS} WHERE user_id = 2`) as Record<_ttid, _album>
-        
-        //console.format(results)
-        
-        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<_album>(`SELECT * FROM ${ALBUMS}`) as Record<_ttid, _album>
-        
-        //console.format(results)
-        
-        expect(Object.keys(results).length).toBe(count)
-    })
-
-    test("SELECT LIMIT", async () => {
-
-        const results = await fylo.executeSQL<_album>(`SELECT * FROM ${ALBUMS} LIMIT 5`) as Record<_ttid, _album>
-        
-        //console.format(results)
-        
-        expect(Object.keys(results).length).toBe(5)
-    })
-
-    test("SELECT GROUP BY", async () => {
-
-        const results = await fylo.executeSQL<_album>(`SELECT * FROM ${ALBUMS} GROUP BY userId`) as unknown as Record<string, Record<keyof _album, Record<_album[keyof _album], _album>>>
-        
-        //console.format(results)
-        
-        expect(Object.keys(results).length).toBeGreaterThan(0)
-    })
-
-    test("SELECT JOIN", async () => {
-
-        const results = await fylo.executeSQL<_album>(`SELECT * FROM ${ALBUMS} INNER JOIN ${POSTS} ON userId = id`) as Record<`${_ttid}, ${_ttid}`, _album | _post>
-        
-        //console.format(results)
-        
-        expect(Object.keys(results).length).toBeGreaterThan(0)
-    })
-})

package/tests/integration/rollback.test.ts

@@ -1,105 +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'
-
-/**
- * Rollback mechanism:
- *   - putKeys() pushes S3.delete ops into the transactions stack
- *   - deleteKeys() pushes S3.put ops (restore) into the stack
- *   - executeRollback() pops and executes them in reverse order
- *
- * After rollback, the written data should no longer be retrievable.
- * After a delete rollback, the deleted data should be restored.
- */
-
-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<_post>(POSTS, {
-            userId: 99,
-            id: 9001,
-            title: 'Rollback Me',
-            body: 'This document should disappear after rollback'
-        })
-
-        // Verify the document was actually written
-        const before = await Fylo.getDoc<_post>(POSTS, _id).once()
-        expect(Object.keys(before).length).toBe(1)
-
-        // Rollback undoes all writes made on this Fylo instance
-        await fylo.rollback()
-
-        const after = await Fylo.getDoc<_post>(POSTS, _id).once()
-        expect(Object.keys(after).length).toBe(0)
-    })
-
-    test("DELETE then rollback — document is restored", async () => {
-
-        // Use a fresh Fylo instance so the transactions stack is clean
-        const freshFylo = new Fylo()
-
-        const _id = await freshFylo.putData<_post>(POSTS, {
-            userId: 99,
-            id: 9002,
-            title: 'Restore Me',
-            body: 'This document should reappear after delete rollback'
-        })
-
-        // Clear the insert transactions so rollback only covers the delete
-        // (call rollback would delete the just-written doc, defeating the purpose)
-        // Instead we use a second instance that has a clean transaction stack
-        const deleteInstance = new Fylo()
-
-        await deleteInstance.delDoc(POSTS, _id)
-
-        // Confirm it's gone
-        const after = await Fylo.getDoc<_post>(POSTS, _id).once()
-        expect(Object.keys(after).length).toBe(0)
-
-        // Rollback the delete — should restore the document
-        await deleteInstance.rollback()
-
-        const restored = await Fylo.getDoc<_post>(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: _post[] = [
-            { 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<_post>(POSTS, batch)
-
-        // Confirm all written
-        const beforeResults = await Promise.all(ids.map(id => Fylo.getDoc<_post>(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<_post>(POSTS, id).once()))
-        expect(afterResults.every(r => Object.keys(r).length === 0)).toBe(true)
-    })
-})

package/tests/integration/update.test.ts

@@ -1,130 +0,0 @@
-import { test, expect, describe, beforeAll, afterAll, mock } from 'bun:test'
-import Fylo from '../../src'
-import { photosURL, todosURL } from '../data'
-import S3Mock from '../mocks/s3'
-import RedisMock from '../mocks/redis'
-
-const PHOTOS = `photo`
-const TODOS = `todo`
-
-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(PHOTOS), fylo.executeSQL<_todo>(`CREATE TABLE ${TODOS}`)])
-
-    try {
-        await fylo.importBulkData<_photo>(PHOTOS, new URL(photosURL), 100)
-        await fylo.importBulkData<_todo>(TODOS, new URL(todosURL), 100)
-    } catch {
-        await fylo.rollback()
-    }
-})
-
-afterAll(async () => {
-    await Promise.all([Fylo.dropCollection(PHOTOS), fylo.executeSQL<_todo>(`DROP TABLE ${TODOS}`)])
-})
-
-describe("NO-SQL", async () => {
-
-    test("UPDATE ONE", async () => {
-
-        const ids: _ttid[] = []
-
-        for await (const data of Fylo.findDocs<_photo>(PHOTOS, { $limit: 1, $onlyIds: true }).collect()) {
-
-            ids.push(data as _ttid)
-        }
-
-        try {
-            await fylo.patchDoc<_photo>(PHOTOS, { [ids.shift() as _ttid]: { title: "All Mighty" }})
-        } catch {
-            await fylo.rollback()
-        }
-
-        let results: Record<_ttid, _photo> = {}
-
-        for await (const data of Fylo.findDocs<_photo>(PHOTOS, { $ops: [{ title: { $eq: "All Mighty" } }]}).collect()) {
-            
-            results = { ...results, ...data as Record<_ttid, _photo> }
-        }
-
-        expect(Object.keys(results).length).toBe(1)
-    })
-
-    test("UPDATE CLAUSE", async () => {
-
-        let count = -1
-
-        try {
-            count = await fylo.patchDocs<_photo>(PHOTOS, { $set: { title: "All Mighti" }, $where: { $ops: [{ title: { $like: "%est%" } }] } })
-        } catch {
-            await fylo.rollback()
-        }
-
-        let results: Record<_ttid, _photo> = {}
-
-        for await (const data of Fylo.findDocs<_photo>(PHOTOS, { $ops: [ { title: { $eq: "All Mighti" } } ] }).collect()) {
-
-            results = { ...results, ...data as Record<_ttid, _photo> }
-        }
-        
-        expect(Object.keys(results).length).toBe(count)
-    })
-
-    test("UPDATE ALL", async () => {
-
-        let count = -1
-
-        try {
-            count = await fylo.patchDocs<_photo>(PHOTOS, { $set: { title: "All Mighter" } })
-        } catch {
-            await fylo.rollback()
-        }
-
-        let results: Record<_ttid, _photo> = {}
-
-        for await (const data of Fylo.findDocs<_photo>(PHOTOS, { $ops: [ { title: { $eq: "All Mighter" } } ] }).collect()) {
-
-            results = { ...results, ...data as Record<_ttid, _photo> }
-        }
-
-        expect(Object.keys(results).length).toBe(count)
-    }, 20000)
-})
-
-describe("SQL", async () => {
-
-    test("UPDATE CLAUSE", async () => {
-
-        let count = -1
-        
-        try {
-            count = await fylo.executeSQL<_todo>(`UPDATE ${TODOS} SET title = 'All Mighty' WHERE title LIKE '%est%'`) as number
-        } catch {
-            await fylo.rollback()
-        }
-
-        const results = await fylo.executeSQL<_todo>(`SELECT * FROM ${TODOS} WHERE title = 'All Mighty'`) as Record<_ttid, _todo>
-        
-        expect(Object.keys(results).length).toBe(count)
-    })
-
-    test("UPDATE ALL", async () => {
-
-        let count = -1
-
-        try {
-            count = await fylo.executeSQL<_todo>(`UPDATE ${TODOS} SET title = 'All Mightier'`) as number
-        } catch {
-            await fylo.rollback()
-        }
-        
-        const results = await fylo.executeSQL<_todo>(`SELECT * FROM ${TODOS} WHERE title = 'All Mightier'`) as Record<_ttid, _todo>
-        
-        expect(Object.keys(results).length).toBe(count)
-    }, 20000)
-})

package/tests/mocks/redis.ts

@@ -1,169 +0,0 @@
-/**
- * No-op Redis mock. All methods are silent no-ops so tests never need a
- * running Redis instance. subscribe yields nothing so listener code paths
- * simply exit immediately.
- */
-export default class RedisMock {
-
-    private static stream: Array<{
-        streamId: string
-        jobId: string
-        collection: string
-        docId: _ttid
-        operation: string
-        claimedBy?: string
-    }> = []
-
-    private static jobs = new Map<string, Record<string, any>>()
-
-    private static docs = new Map<string, Record<string, string>>()
-
-    private static locks = new Map<string, string>()
-
-    private static deadLetters: Array<{ streamId: string, jobId: string, reason?: string, failedAt: number }> = []
-
-    private static nextId = 0
-
-    async publish(_collection: string, _action: 'insert' | 'delete', _keyId: string | _ttid): Promise<void> {}
-
-    async claimTTID(_id: _ttid, _ttlSeconds: number = 10): Promise<boolean> { return true }
-
-    async enqueueWrite(job: Record<string, any>) {
-        RedisMock.jobs.set(job.jobId, { ...job, nextAttemptAt: job.nextAttemptAt ?? Date.now() })
-        RedisMock.docs.set(`fylo:doc:${job.collection}:${job.docId}`, {
-            status: 'queued',
-            lastJobId: job.jobId,
-            updatedAt: String(Date.now())
-        })
-        const streamId = String(++RedisMock.nextId)
-        RedisMock.stream.push({
-            streamId,
-            jobId: job.jobId,
-            collection: job.collection,
-            docId: job.docId,
-            operation: job.operation
-        })
-        return streamId
-    }
-
-    async readWriteJobs(workerId: string, count: number = 1): Promise<Array<{ streamId: string, job: Record<string, any> }>> {
-        const available = RedisMock.stream
-            .filter(entry => !entry.claimedBy)
-            .slice(0, count)
-
-        for(const entry of available) entry.claimedBy = workerId
-
-        return available.map(entry => ({
-            streamId: entry.streamId,
-            job: { ...RedisMock.jobs.get(entry.jobId)! }
-        }))
-    }
-
-    async ackWriteJob(streamId: string) {
-        RedisMock.stream = RedisMock.stream.filter(item => item.streamId !== streamId)
-    }
-
-    async deadLetterWriteJob(streamId: string, job: Record<string, any>, reason?: string) {
-        RedisMock.deadLetters.push({
-            streamId: String(RedisMock.deadLetters.length + 1),
-            jobId: job.jobId,
-            reason,
-            failedAt: Date.now()
-        })
-
-        await this.ackWriteJob(streamId)
-    }
-
-    async claimPendingJobs(workerId: string, _minIdleMs: number = 30_000, count: number = 10) {
-        const pending = RedisMock.stream
-            .filter(entry => entry.claimedBy)
-            .slice(0, count)
-
-        for(const entry of pending) entry.claimedBy = workerId
-
-        return pending.map(entry => ({
-            streamId: entry.streamId,
-            job: { ...RedisMock.jobs.get(entry.jobId)! }
-        }))
-    }
-
-    async setJobStatus(jobId: string, status: string, extra: Record<string, any> = {}) {
-        const job = RedisMock.jobs.get(jobId)
-        if(job) Object.assign(job, extra, { status, updatedAt: Date.now() })
-    }
-
-    async setDocStatus(collection: string, docId: _ttid, status: string, jobId?: string) {
-        const key = `fylo:doc:${collection}:${docId}`
-        const curr = RedisMock.docs.get(key) ?? {}
-        RedisMock.docs.set(key, {
-            ...curr,
-            status,
-            updatedAt: String(Date.now()),
-            ...(jobId ? { lastJobId: jobId } : {})
-        })
-    }
-
-    async getJob(jobId: string): Promise<Record<string, any> | null> {
-        const job = RedisMock.jobs.get(jobId)
-        return job ? { ...job } : null
-    }
-
-    async getDocStatus(collection: string, docId: _ttid): Promise<Record<string, string> | null> {
-        return RedisMock.docs.get(`fylo:doc:${collection}:${docId}`) ?? null
-    }
-
-    async readDeadLetters(count: number = 10) {
-        return RedisMock.deadLetters.slice(0, count).map(item => ({
-            streamId: item.streamId,
-            job: { ...RedisMock.jobs.get(item.jobId)! },
-            reason: item.reason,
-            failedAt: item.failedAt
-        }))
-    }
-
-    async replayDeadLetter(streamId: string) {
-        const item = RedisMock.deadLetters.find(entry => entry.streamId === streamId)
-        if(!item) return null
-
-        const job = RedisMock.jobs.get(item.jobId)
-        if(!job) return null
-
-        const replayed = {
-            ...job,
-            status: 'queued',
-            error: undefined,
-            workerId: undefined,
-            attempts: 0,
-            updatedAt: Date.now(),
-            nextAttemptAt: Date.now()
-        }
-
-        RedisMock.jobs.set(item.jobId, replayed)
-        await this.enqueueWrite(replayed)
-        RedisMock.deadLetters = RedisMock.deadLetters.filter(entry => entry.streamId !== streamId)
-
-        return { ...replayed }
-    }
-
-    async getQueueStats() {
-        return {
-            queued: RedisMock.stream.length,
-            pending: RedisMock.stream.filter(entry => entry.claimedBy).length,
-            deadLetters: RedisMock.deadLetters.length
-        }
-    }
-
-    async acquireDocLock(collection: string, docId: _ttid, jobId: string) {
-        const key = `fylo:lock:${collection}:${docId}`
-        if(RedisMock.locks.has(key)) return false
-        RedisMock.locks.set(key, jobId)
-        return true
-    }
-
-    async releaseDocLock(collection: string, docId: _ttid, jobId: string) {
-        const key = `fylo:lock:${collection}:${docId}`
-        if(RedisMock.locks.get(key) === jobId) RedisMock.locks.delete(key)
-    }
-
-    async *subscribe(_collection: string): AsyncGenerator<never, void, unknown> {}
-}