@delma/fylo 1.1.1 → 2.0.0

package/tests/collection/truncate.test.js

@@ -0,0 +1,35 @@
+import { test, expect, describe, afterAll, mock } from 'bun:test'
+import Fylo from '../../src'
+import { postsURL, albumURL } from '../data'
+import S3Mock from '../mocks/s3'
+import RedisMock from '../mocks/redis'
+const POSTS = `post`
+const ALBUMS = `album`
+afterAll(async () => {
+    await Promise.all([Fylo.dropCollection(ALBUMS), Fylo.dropCollection(POSTS)])
+})
+mock.module('../../src/adapters/s3', () => ({ S3: S3Mock }))
+mock.module('../../src/adapters/redis', () => ({ Redis: RedisMock }))
+describe('NO-SQL', () => {
+    test('TRUNCATE', async () => {
+        const fylo = new Fylo()
+        await Fylo.createCollection(POSTS)
+        await fylo.importBulkData(POSTS, new URL(postsURL))
+        await fylo.delDocs(POSTS)
+        const ids = []
+        for await (const data of Fylo.findDocs(POSTS, { $limit: 1, $onlyIds: true }).collect()) {
+            ids.push(data)
+        }
+        expect(ids.length).toBe(0)
+    })
+})
+describe('SQL', () => {
+    test('TRUNCATE', async () => {
+        const fylo = new Fylo()
+        await fylo.executeSQL(`CREATE TABLE ${ALBUMS}`)
+        await fylo.importBulkData(ALBUMS, new URL(albumURL))
+        await fylo.executeSQL(`DELETE FROM ${ALBUMS}`)
+        const ids = await fylo.executeSQL(`SELECT _id FROM ${ALBUMS} LIMIT 1`)
+        expect(ids.length).toBe(0)
+    })
+})

package/tests/{data.ts → data.js}

@@ -1,13 +1,11 @@
-function makeDataUrl(data: unknown): string {
+function makeDataUrl(data) {
     return `data:application/json,${encodeURIComponent(JSON.stringify(data))}`
 }
-
-function generateAlbums(): _album[] {
+function generateAlbums() {
     return Array.from({ length: 100 }, (_, index) => {
         const id = index + 1
         const userId = Math.ceil(id / 10)
         const prefix = id <= 15 ? 'omnis' : id % 4 === 0 ? 'quidem' : 'album'
-
         return {
             id,
             userId,
@@ -15,12 +13,10 @@ function generateAlbums(): _album[] {
         }
     })
 }
-
-function generatePosts(): _post[] {
+function generatePosts() {
     return Array.from({ length: 100 }, (_, index) => {
         const id = index + 1
         const userId = Math.ceil(id / 10)
-
         return {
             id,
             userId,
@@ -29,11 +25,9 @@ function generatePosts(): _post[] {
         }
     })
 }
-
-function generateComments(): _comment[] {
+function generateComments() {
     return Array.from({ length: 100 }, (_, index) => {
         const id = index + 1
-
         return {
             id,
             postId: id,
@@ -43,12 +37,10 @@ function generateComments(): _comment[] {
         }
     })
 }
-
-function generatePhotos(): _photo[] {
+function generatePhotos() {
     return Array.from({ length: 100 }, (_, index) => {
         const id = index + 1
         const title = id % 3 === 0 ? `test photo ${id}` : `photo ${id}`
-
         return {
             id,
             albumId: Math.ceil(id / 10),
@@ -58,11 +50,9 @@ function generatePhotos(): _photo[] {
         }
     })
 }
-
-function generateTodos(): _todo[] {
+function generateTodos() {
     return Array.from({ length: 100 }, (_, index) => {
         const id = index + 1
-
         return {
             id,
             userId: Math.ceil(id / 10),
@@ -71,11 +61,9 @@ function generateTodos(): _todo[] {
         }
     })
 }
-
-function generateUsers(): _user[] {
+function generateUsers() {
     return Array.from({ length: 10 }, (_, index) => {
         const id = index + 1
-
         return {
             id,
             name: `User ${id}`,
@@ -98,10 +86,9 @@ function generateUsers(): _user[] {
                 catchPhrase: `Catch phrase ${id}`,
                 bs: `business ${id}`
             }
-        } as unknown as _user
+        }
     })
 }
-
 export const albumURL = makeDataUrl(generateAlbums())
 export const postsURL = makeDataUrl(generatePosts())
 export const commentsURL = makeDataUrl(generateComments())

package/tests/{index.ts → index.js}

@@ -1,19 +1,14 @@
 import { Redis } from '../src/adapters/redis'
 import ttid from '@delma/ttid'
-
 const redisPub = new Redis()
 const redisSub = new Redis()
-
 setTimeout(async () => {
-    await redisPub.publish("bun", "insert", ttid.generate())
+    await redisPub.publish('bun', 'insert', ttid.generate())
 }, 2000)
-
 setTimeout(async () => {
-    await redisPub.publish("bun", "insert", ttid.generate())
+    await redisPub.publish('bun', 'insert', ttid.generate())
 }, 3000)
-
 await Bun.sleep(1000)
-
-for await (const data of redisSub.subscribe("bun")) {
-    console.log("Received:", data)
+for await (const data of redisSub.subscribe('bun')) {
+    console.log('Received:', data)
 }

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

@@ -0,0 +1,22 @@
+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.ts → create.test.js}

@@ -3,55 +3,37 @@ 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<_user>(`CREATE TABLE ${ALBUMS}`)])
-    
+    await Promise.all([Fylo.createCollection(POSTS), fylo.executeSQL(`CREATE TABLE ${ALBUMS}`)])
     try {
-        albumsCount = await fylo.importBulkData<_album>(ALBUMS, new URL(albumURL), 100)
-        postsCount = await fylo.importBulkData<_post>(POSTS, new URL(postsURL), 100)
+        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<_album>(`DROP TABLE ${ALBUMS}`)])
+    await Promise.all([Fylo.dropCollection(POSTS), fylo.executeSQL(`DROP TABLE ${ALBUMS}`)])
 })
-
-describe("NO-SQL", async () => {
-
-    test("PUT", async () => {
-
-        let results: Record<_ttid, _post> = {}
-
-        for await (const data of Fylo.findDocs<_post>(POSTS).collect()) {
-            
-            results = { ...results, ...data as Record<_ttid, _post> }
+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<_album>(`SELECT * FROM ${ALBUMS}`) as Record<_ttid, _album>
-
+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

@@ -0,0 +1,95 @@
+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.ts → edge-cases.test.js}

@@ -3,230 +3,156 @@ import Fylo from '../../src'
 import TTID from '@delma/ttid'
 import S3Mock from '../mocks/s3'
 import RedisMock from '../mocks/redis'
-
-/**
- * Edge case coverage:
- *   - Non-existent ID returns empty object
- *   - Values containing forward slashes survive the SLASH_ASCII (%2F) round-trip
- *   - Multiple $ops entries act as OR (union across patterns)
- *   - $rename renames fields in query output
- *   - Versioned putData (existing TTID as key) preserves the creation-time prefix
- *   - SQL UPDATE ONE — update a single document by ID via SQL
- *   - SQL DELETE ONE — delete a single document by ID via SQL
- */
-
 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() as _ttid
-
+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 () => {
-
+    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<_post>(COLLECTION, original)
-
-        const result = await Fylo.getDoc<_post>(COLLECTION, _id).once()
+        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 () => {
-
+    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<_post>(COLLECTION, original)
-
-        const result = await Fylo.getDoc<_post>(COLLECTION, _id).once()
-
+        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 () => {
-
+    test('$ops — multiple conditions act as OR union', async () => {
         const cleanFylo = new Fylo()
-
-        const id1 = await cleanFylo.putData<_post>(COLLECTION, { userId: 10, id: 100, title: 'Alpha', body: 'first' })
-        const id2 = await cleanFylo.putData<_post>(COLLECTION, { userId: 20, id: 200, title: 'Beta',  body: 'second' })
-
-        const results: Record<_ttid, _post> = {}
-
-        for await (const data of Fylo.findDocs<_post>(COLLECTION, {
-            $ops: [
-                { userId: { $eq: 10 } },
-                { userId: { $eq: 20 } }
-            ]
+        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 () => {
-
+    test('$rename — renames fields in query output', async () => {
         const cleanFylo = new Fylo()
-
-        const _id = await cleanFylo.putData<_post>(COLLECTION, {
+        const _id = await cleanFylo.putData(COLLECTION, {
             userId: 1,
             id: 300,
             title: 'Rename Me',
             body: 'some body'
         })
-
-        let renamed: Partial<_post> & { name?: string } = {}
-
-        for await (const data of Fylo.findDocs<_post>(COLLECTION, {
+        let renamed = {}
+        for await (const data of Fylo.findDocs(COLLECTION, {
             $ops: [{ id: { $eq: 300 } }],
-            $rename: { title: 'name' } as Record<keyof Partial<_post>, string>
+            $rename: { title: 'name' }
         }).collect()) {
-            renamed = Object.values(data as Record<_ttid, typeof renamed>)[0]
+            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 () => {
-
+    test('versioned putData — preserves creation-time prefix in TTID', async () => {
         const cleanFylo = new Fylo()
-
-        const _id1 = await cleanFylo.putData<_post>(COLLECTION, {
+        const _id1 = await cleanFylo.putData(COLLECTION, {
             userId: 1,
             id: 400,
             title: 'Original',
             body: 'v1'
         })
-
-        const _id2 = await cleanFylo.putData<_post>(COLLECTION, {
+        const _id2 = await cleanFylo.putData(COLLECTION, {
             [_id1]: { userId: 1, id: 400, title: 'Updated', body: 'v2' }
         })
-
-        // The creation-time segment (before the first '-') must be identical
         expect(_id2.split('-')[0]).toBe(_id1.split('-')[0])
-
-        // The updated doc is retrievable via its own TTID
-        const result = await Fylo.getDoc<_post>(COLLECTION, _id2).once()
+        const result = await Fylo.getDoc(COLLECTION, _id2).once()
         const doc = result[_id2]
-
         expect(doc).toBeDefined()
         expect(doc.title).toBe('Updated')
-
-        // Clean up both versions
         await cleanFylo.delDoc(COLLECTION, _id1)
         await cleanFylo.delDoc(COLLECTION, _id2)
     })
-
-    test("versioned putData — original version is no longer retrievable by old full TTID", async () => {
-
+    test('versioned putData — original version is no longer retrievable by old full TTID', async () => {
         const cleanFylo = new Fylo()
-
-        const _id1 = await cleanFylo.putData<_post>(COLLECTION, {
+        const _id1 = await cleanFylo.putData(COLLECTION, {
             userId: 1,
             id: 500,
             title: 'Old Version',
             body: 'original'
         })
-
-        const _id2 = await cleanFylo.putData<_post>(COLLECTION, {
+        const _id2 = await cleanFylo.putData(COLLECTION, {
             [_id1]: { userId: 1, id: 500, title: 'New Version', body: 'updated' }
         })
-
-        // Both IDs are different (update appended a segment)
         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 () => {
-
+describe('SQL', () => {
+    test('UPDATE ONE — update a single document by querying its unique field', async () => {
         const cleanFylo = new Fylo()
-
-        await cleanFylo.putData<_post>(COLLECTION, {
+        await cleanFylo.putData(COLLECTION, {
             userId: 1,
             id: 600,
             title: 'Before SQL Update',
             body: 'original'
         })
-
-        const updated = await cleanFylo.executeSQL<_post>(
+        const updated = await cleanFylo.executeSQL(
             `UPDATE ${COLLECTION} SET title = 'After SQL Update' WHERE id = 600`
-        ) as number
-
+        )
         expect(updated).toBe(1)
-
-        const results = await cleanFylo.executeSQL<_post>(
+        const results = await cleanFylo.executeSQL(
             `SELECT * FROM ${COLLECTION} WHERE title = 'After SQL Update'`
-        ) as Record<_ttid, _post>
-
+        )
         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 () => {
-
+    test('DELETE ONE — delete a single document by querying its unique field', async () => {
         const cleanFylo = new Fylo()
-
-        await cleanFylo.putData<_post>(COLLECTION, {
+        await cleanFylo.putData(COLLECTION, {
             userId: 1,
             id: 700,
             title: 'Delete Via SQL',
             body: 'should be removed'
         })
-
-        await cleanFylo.executeSQL<_post>(
-            `DELETE FROM ${COLLECTION} WHERE title = 'Delete Via SQL'`
-        )
-
-        const results = await cleanFylo.executeSQL<_post>(
+        await cleanFylo.executeSQL(`DELETE FROM ${COLLECTION} WHERE title = 'Delete Via SQL'`)
+        const results = await cleanFylo.executeSQL(
             `SELECT * FROM ${COLLECTION} WHERE title = 'Delete Via SQL'`
-        ) as Record<_ttid, _post>
-
+        )
         expect(Object.keys(results).length).toBe(0)
     })
 })