@delma/fylo 1.1.2 → 2.0.0

package/tests/integration/delete.test.ts

@@ -1,147 +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: Record<_ttid, _comment> = {}
-let usersResults: Record<_ttid, _user> = {}
-
-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<_post>(`CREATE TABLE ${USERS}`)
-    ])
-
-    try {
-        
-        await Promise.all([
-            fylo.importBulkData<_comment>(COMMENTS, new URL(commentsURL), 100),
-            fylo.importBulkData<_user>(USERS, new URL(usersURL), 100)
-        ])
-
-    } catch {
-        await fylo.rollback()
-    }
-
-    for await (const data of Fylo.findDocs<_comment>(COMMENTS, { $limit: 1 }).collect()) {
-
-        commentsResults = { ...commentsResults, ...data as Record<_ttid, _comment> }
-        
-    }
-
-    usersResults = await fylo.executeSQL<_user>(`SELECT * FROM ${USERS} LIMIT 1`) as Record<_ttid, _user>
-})
-
-afterAll(async () => {
-    await Promise.all([Fylo.dropCollection(COMMENTS), fylo.executeSQL<_user>(`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<_comment>(COMMENTS).collect()) {
-
-            commentsResults = { ...commentsResults, ...data as Record<_ttid, _comment> }
-        }
-
-        const idx = Object.keys(commentsResults).findIndex(_id => _id === id)
-
-        expect(idx).toEqual(-1)
-
-    })
-
-    test("DELETE CLAUSE", async () => {
-
-        try {
-            await fylo.delDocs<_comment>(COMMENTS, { $ops: [ { name: { $like: "%et%" } } ] })
-            //console.log
-        } catch(e) {
-            console.error(e)
-            await fylo.rollback()
-        }
-        
-        commentsResults = {}
-
-        for await (const data of Fylo.findDocs<_comment>(COMMENTS, { $ops: [ { name: { $like: "%et%" } } ] }).collect()) {
-
-            // console.log(data)
-            
-            commentsResults = { ...commentsResults, ...data as Record<_ttid, _comment> }
-        }
-
-        expect(Object.keys(commentsResults).length).toEqual(0)
-    })
-
-    test("DELETE ALL", async () => {
-
-        try {
-            await fylo.delDocs<_comment>(COMMENTS)
-        } catch {
-            await fylo.rollback()
-        }
-
-        commentsResults = {}
-
-        for await (const data of Fylo.findDocs<_comment>(COMMENTS).collect()) {
-
-            commentsResults = { ...commentsResults, ...data as Record<_ttid, _comment> }
-        }
-
-        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<_user>(`DELETE FROM ${USERS} WHERE name = '${name}'`)
-        } catch {
-            await fylo.rollback()
-        } 
-
-        usersResults = await fylo.executeSQL<_user>(`SELECT * FROM ${USERS} WHERE name = '${name}'`) as Record<_ttid, _user>
-        
-        const idx = Object.values(usersResults).findIndex(com => com.name === name)
-
-        expect(idx).toBe(-1)
-    })
-
-    test("DELETE ALL", async () => {
-
-        try {
-            await fylo.executeSQL<_user>(`DELETE FROM ${USERS}`)
-        } catch {
-            await fylo.rollback()
-        }
-
-        usersResults = await fylo.executeSQL<_user>(`SELECT * FROM ${USERS}`) as Record<_ttid, _user>
-
-        expect(Object.keys(usersResults).length).toBe(0)
-    })
-})

package/tests/integration/nested.test.ts

@@ -1,212 +0,0 @@
-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'
-
-/**
- * _user has deeply nested fields:
- *   address.street, address.suite, address.city, address.zipcode
- *   address.geo.lat, address.geo.lng
- *   company.name, company.catchPhrase, company.bs
- *
- * This exercises the recursive branch in Dir.extractKeys and the nested
- * path reconstruction in Dir.constructData.
- */
-
-const USERS = 'nst-user'
-
-let insertedCount = 0
-let sampleId: _ttid
-
-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<_user>(USERS, new URL(usersURL))
-    } catch {
-        await fylo.rollback()
-    }
-
-    for await (const data of Fylo.findDocs<_user>(USERS, { $limit: 1, $onlyIds: true }).collect()) {
-        sampleId = data as _ttid
-    }
-})
-
-afterAll(async () => {
-    await Fylo.dropCollection(USERS)
-})
-
-describe("NO-SQL", async () => {
-
-    test("SELECT ALL — nested documents are returned", async () => {
-
-        let results: Record<_ttid, _user> = {}
-
-        for await (const data of Fylo.findDocs<_user>(USERS).collect()) {
-            results = { ...results, ...data as Record<_ttid, _user> }
-        }
-
-        expect(Object.keys(results).length).toBe(insertedCount)
-    })
-
-    test("GET ONE — top-level fields are reconstructed correctly", async () => {
-
-        const result = await Fylo.getDoc<_user>(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<_user>(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<_user>(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<_user>(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<_user>(USERS).collect()) {
-
-            const [, user] = Object.entries(data as Record<_ttid, _user>)[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: Record<_ttid, _user> = {}
-
-        for await (const data of Fylo.findDocs<_user>(USERS, { $select: ['name', 'email'] }).collect()) {
-            results = { ...results, ...data as Record<_ttid, _user> }
-        }
-
-        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<_user>(USERS, sampleId).once()
-        const targetCity = result[sampleId].address.city
-
-        let results: Record<_ttid, _user> = {}
-
-        for await (const data of Fylo.findDocs<_user>(USERS, {
-            $ops: [{ ['address/city' as keyof _user]: { $eq: targetCity } }]
-        }).collect()) {
-            results = { ...results, ...data as Record<_ttid, _user> }
-        }
-
-        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<_user>(USERS, sampleId).once()
-        const targetCity = result[sampleId].address.city
-
-        const results = await fylo.executeSQL<_user>(
-            `SELECT * FROM ${USERS} WHERE address.city = '${targetCity}'`
-        ) as Record<_ttid, _user>
-
-        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<_user>(USERS, sampleId).once()
-        const targetLat = result[sampleId].address.geo.lat
-
-        const results = await fylo.executeSQL<_user>(
-            `SELECT * FROM ${USERS} WHERE address.geo.lat = '${targetLat}'`
-        ) as Record<_ttid, _user>
-
-        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<_user>(USERS, sampleId).once()
-        const targetCompany = result[sampleId].company.name
-
-        const results = await fylo.executeSQL<_user>(
-            `SELECT * FROM ${USERS} WHERE company.name = '${targetCompany}'`
-        ) as Record<_ttid, _user>
-
-        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<_user>(USERS, sampleId).once()
-        const targetCity = result[sampleId].address.city
-
-        const results = await fylo.executeSQL<_user>(
-            `SELECT name, email FROM ${USERS} WHERE address.city = '${targetCity}'`
-        ) as Record<_ttid, _user>
-
-        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.ts

@@ -1,167 +0,0 @@
-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'
-
-/**
- * Albums from JSONPlaceholder: 100 records, userId 1–10, 10 albums per userId.
- *
- * NOTE: The numeric-range glob generator in query.ts produces digit-by-digit
- * character classes (e.g. $gt:5 → "[6-9]"). This correctly matches single-digit
- * values but misses two-digit values like 10. Tests below assert correct expected
- * values so any regression in the generator is surfaced immediately.
- */
-
-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<_album>(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: Record<_ttid, _album> = {}
-
-        for await (const data of Fylo.findDocs<_album>(ALBUMS, { $ops: [{ userId: { $ne: 1 } }] }).collect()) {
-            results = { ...results, ...data as Record<_ttid, _album> }
-        }
-
-        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: Record<_ttid, _album> = {}
-
-        for await (const data of Fylo.findDocs<_album>(ALBUMS, { $ops: [{ userId: { $lt: 5 } }] }).collect()) {
-            results = { ...results, ...data as Record<_ttid, _album> }
-        }
-
-        const albums = Object.values(results)
-        const allLessThan5 = albums.every(a => a.userId < 5)
-
-        expect(allLessThan5).toBe(true)
-        expect(albums.length).toBe(40) // userId 1,2,3,4 → 4×10
-    })
-
-    test("$lte — returns documents where field is less than or equal to value", async () => {
-
-        let results: Record<_ttid, _album> = {}
-
-        for await (const data of Fylo.findDocs<_album>(ALBUMS, { $ops: [{ userId: { $lte: 5 } }] }).collect()) {
-            results = { ...results, ...data as Record<_ttid, _album> }
-        }
-
-        const albums = Object.values(results)
-        const allLte5 = albums.every(a => a.userId <= 5)
-
-        expect(allLte5).toBe(true)
-        expect(albums.length).toBe(50) // userId 1,2,3,4,5 → 5×10
-    })
-
-    test("$gt — returns documents where field is greater than value", async () => {
-
-        let results: Record<_ttid, _album> = {}
-
-        for await (const data of Fylo.findDocs<_album>(ALBUMS, { $ops: [{ userId: { $gt: 5 } }] }).collect()) {
-            results = { ...results, ...data as Record<_ttid, _album> }
-        }
-
-        const albums = Object.values(results)
-        const allGt5 = albums.every(a => a.userId > 5)
-
-        expect(allGt5).toBe(true)
-        expect(albums.length).toBe(50) // userId 6,7,8,9,10 → 5×10
-    })
-
-    test("$gte — returns documents where field is greater than or equal to value", async () => {
-
-        let results: Record<_ttid, _album> = {}
-
-        for await (const data of Fylo.findDocs<_album>(ALBUMS, { $ops: [{ userId: { $gte: 5 } }] }).collect()) {
-            results = { ...results, ...data as Record<_ttid, _album> }
-        }
-
-        const albums = Object.values(results)
-        const allGte5 = albums.every(a => a.userId >= 5)
-
-        expect(allGte5).toBe(true)
-        expect(albums.length).toBe(60) // userId 5,6,7,8,9,10 → 6×10
-    })
-
-    test("$like — matches substring pattern", async () => {
-
-        let results: Record<_ttid, _album> = {}
-
-        for await (const data of Fylo.findDocs<_album>(ALBUMS, { $ops: [{ title: { $like: '%quidem%' } }] }).collect()) {
-            results = { ...results, ...data as Record<_ttid, _album> }
-        }
-
-        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: Record<_ttid, _album> = {}
-
-        for await (const data of Fylo.findDocs<_album>(ALBUMS, { $ops: [{ title: { $like: 'omnis%' } }] }).collect()) {
-            results = { ...results, ...data as Record<_ttid, _album> }
-        }
-
-        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<_album>(`SELECT * FROM ${ALBUMS} WHERE userId != 1`) as Record<_ttid, _album>
-
-        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<_album>(`SELECT * FROM ${ALBUMS} WHERE title LIKE '%quidem%'`) as Record<_ttid, _album>
-
-        const albums = Object.values(results)
-        const allMatch = albums.every(a => a.title.includes('quidem'))
-
-        expect(allMatch).toBe(true)
-        expect(albums.length).toBeGreaterThan(0)
-    })
-})