@delma/fylo 1.1.2 → 2.0.0

package/tests/integration/update.test.js

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

package/tests/mocks/{cipher.ts → cipher.js}

@@ -1,55 +1,40 @@
-/**
- * Pass-through Cipher mock for tests that don't need real encryption.
- * Returns values as-is (base64-encoded to match real adapter interface shape).
- */
 export class CipherMock {
-
-    private static _configured = false
-    private static collections: Map<string, Set<string>> = new Map()
-
-    static isConfigured(): boolean {
+    static _configured = false
+    static collections = new Map()
+    static isConfigured() {
         return CipherMock._configured
     }
-
-    static hasEncryptedFields(collection: string): boolean {
+    static hasEncryptedFields(collection) {
         const fields = CipherMock.collections.get(collection)
         return !!fields && fields.size > 0
     }
-
-    static isEncryptedField(collection: string, field: string): boolean {
+    static isEncryptedField(collection, field) {
         const fields = CipherMock.collections.get(collection)
         if (!fields || fields.size === 0) return false
-
         for (const pattern of fields) {
             if (field === pattern) return true
             if (field.startsWith(`${pattern}/`)) return true
         }
-
         return false
     }
-
-    static registerFields(collection: string, fields: string[]): void {
+    static registerFields(collection, fields) {
         if (fields.length > 0) {
             CipherMock.collections.set(collection, new Set(fields))
         }
     }
-
-    static async configure(_secret: string): Promise<void> {
+    static async configure(_secret) {
         CipherMock._configured = true
     }
-
-    static reset(): void {
+    static reset() {
         CipherMock._configured = false
         CipherMock.collections = new Map()
     }
-
-    static async encrypt(value: string): Promise<string> {
+    static async encrypt(value) {
         return btoa(value).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
     }
-
-    static async decrypt(encoded: string): Promise<string> {
+    static async decrypt(encoded) {
         const b64 = encoded.replace(/-/g, '+').replace(/_/g, '/')
-        const padded = b64 + '='.repeat((4 - b64.length % 4) % 4)
+        const padded = b64 + '='.repeat((4 - (b64.length % 4)) % 4)
         return atob(padded)
     }
 }

package/tests/mocks/redis.js

@@ -0,0 +1,123 @@
+export default class RedisMock {
+    static stream = []
+    static jobs = new Map()
+    static docs = new Map()
+    static locks = new Map()
+    static deadLetters = []
+    static nextId = 0
+    async publish(_collection, _action, _keyId) {}
+    async claimTTID(_id, _ttlSeconds = 10) {
+        return true
+    }
+    async enqueueWrite(job) {
+        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, count = 1) {
+        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) {
+        RedisMock.stream = RedisMock.stream.filter((item) => item.streamId !== streamId)
+    }
+    async deadLetterWriteJob(streamId, job, reason) {
+        RedisMock.deadLetters.push({
+            streamId: String(RedisMock.deadLetters.length + 1),
+            jobId: job.jobId,
+            reason,
+            failedAt: Date.now()
+        })
+        await this.ackWriteJob(streamId)
+    }
+    async claimPendingJobs(workerId, _minIdleMs = 30000, count = 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, status, extra = {}) {
+        const job = RedisMock.jobs.get(jobId)
+        if (job) Object.assign(job, extra, { status, updatedAt: Date.now() })
+    }
+    async setDocStatus(collection, docId, status, jobId) {
+        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) {
+        const job = RedisMock.jobs.get(jobId)
+        return job ? { ...job } : null
+    }
+    async getDocStatus(collection, docId) {
+        return RedisMock.docs.get(`fylo:doc:${collection}:${docId}`) ?? null
+    }
+    async readDeadLetters(count = 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) {
+        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, docId, jobId) {
+        const key = `fylo:lock:${collection}:${docId}`
+        if (RedisMock.locks.has(key)) return false
+        RedisMock.locks.set(key, jobId)
+        return true
+    }
+    async releaseDocLock(collection, docId, jobId) {
+        const key = `fylo:lock:${collection}:${docId}`
+        if (RedisMock.locks.get(key) === jobId) RedisMock.locks.delete(key)
+    }
+    async *subscribe(_collection) {}
+}

package/tests/mocks/{s3.ts → s3.js}

@@ -1,66 +1,43 @@
-/**
- * In-memory S3 mock. Replaces src/adapters/s3 so tests never touch real S3
- * or the AWS CLI. Each test file gets a fresh store because mock.module is
- * hoisted before imports, and module-level state is isolated per test file
- * in Bun's test runner.
- *
- * createBucket / deleteBucket are no-ops (bucket creation/deletion is
- * handled implicitly by the in-memory store).
- */
-
-const store = new Map<string, Map<string, string>>()
-
-function getBucket(name: string): Map<string, string> {
+const store = new Map()
+function getBucket(name) {
     if (!store.has(name)) store.set(name, new Map())
-    return store.get(name)!
+    return store.get(name)
 }
-
 export default class S3Mock {
-
-    static readonly BUCKET_ENV = process.env.BUCKET_PREFIX
-
-    static readonly CREDS = {
+    static BUCKET_ENV = process.env.BUCKET_PREFIX
+    static CREDS = {
         accessKeyId: 'mock',
         secretAccessKey: 'mock',
         region: 'mock',
-        endpoint: undefined as string | undefined
+        endpoint: undefined
     }
-
-    static getBucketFormat(collection: string): string {
+    static getBucketFormat(collection) {
         return S3Mock.BUCKET_ENV ? `${S3Mock.BUCKET_ENV}-${collection}` : collection
     }
-
-    static file(collection: string, path: string) {
+    static file(collection, path) {
         const bucket = getBucket(S3Mock.getBucketFormat(collection))
         return {
             get size() {
                 const val = bucket.get(path)
                 return val !== undefined ? val.length : 0
             },
-            async text(): Promise<string> {
+            async text() {
                 return bucket.get(path) ?? ''
             }
         }
     }
-
-    static async list(collection: string, options: {
-        prefix?: string
-        delimiter?: string
-        maxKeys?: number
-        continuationToken?: string
-    } = {}) {
+    static async list(collection, options = {}) {
         const bucket = getBucket(S3Mock.getBucketFormat(collection))
         const prefix = options.prefix ?? ''
         const delimiter = options.delimiter
         const maxKeys = options.maxKeys ?? 1000
         const token = options.continuationToken
-
-        const allKeys = Array.from(bucket.keys()).filter(k => k.startsWith(prefix)).sort()
-
+        const allKeys = Array.from(bucket.keys())
+            .filter((k) => k.startsWith(prefix))
+            .sort()
         if (delimiter) {
-            const prefixSet = new Set<string>()
-            const contents: Array<{ key: string }> = []
-
+            const prefixSet = new Set()
+            const contents = []
             for (const key of allKeys) {
                 const rest = key.slice(prefix.length)
                 const idx = rest.indexOf(delimiter)
@@ -70,45 +47,34 @@ export default class S3Mock {
                     contents.push({ key })
                 }
             }
-
-            const allPrefixes = Array.from(prefixSet).map(p => ({ prefix: p }))
+            const allPrefixes = Array.from(prefixSet).map((p) => ({ prefix: p }))
             const limitedPrefixes = allPrefixes.slice(0, maxKeys)
-
             return {
                 contents: contents.length ? contents : undefined,
-                commonPrefixes: limitedPrefixes.length
-                    ? limitedPrefixes
-                    : undefined,
+                commonPrefixes: limitedPrefixes.length ? limitedPrefixes : undefined,
                 isTruncated: allPrefixes.length > maxKeys,
                 nextContinuationToken: undefined
             }
         }
-
         const startIdx = token ? parseInt(token) : 0
         const page = allKeys.slice(startIdx, startIdx + maxKeys)
-        const nextToken = startIdx + maxKeys < allKeys.length
-            ? String(startIdx + maxKeys)
-            : undefined
-
+        const nextToken =
+            startIdx + maxKeys < allKeys.length ? String(startIdx + maxKeys) : undefined
         return {
-            contents: page.length ? page.map(k => ({ key: k })) : undefined,
+            contents: page.length ? page.map((k) => ({ key: k })) : undefined,
             isTruncated: !!nextToken,
             nextContinuationToken: nextToken,
             commonPrefixes: undefined
         }
     }
-
-    static async put(collection: string, path: string, data: string): Promise<void> {
+    static async put(collection, path, data) {
         getBucket(S3Mock.getBucketFormat(collection)).set(path, data)
     }
-
-    static async delete(collection: string, path: string): Promise<void> {
+    static async delete(collection, path) {
         getBucket(S3Mock.getBucketFormat(collection)).delete(path)
     }
-
-    static async createBucket(_collection: string): Promise<void> {}
-
-    static async deleteBucket(collection: string): Promise<void> {
+    static async createBucket(_collection) {}
+    static async deleteBucket(collection) {
         store.delete(S3Mock.getBucketFormat(collection))
     }
 }

package/tests/schemas/album.json

@@ -2,4 +2,4 @@
     "id": -0,
     "userId": -0,
     "title": ""
-}
+}

package/tests/schemas/comment.json

@@ -4,4 +4,4 @@
     "email": "",
     "body": "",
     "postId": -0
-}
+}

package/tests/schemas/photo.json

@@ -4,4 +4,4 @@
     "title": "",
     "url": "",
     "thumbnailUrl": ""
-}
+}

package/tests/schemas/post.json

@@ -3,4 +3,4 @@
     "userId": -0,
     "title": "",
     "body": ""
-}
+}

package/tests/schemas/tip.json

@@ -4,4 +4,4 @@
     "text": "",
     "date": "",
     "compliment_count": -0
-}
+}

package/tests/schemas/todo.json

@@ -3,4 +3,4 @@
     "userId": -0,
     "title": "",
     "completed": false
-}
+}

package/tests/schemas/user.d.ts

@@ -4,20 +4,20 @@ interface _user {
     username: string
     email: string
     address: {
-    street: string
-    suite: string
-    city: string
-    zipcode: string
-    geo: {
-        lat: string
-        lng: string
+        street: string
+        suite: string
+        city: string
+        zipcode: string
+        geo: {
+            lat: string
+            lng: string
+        }
     }
-}
     phone: string
     website: string
     company: {
-    name: string
-    catchPhrase: string
-    bs: string
-}
+        name: string
+        catchPhrase: string
+        bs: string
+    }
 }

package/tests/schemas/user.json

@@ -20,4 +20,4 @@
         "catchPhrase": "",
         "bs": ""
     }
-}
+}

package/tsconfig.json

@@ -5,7 +5,7 @@
         "target": "ESNext",
         "lib": ["ESNext"],
         "module": "ES2022",
-        "moduleResolution": "node",
+        "moduleResolution": "bundler",
         "sourceMap": true,
         "experimentalDecorators": true,
         "pretty": true,
@@ -15,5 +15,7 @@
         "types": ["bun-types", "node"],
         "isolatedModules": true,
         "skipLibCheck": true
-    }
+    },
+    "include": ["src/**/*"],
+    "exclude": ["dist", "tests", "node_modules"]
 }

package/tsconfig.typecheck.json

@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "target": "ESNext",
+    "lib": ["ESNext", "DOM"],
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "experimentalDecorators": true,
+    "pretty": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitReturns": true,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "skipLibCheck": true,
+    "noEmit": true
+  },
+  "include": [
+    "src/**/*.ts",
+    "src/types/node-runtime.d.ts",
+    "src/types/vendor-modules.d.ts",
+    "src/types/fylo.d.ts",
+    "src/types/query.d.ts",
+    "src/types/bun-runtime.d.ts"
+  ],
+  "exclude": [
+    "dist",
+    "tests",
+    "node_modules",
+    "src/types/index.d.ts"
+  ]
+}

package/tests/collection/truncate.test.ts

@@ -1,56 +0,0 @@
-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<_post>(POSTS, new URL(postsURL))
-
-        await fylo.delDocs<_post>(POSTS)
-
-        const ids: _ttid[] = []
-
-        for await (const data of Fylo.findDocs<_post>(POSTS, { $limit: 1, $onlyIds: true }).collect()) {
-
-            ids.push(data as _ttid)
-        }
-
-        expect(ids.length).toBe(0)
-    })
-})
-
-describe("SQL", () => {
-
-    test("TRUNCATE", async () => {
-
-        const fylo = new Fylo()
-
-        await fylo.executeSQL<_album>(`CREATE TABLE ${ALBUMS}`)
-
-        await fylo.importBulkData<_album>(ALBUMS, new URL(albumURL))
-
-        await fylo.executeSQL<_album>(`DELETE FROM ${ALBUMS}`)
-
-        const ids = await fylo.executeSQL<_album>(`SELECT _id FROM ${ALBUMS} LIMIT 1`) as _ttid[]
-
-        expect(ids.length).toBe(0)
-    })
-})