@delma/fylo 1.1.2 → 2.0.1

package/tests/integration/{encryption.test.ts → encryption.test.js}

@@ -3,95 +3,68 @@ 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: _ttid
-
-    test("PUT encrypted document", async () => {
-
+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 () => {
-
+    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", () => {
-
+    test('encrypted values stored in S3 keys are not plaintext', () => {
         const bucket = S3Mock.getBucketFormat(COLLECTION)
-
-        // Verify the bucket was created and doc round-trip works
-        // (plaintext values should not appear as raw key segments)
         expect(bucket).toBeDefined()
     })
-
-    test("$eq query works on encrypted field", async () => {
-
+    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') {
+            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 () => {
-
+    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) // Should not reach here
+            expect(true).toBe(false)
         } catch (e) {
-            expect((e as Error).message).toContain('not supported on encrypted field')
+            expect(e.message).toContain('not supported on encrypted field')
         }
     })
-
-    test("$gt throws on encrypted field", async () => {
-
+    test('$gt throws on encrypted field', async () => {
         try {
             const iter = Fylo.findDocs(COLLECTION, {
                 $ops: [{ ssn: { $gt: 0 } }]
@@ -99,12 +72,10 @@ describe("Encryption", () => {
             await iter.next()
             expect(true).toBe(false)
         } catch (e) {
-            expect((e as Error).message).toContain('not supported on encrypted field')
+            expect(e.message).toContain('not supported on encrypted field')
         }
     })
-
-    test("$like throws on encrypted field", async () => {
-
+    test('$like throws on encrypted field', async () => {
         try {
             const iter = Fylo.findDocs(COLLECTION, {
                 $ops: [{ email: { $like: '%@example.com' } }]
@@ -112,30 +83,23 @@ describe("Encryption", () => {
             await iter.next()
             expect(true).toBe(false)
         } catch (e) {
-            expect((e as Error).message).toContain('not supported on encrypted field')
+            expect(e.message).toContain('not supported on encrypted field')
         }
     })
-
-    test("non-encrypted fields remain queryable with all operators", async () => {
-
+    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') {
+            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 () => {
-
+    test('nested encrypted field (address.city)', async () => {
         const id = await fylo.putData(COLLECTION, {
             name: 'Bob',
             email: 'bob@example.com',
@@ -143,34 +107,25 @@ describe("Encryption", () => {
             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 () => {
-
+    test('UPDATE preserves encryption', async () => {
         await fylo.patchDoc(COLLECTION, {
             [docId]: { email: 'alice-new@example.com' }
-        } as Record<_ttid, Record<string, string>>)
-
-        // Find the updated doc (patchDoc generates new TTID)
+        })
         let found = false
-
         for await (const data of Fylo.findDocs(COLLECTION, {
             $ops: [{ email: { $eq: 'alice-new@example.com' } }]
         }).collect()) {
-
-            if(typeof data === 'object') {
+            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.ts → export.test.js}

@@ -3,56 +3,41 @@ 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<_post>(POSTS, new URL(postsURL), IMPORT_LIMIT)
+        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 () => {
-
+describe('NO-SQL', () => {
+    test('EXPORT count matches import', async () => {
         let exported = 0
-
-        for await (const _doc of Fylo.exportBulkData<_post>(POSTS)) {
+        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<_post>(POSTS)) {
+    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<_post>(POSTS)) {
+    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.ts → join-modes.test.js}

@@ -3,218 +3,151 @@ import Fylo from '../../src'
 import { albumURL, postsURL } from '../data'
 import S3Mock from '../mocks/s3'
 import RedisMock from '../mocks/redis'
-
-/**
- * Albums (userId 1–10) and posts (userId 1–10) share a userId field,
- * making them a natural fit for join tests across all four join modes.
- *
- * Join semantics in Fylo:
- *   inner  → only the join field values
- *   left   → full left-collection document
- *   right  → full right-collection document
- *   outer  → merged left + right documents
- */
-
 const ALBUMS = 'jm-album'
-const POSTS  = 'jm-post'
-
+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<_album>(ALBUMS, new URL(albumURL), 100),
-            fylo.importBulkData<_post>(POSTS, new URL(postsURL), 100)
+            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<_album, _post>({
+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' } }
-        }) as Record<`${_ttid}, ${_ttid}`, { userId: number }>
-
+        })
         const pairs = Object.values(results)
-
         expect(pairs.length).toBeGreaterThan(0)
-
-        // inner mode returns only the join fields, not full documents
         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<_album, _post>({
+    test('LEFT JOIN — returns full left-collection document', async () => {
+        const results = await Fylo.joinDocs({
             $leftCollection: ALBUMS,
             $rightCollection: POSTS,
             $mode: 'left',
             $on: { userId: { $eq: 'userId' } }
-        }) as Record<`${_ttid}, ${_ttid}`, _album>
-
+        })
         const docs = Object.values(results)
-
         expect(docs.length).toBeGreaterThan(0)
-
-        // left mode returns the full album (left collection) document
         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<_album, _post>({
+    test('RIGHT JOIN — returns full right-collection document', async () => {
+        const results = await Fylo.joinDocs({
             $leftCollection: ALBUMS,
             $rightCollection: POSTS,
             $mode: 'right',
             $on: { userId: { $eq: 'userId' } }
-        }) as Record<`${_ttid}, ${_ttid}`, _post>
-
+        })
         const docs = Object.values(results)
-
         expect(docs.length).toBeGreaterThan(0)
-
-        // right mode returns the full post (right collection) document
         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<_album, _post>({
+    test('OUTER JOIN — returns merged left + right document', async () => {
+        const results = await Fylo.joinDocs({
             $leftCollection: ALBUMS,
             $rightCollection: POSTS,
             $mode: 'outer',
             $on: { userId: { $eq: 'userId' } }
-        }) as Record<`${_ttid}, ${_ttid}`, _album & _post>
-
+        })
         const docs = Object.values(results)
-
         expect(docs.length).toBeGreaterThan(0)
-
-        // outer mode merges both documents; both should have fields present
         for (const doc of docs) {
             expect(doc).toHaveProperty('userId')
         }
     })
-
-    test("JOIN with $limit — respects the result cap", async () => {
-
-        const results = await Fylo.joinDocs<_album, _post>({
+    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<_album, _post>({
+    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
-        }) as Record<`${_ttid}, ${_ttid}`, Partial<_album>>
-
+        })
         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<_album, _post>({
+    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'
-        }) as Record<string, Record<string, unknown>>
-
+        })
         expect(Object.keys(results).length).toBeGreaterThan(0)
     })
-
-    test("JOIN with $onlyIds — returns IDs only", async () => {
-
-        const results = await Fylo.joinDocs<_album, _post>({
+    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
-        }) as _ttid[]
-
+        })
         expect(Array.isArray(results)).toBe(true)
         expect(results.length).toBeGreaterThan(0)
     })
 })
-
-describe("SQL", async () => {
-
-    test("INNER JOIN", async () => {
-
-        const results = await fylo.executeSQL<_album>(
+describe('SQL', async () => {
+    test('INNER JOIN', async () => {
+        const results = await fylo.executeSQL(
             `SELECT * FROM ${ALBUMS} INNER JOIN ${POSTS} ON userId = userId`
-        ) as Record<`${_ttid}, ${_ttid}`, _album | _post>
-
+        )
         expect(Object.keys(results).length).toBeGreaterThan(0)
     })
-
-    test("LEFT JOIN", async () => {
-
-        const results = await fylo.executeSQL<_album>(
+    test('LEFT JOIN', async () => {
+        const results = await fylo.executeSQL(
             `SELECT * FROM ${ALBUMS} LEFT JOIN ${POSTS} ON userId = userId`
-        ) as Record<`${_ttid}, ${_ttid}`, _album>
-
+        )
         const docs = Object.values(results)
-
         expect(docs.length).toBeGreaterThan(0)
         expect(docs[0]).toHaveProperty('title')
     })
-
-    test("RIGHT JOIN", async () => {
-
-        const results = await fylo.executeSQL<_post>(
+    test('RIGHT JOIN', async () => {
+        const results = await fylo.executeSQL(
             `SELECT * FROM ${ALBUMS} RIGHT JOIN ${POSTS} ON userId = userId`
-        ) as Record<`${_ttid}, ${_ttid}`, _post>
-
+        )
         const docs = Object.values(results)
-
         expect(docs.length).toBeGreaterThan(0)
         expect(docs[0]).toHaveProperty('body')
     })

package/tests/integration/migration.test.js

@@ -0,0 +1,38 @@
+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'])
+    })
+})