@delma/fylo 2.0.1 → 2.1.0

package/tests/integration/edge-cases.test.js

@@ -1,22 +1,22 @@
-import { test, expect, describe, beforeAll, afterAll, mock } from 'bun:test'
+import { test, expect, describe, beforeAll, afterAll } from 'bun:test'
+import { rm } from 'node:fs/promises'
 import Fylo from '../../src'
 import TTID from '@delma/ttid'
-import S3Mock from '../mocks/s3'
-import RedisMock from '../mocks/redis'
+import { createTestRoot } from '../helpers/root'
 const COLLECTION = 'ec-test'
-const fylo = new Fylo()
-mock.module('../../src/adapters/s3', () => ({ S3: S3Mock }))
-mock.module('../../src/adapters/redis', () => ({ Redis: RedisMock }))
+const root = await createTestRoot('fylo-edge-')
+const fylo = new Fylo({ root })
 beforeAll(async () => {
-    await Fylo.createCollection(COLLECTION)
+    await fylo.createCollection(COLLECTION)
 })
 afterAll(async () => {
-    await Fylo.dropCollection(COLLECTION)
+    await fylo.dropCollection(COLLECTION)
+    await rm(root, { recursive: true, force: true })
 })
 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()
+        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 () => {
@@ -27,7 +27,7 @@ describe('NO-SQL', () => {
             body: 'https://example.com/api/v1/resource'
         }
         const _id = await fylo.putData(COLLECTION, original)
-        const result = await Fylo.getDoc(COLLECTION, _id).once()
+        const result = await fylo.getDoc(COLLECTION, _id).once()
         const doc = result[_id]
         expect(doc.body).toBe(original.body)
         await fylo.delDoc(COLLECTION, _id)
@@ -40,12 +40,12 @@ describe('NO-SQL', () => {
             body: 'https://cdn.example.com//assets//image.png'
         }
         const _id = await fylo.putData(COLLECTION, original)
-        const result = await Fylo.getDoc(COLLECTION, _id).once()
+        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 () => {
-        const cleanFylo = new Fylo()
+        const cleanFylo = new Fylo({ root })
         const id1 = await cleanFylo.putData(COLLECTION, {
             userId: 10,
             id: 100,
@@ -59,9 +59,11 @@ describe('NO-SQL', () => {
             body: 'second'
         })
         const results = {}
-        for await (const data of Fylo.findDocs(COLLECTION, {
-            $ops: [{ userId: { $eq: 10 } }, { userId: { $eq: 20 } }]
-        }).collect()) {
+        for await (const data of fylo
+            .findDocs(COLLECTION, {
+                $ops: [{ userId: { $eq: 10 } }, { userId: { $eq: 20 } }]
+            })
+            .collect()) {
             Object.assign(results, data)
         }
         expect(results[id1]).toBeDefined()
@@ -70,7 +72,7 @@ describe('NO-SQL', () => {
         await cleanFylo.delDoc(COLLECTION, id2)
     })
     test('$rename — renames fields in query output', async () => {
-        const cleanFylo = new Fylo()
+        const cleanFylo = new Fylo({ root })
         const _id = await cleanFylo.putData(COLLECTION, {
             userId: 1,
             id: 300,
@@ -78,10 +80,12 @@ describe('NO-SQL', () => {
             body: 'some body'
         })
         let renamed = {}
-        for await (const data of Fylo.findDocs(COLLECTION, {
-            $ops: [{ id: { $eq: 300 } }],
-            $rename: { title: 'name' }
-        }).collect()) {
+        for await (const data of fylo
+            .findDocs(COLLECTION, {
+                $ops: [{ id: { $eq: 300 } }],
+                $rename: { title: 'name' }
+            })
+            .collect()) {
             renamed = Object.values(data)[0]
         }
         expect(renamed.name).toBe('Rename Me')
@@ -89,7 +93,7 @@ describe('NO-SQL', () => {
         await cleanFylo.delDoc(COLLECTION, _id)
     })
     test('versioned putData — preserves creation-time prefix in TTID', async () => {
-        const cleanFylo = new Fylo()
+        const cleanFylo = new Fylo({ root })
         const _id1 = await cleanFylo.putData(COLLECTION, {
             userId: 1,
             id: 400,
@@ -100,7 +104,7 @@ describe('NO-SQL', () => {
             [_id1]: { userId: 1, id: 400, title: 'Updated', body: 'v2' }
         })
         expect(_id2.split('-')[0]).toBe(_id1.split('-')[0])
-        const result = await Fylo.getDoc(COLLECTION, _id2).once()
+        const result = await fylo.getDoc(COLLECTION, _id2).once()
         const doc = result[_id2]
         expect(doc).toBeDefined()
         expect(doc.title).toBe('Updated')
@@ -108,7 +112,7 @@ describe('NO-SQL', () => {
         await cleanFylo.delDoc(COLLECTION, _id2)
     })
     test('versioned putData — original version is no longer retrievable by old full TTID', async () => {
-        const cleanFylo = new Fylo()
+        const cleanFylo = new Fylo({ root })
         const _id1 = await cleanFylo.putData(COLLECTION, {
             userId: 1,
             id: 500,
@@ -124,7 +128,7 @@ describe('NO-SQL', () => {
 })
 describe('SQL', () => {
     test('UPDATE ONE — update a single document by querying its unique field', async () => {
-        const cleanFylo = new Fylo()
+        const cleanFylo = new Fylo({ root })
         await cleanFylo.putData(COLLECTION, {
             userId: 1,
             id: 600,
@@ -142,7 +146,7 @@ describe('SQL', () => {
         expect(Object.values(results)[0].title).toBe('After SQL Update')
     })
     test('DELETE ONE — delete a single document by querying its unique field', async () => {
-        const cleanFylo = new Fylo()
+        const cleanFylo = new Fylo({ root })
         await cleanFylo.putData(COLLECTION, {
             userId: 1,
             id: 700,

package/tests/integration/encryption.test.js

@@ -1,21 +1,22 @@
 import { test, expect, describe, beforeAll, afterAll, mock } from 'bun:test'
+import { readFile, rm } from 'node:fs/promises'
+import path from 'node:path'
 import Fylo from '../../src'
-import S3Mock from '../mocks/s3'
-import RedisMock from '../mocks/redis'
+import { createTestRoot } from '../helpers/root'
 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 }))
+const root = await createTestRoot('fylo-encryption-')
+const fylo = new Fylo({ root })
 mock.module('../../src/adapters/cipher', () => ({ Cipher: CipherMock }))
 beforeAll(async () => {
-    await Fylo.createCollection(COLLECTION)
+    await fylo.createCollection(COLLECTION)
     await CipherMock.configure('test-secret-key')
     CipherMock.registerFields(COLLECTION, ['email', 'ssn', 'address'])
 })
 afterAll(async () => {
     CipherMock.reset()
-    await Fylo.dropCollection(COLLECTION)
+    await fylo.dropCollection(COLLECTION)
+    await rm(root, { recursive: true, force: true })
 })
 describe('Encryption', () => {
     let docId
@@ -29,22 +30,28 @@ describe('Encryption', () => {
         expect(docId).toBeDefined()
     })
     test('GET decrypts fields transparently', async () => {
-        const result = await Fylo.getDoc(COLLECTION, docId).once()
+        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', () => {
-        const bucket = S3Mock.getBucketFormat(COLLECTION)
-        expect(bucket).toBeDefined()
+    test('encrypted values stored in the doc file are not plaintext', async () => {
+        const raw = await readFile(
+            path.join(root, COLLECTION, '.fylo', 'docs', docId.slice(0, 2), `${docId}.json`),
+            'utf8'
+        )
+        expect(raw).not.toContain('alice@example.com')
+        expect(raw).not.toContain('123-45-6789')
     })
     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()) {
+        for await (const data of fylo
+            .findDocs(COLLECTION, {
+                $ops: [{ email: { $eq: 'alice@example.com' } }]
+            })
+            .collect()) {
             if (typeof data === 'object') {
                 const doc = Object.values(data)[0]
                 expect(doc.email).toBe('alice@example.com')
@@ -55,9 +62,11 @@ describe('Encryption', () => {
     })
     test('$ne throws on encrypted field', async () => {
         try {
-            const iter = Fylo.findDocs(COLLECTION, {
-                $ops: [{ email: { $ne: 'bob@example.com' } }]
-            }).collect()
+            const iter = fylo
+                .findDocs(COLLECTION, {
+                    $ops: [{ email: { $ne: 'bob@example.com' } }]
+                })
+                .collect()
             await iter.next()
             expect(true).toBe(false)
         } catch (e) {
@@ -66,9 +75,11 @@ describe('Encryption', () => {
     })
     test('$gt throws on encrypted field', async () => {
         try {
-            const iter = Fylo.findDocs(COLLECTION, {
-                $ops: [{ ssn: { $gt: 0 } }]
-            }).collect()
+            const iter = fylo
+                .findDocs(COLLECTION, {
+                    $ops: [{ ssn: { $gt: 0 } }]
+                })
+                .collect()
             await iter.next()
             expect(true).toBe(false)
         } catch (e) {
@@ -77,9 +88,11 @@ describe('Encryption', () => {
     })
     test('$like throws on encrypted field', async () => {
         try {
-            const iter = Fylo.findDocs(COLLECTION, {
-                $ops: [{ email: { $like: '%@example.com' } }]
-            }).collect()
+            const iter = fylo
+                .findDocs(COLLECTION, {
+                    $ops: [{ email: { $like: '%@example.com' } }]
+                })
+                .collect()
             await iter.next()
             expect(true).toBe(false)
         } catch (e) {
@@ -88,9 +101,11 @@ describe('Encryption', () => {
     })
     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()) {
+        for await (const data of fylo
+            .findDocs(COLLECTION, {
+                $ops: [{ name: { $eq: 'Alice' } }]
+            })
+            .collect()) {
             if (typeof data === 'object') {
                 const doc = Object.values(data)[0]
                 expect(doc.name).toBe('Alice')
@@ -107,7 +122,7 @@ describe('Encryption', () => {
             age: 25,
             address: { city: 'Toronto', zip: 'M5V 2T6' }
         })
-        const result = await Fylo.getDoc(COLLECTION, id).once()
+        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')
@@ -117,9 +132,11 @@ describe('Encryption', () => {
             [docId]: { email: 'alice-new@example.com' }
         })
         let found = false
-        for await (const data of Fylo.findDocs(COLLECTION, {
-            $ops: [{ email: { $eq: 'alice-new@example.com' } }]
-        }).collect()) {
+        for await (const data of fylo
+            .findDocs(COLLECTION, {
+                $ops: [{ email: { $eq: 'alice-new@example.com' } }]
+            })
+            .collect()) {
             if (typeof data === 'object') {
                 const doc = Object.values(data)[0]
                 expect(doc.email).toBe('alice-new@example.com')

package/tests/integration/export.test.js

@@ -1,16 +1,15 @@
-import { test, expect, describe, beforeAll, afterAll, mock } from 'bun:test'
+import { test, expect, describe, beforeAll, afterAll } from 'bun:test'
+import { rm } from 'node:fs/promises'
 import Fylo from '../../src'
 import { postsURL } from '../data'
-import S3Mock from '../mocks/s3'
-import RedisMock from '../mocks/redis'
+import { createTestRoot } from '../helpers/root'
 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 }))
+const root = await createTestRoot('fylo-export-')
+const fylo = new Fylo({ root })
 beforeAll(async () => {
-    await Fylo.createCollection(POSTS)
+    await fylo.createCollection(POSTS)
     try {
         importedCount = await fylo.importBulkData(POSTS, new URL(postsURL), IMPORT_LIMIT)
     } catch {
@@ -18,18 +17,19 @@ beforeAll(async () => {
     }
 })
 afterAll(async () => {
-    await Fylo.dropCollection(POSTS)
+    await fylo.dropCollection(POSTS)
+    await rm(root, { recursive: true, force: true })
 })
 describe('NO-SQL', () => {
     test('EXPORT count matches import', async () => {
         let exported = 0
-        for await (const _doc of Fylo.exportBulkData(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(POSTS)) {
+        for await (const doc of fylo.exportBulkData(POSTS)) {
             expect(doc).toHaveProperty('title')
             expect(doc).toHaveProperty('userId')
             expect(doc).toHaveProperty('body')
@@ -37,7 +37,7 @@ describe('NO-SQL', () => {
         }
     })
     test('EXPORT all documents are valid posts', async () => {
-        for await (const doc of Fylo.exportBulkData(POSTS)) {
+        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.js

@@ -1,15 +1,14 @@
-import { test, expect, describe, beforeAll, afterAll, mock } from 'bun:test'
+import { test, expect, describe, beforeAll, afterAll } from 'bun:test'
+import { rm } from 'node:fs/promises'
 import Fylo from '../../src'
 import { albumURL, postsURL } from '../data'
-import S3Mock from '../mocks/s3'
-import RedisMock from '../mocks/redis'
+import { createTestRoot } from '../helpers/root'
 const ALBUMS = 'jm-album'
 const POSTS = 'jm-post'
-const fylo = new Fylo()
-mock.module('../../src/adapters/s3', () => ({ S3: S3Mock }))
-mock.module('../../src/adapters/redis', () => ({ Redis: RedisMock }))
+const root = await createTestRoot('fylo-join-')
+const fylo = new Fylo({ root })
 beforeAll(async () => {
-    await Promise.all([Fylo.createCollection(ALBUMS), Fylo.createCollection(POSTS)])
+    await Promise.all([fylo.createCollection(ALBUMS), fylo.createCollection(POSTS)])
     try {
         await Promise.all([
             fylo.importBulkData(ALBUMS, new URL(albumURL), 100),
@@ -20,11 +19,12 @@ beforeAll(async () => {
     }
 })
 afterAll(async () => {
-    await Promise.all([Fylo.dropCollection(ALBUMS), Fylo.dropCollection(POSTS)])
+    await Promise.all([fylo.dropCollection(ALBUMS), fylo.dropCollection(POSTS)])
+    await rm(root, { recursive: true, force: true })
 })
 describe('NO-SQL', async () => {
     test('INNER JOIN — returns only join field values', async () => {
-        const results = await Fylo.joinDocs({
+        const results = await fylo.joinDocs({
             $leftCollection: ALBUMS,
             $rightCollection: POSTS,
             $mode: 'inner',
@@ -38,7 +38,7 @@ describe('NO-SQL', async () => {
         }
     })
     test('LEFT JOIN — returns full left-collection document', async () => {
-        const results = await Fylo.joinDocs({
+        const results = await fylo.joinDocs({
             $leftCollection: ALBUMS,
             $rightCollection: POSTS,
             $mode: 'left',
@@ -52,7 +52,7 @@ describe('NO-SQL', async () => {
         }
     })
     test('RIGHT JOIN — returns full right-collection document', async () => {
-        const results = await Fylo.joinDocs({
+        const results = await fylo.joinDocs({
             $leftCollection: ALBUMS,
             $rightCollection: POSTS,
             $mode: 'right',
@@ -67,7 +67,7 @@ describe('NO-SQL', async () => {
         }
     })
     test('OUTER JOIN — returns merged left + right document', async () => {
-        const results = await Fylo.joinDocs({
+        const results = await fylo.joinDocs({
             $leftCollection: ALBUMS,
             $rightCollection: POSTS,
             $mode: 'outer',
@@ -80,7 +80,7 @@ describe('NO-SQL', async () => {
         }
     })
     test('JOIN with $limit — respects the result cap', async () => {
-        const results = await Fylo.joinDocs({
+        const results = await fylo.joinDocs({
             $leftCollection: ALBUMS,
             $rightCollection: POSTS,
             $mode: 'inner',
@@ -90,7 +90,7 @@ describe('NO-SQL', async () => {
         expect(Object.keys(results).length).toBe(5)
     })
     test('JOIN with $select — only requested fields are returned', async () => {
-        const results = await Fylo.joinDocs({
+        const results = await fylo.joinDocs({
             $leftCollection: ALBUMS,
             $rightCollection: POSTS,
             $mode: 'left',
@@ -106,7 +106,7 @@ describe('NO-SQL', async () => {
         }
     })
     test('JOIN with $groupby — groups results by field value', async () => {
-        const results = await Fylo.joinDocs({
+        const results = await fylo.joinDocs({
             $leftCollection: ALBUMS,
             $rightCollection: POSTS,
             $mode: 'inner',
@@ -116,7 +116,7 @@ describe('NO-SQL', async () => {
         expect(Object.keys(results).length).toBeGreaterThan(0)
     })
     test('JOIN with $onlyIds — returns IDs only', async () => {
-        const results = await Fylo.joinDocs({
+        const results = await fylo.joinDocs({
             $leftCollection: ALBUMS,
             $rightCollection: POSTS,
             $mode: 'inner',

package/tests/integration/nested.test.js

@@ -1,38 +1,38 @@
-import { test, expect, describe, beforeAll, afterAll, mock } from 'bun:test'
+import { test, expect, describe, beforeAll, afterAll } from 'bun:test'
+import { rm } from 'node:fs/promises'
 import Fylo from '../../src'
 import { usersURL } from '../data'
-import S3Mock from '../mocks/s3'
-import RedisMock from '../mocks/redis'
+import { createTestRoot } from '../helpers/root'
 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 }))
+const root = await createTestRoot('fylo-nested-')
+const fylo = new Fylo({ root })
 beforeAll(async () => {
-    await Fylo.createCollection(USERS)
+    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()) {
+    for await (const data of fylo.findDocs(USERS, { $limit: 1, $onlyIds: true }).collect()) {
         sampleId = data
     }
 })
 afterAll(async () => {
-    await Fylo.dropCollection(USERS)
+    await fylo.dropCollection(USERS)
+    await rm(root, { recursive: true, force: true })
 })
 describe('NO-SQL', async () => {
     test('SELECT ALL — nested documents are returned', async () => {
         let results = {}
-        for await (const data of Fylo.findDocs(USERS).collect()) {
+        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 result = await fylo.getDoc(USERS, sampleId).once()
         const user = result[sampleId]
         expect(user).toBeDefined()
         expect(typeof user.name).toBe('string')
@@ -40,7 +40,7 @@ describe('NO-SQL', async () => {
         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 result = await fylo.getDoc(USERS, sampleId).once()
         const user = result[sampleId]
         expect(user.address).toBeDefined()
         expect(typeof user.address.city).toBe('string')
@@ -48,14 +48,14 @@ describe('NO-SQL', async () => {
         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 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 result = await fylo.getDoc(USERS, sampleId).once()
         const user = result[sampleId]
         expect(user.company).toBeDefined()
         expect(typeof user.company.name).toBe('string')
@@ -63,7 +63,7 @@ describe('NO-SQL', async () => {
         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()) {
+        for await (const data of fylo.findDocs(USERS).collect()) {
             const [, user] = Object.entries(data)[0]
             expect(user.address).toBeDefined()
             expect(user.address.geo).toBeDefined()
@@ -73,7 +73,7 @@ describe('NO-SQL', async () => {
     })
     test('$select — returns only requested top-level fields', async () => {
         let results = {}
-        for await (const data of Fylo.findDocs(USERS, { $select: ['name', 'email'] }).collect()) {
+        for await (const data of fylo.findDocs(USERS, { $select: ['name', 'email'] }).collect()) {
             results = { ...results, ...data }
         }
         const users = Object.values(results)
@@ -81,12 +81,14 @@ describe('NO-SQL', async () => {
         expect(onlyNameAndEmail).toBe(true)
     })
     test('$eq on nested string field — query by city', async () => {
-        const result = await Fylo.getDoc(USERS, sampleId).once()
+        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()) {
+        for await (const data of fylo
+            .findDocs(USERS, {
+                $ops: [{ ['address/city']: { $eq: targetCity } }]
+            })
+            .collect()) {
             results = { ...results, ...data }
         }
         const matchingUsers = Object.values(results)
@@ -97,7 +99,7 @@ describe('NO-SQL', async () => {
 })
 describe('SQL — dot notation', async () => {
     test('WHERE with dot notation — first-level nested field', async () => {
-        const result = await Fylo.getDoc(USERS, sampleId).once()
+        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}'`
@@ -108,7 +110,7 @@ describe('SQL — dot notation', async () => {
         expect(users.length).toBeGreaterThan(0)
     })
     test('WHERE with dot notation — deeply nested field', async () => {
-        const result = await Fylo.getDoc(USERS, sampleId).once()
+        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}'`
@@ -119,7 +121,7 @@ describe('SQL — dot notation', async () => {
         expect(users.length).toBeGreaterThan(0)
     })
     test('WHERE with dot notation — second nested object', async () => {
-        const result = await Fylo.getDoc(USERS, sampleId).once()
+        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}'`
@@ -130,7 +132,7 @@ describe('SQL — dot notation', async () => {
         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 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}'`