@delma/fylo 1.0.0

package/tests/integration/update.test.ts

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

package/tests/mocks/cipher.ts

@@ -0,0 +1,55 @@
+/**
+ * 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 {
+        return CipherMock._configured
+    }
+
+    static hasEncryptedFields(collection: string): boolean {
+        const fields = CipherMock.collections.get(collection)
+        return !!fields && fields.size > 0
+    }
+
+    static isEncryptedField(collection: string, field: string): boolean {
+        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 {
+        if (fields.length > 0) {
+            CipherMock.collections.set(collection, new Set(fields))
+        }
+    }
+
+    static async configure(_secret: string): Promise<void> {
+        CipherMock._configured = true
+    }
+
+    static reset(): void {
+        CipherMock._configured = false
+        CipherMock.collections = new Map()
+    }
+
+    static async encrypt(value: string): Promise<string> {
+        return btoa(value).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
+    }
+
+    static async decrypt(encoded: string): Promise<string> {
+        const b64 = encoded.replace(/-/g, '+').replace(/_/g, '/')
+        const padded = b64 + '='.repeat((4 - b64.length % 4) % 4)
+        return atob(padded)
+    }
+}

package/tests/mocks/redis.ts

@@ -0,0 +1,13 @@
+/**
+ * No-op Redis mock. All methods are silent no-ops so tests never need a
+ * running Redis instance. subscribe yields nothing so listener code paths
+ * simply exit immediately.
+ */
+export default class RedisMock {
+
+    async publish(_collection: string, _action: 'insert' | 'delete', _keyId: string | _ttid): Promise<void> {}
+
+    async claimTTID(_id: _ttid, _ttlSeconds: number = 10): Promise<boolean> { return true }
+
+    async *subscribe(_collection: string): AsyncGenerator<never, void, unknown> {}
+}

package/tests/mocks/s3.ts

@@ -0,0 +1,114 @@
+/**
+ * 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> {
+    if (!store.has(name)) store.set(name, new Map())
+    return store.get(name)!
+}
+
+export default class S3Mock {
+
+    static readonly BUCKET_ENV = process.env.BUCKET_PREFIX
+
+    static readonly CREDS = {
+        accessKeyId: 'mock',
+        secretAccessKey: 'mock',
+        region: 'mock',
+        endpoint: undefined as string | undefined
+    }
+
+    static getBucketFormat(collection: string): string {
+        return S3Mock.BUCKET_ENV ? `${S3Mock.BUCKET_ENV}-${collection}` : collection
+    }
+
+    static file(collection: string, path: string) {
+        const bucket = getBucket(S3Mock.getBucketFormat(collection))
+        return {
+            get size() {
+                const val = bucket.get(path)
+                return val !== undefined ? val.length : 0
+            },
+            async text(): Promise<string> {
+                return bucket.get(path) ?? ''
+            }
+        }
+    }
+
+    static async list(collection: string, options: {
+        prefix?: string
+        delimiter?: string
+        maxKeys?: number
+        continuationToken?: string
+    } = {}) {
+        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()
+
+        if (delimiter) {
+            const prefixSet = new Set<string>()
+            const contents: Array<{ key: string }> = []
+
+            for (const key of allKeys) {
+                const rest = key.slice(prefix.length)
+                const idx = rest.indexOf(delimiter)
+                if (idx >= 0) {
+                    prefixSet.add(prefix + rest.slice(0, idx + 1))
+                } else {
+                    contents.push({ key })
+                }
+            }
+
+            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,
+                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
+
+        return {
+            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> {
+        getBucket(S3Mock.getBucketFormat(collection)).set(path, data)
+    }
+
+    static async delete(collection: string, path: string): Promise<void> {
+        getBucket(S3Mock.getBucketFormat(collection)).delete(path)
+    }
+
+    static async createBucket(_collection: string): Promise<void> {}
+
+    static async deleteBucket(collection: string): Promise<void> {
+        store.delete(S3Mock.getBucketFormat(collection))
+    }
+}

package/tests/schemas/album.d.ts

@@ -0,0 +1,5 @@
+interface _album {
+    id: number
+    userId: number
+    title: string
+}

package/tests/schemas/album.json

@@ -0,0 +1,5 @@
+{
+    "id": -0,
+    "userId": -0,
+    "title": ""
+}

package/tests/schemas/comment.d.ts

@@ -0,0 +1,7 @@
+interface _comment {
+    id: number
+    name: string
+    email: string
+    body: string
+    postId: number
+}

package/tests/schemas/comment.json

@@ -0,0 +1,7 @@
+{
+    "id": -0,
+    "name": "",
+    "email": "",
+    "body": "",
+    "postId": -0
+}

package/tests/schemas/photo.d.ts

@@ -0,0 +1,7 @@
+interface _photo {
+    id: number
+    albumId: number
+    title: string
+    url: string
+    thumbnailUrl: string
+}

package/tests/schemas/photo.json

@@ -0,0 +1,7 @@
+{
+    "id": -0,
+    "albumId": -0,
+    "title": "",
+    "url": "",
+    "thumbnailUrl": ""
+}

package/tests/schemas/post.d.ts

@@ -0,0 +1,6 @@
+interface _post {
+    id: number
+    userId: number
+    title: string
+    body: string
+}

package/tests/schemas/post.json

@@ -0,0 +1,6 @@
+{
+    "id": -0,
+    "userId": -0,
+    "title": "",
+    "body": ""
+}

package/tests/schemas/tip.d.ts

@@ -0,0 +1,7 @@
+interface _tip {
+    user_id: string
+    business_id: string
+    text: string
+    date: string
+    compliment_count: number
+}

package/tests/schemas/tip.json

@@ -0,0 +1,7 @@
+{
+    "user_id": "",
+    "business_id": "",
+    "text": "",
+    "date": "",
+    "compliment_count": -0
+}

package/tests/schemas/todo.d.ts

@@ -0,0 +1,6 @@
+interface _todo {
+    id: number
+    userId: number
+    title: string
+    completed: boolean
+}

package/tests/schemas/todo.json

@@ -0,0 +1,6 @@
+{
+    "id": -0,
+    "userId": -0,
+    "title": "",
+    "completed": false
+}

package/tests/schemas/user.d.ts

@@ -0,0 +1,23 @@
+interface _user {
+    id: number
+    name: string
+    username: string
+    email: string
+    address: {
+    street: string
+    suite: string
+    city: string
+    zipcode: string
+    geo: {
+        lat: string
+        lng: string
+    }
+}
+    phone: string
+    website: string
+    company: {
+    name: string
+    catchPhrase: string
+    bs: string
+}
+}

package/tests/schemas/user.json

@@ -0,0 +1,23 @@
+{
+    "id": -0,
+    "name": "",
+    "username": "",
+    "^email$": "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+.[a-zA-Z]{2,}$",
+    "address": {
+        "street": "",
+        "suite": "",
+        "city": "",
+        "zipcode": "",
+        "geo": {
+            "lat": "",
+            "lng": ""
+        }
+    },
+    "phone": "",
+    "website": "",
+    "company": {
+        "name": "",
+        "catchPhrase": "",
+        "bs": ""
+    }
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "strict": true,
+        "outDir": "dist",
+        "target": "ESNext",
+        "lib": ["ESNext"],
+        "module": "ES2022",
+        "moduleResolution": "node",
+        "sourceMap": true,
+        "experimentalDecorators": true,
+        "pretty": true,
+        "noFallthroughCasesInSwitch": true,
+        "noImplicitReturns": true,
+        "forceConsistentCasingInFileNames": true,
+        "types": ["bun-types", "node", "@vyckr/ttid"],
+        "isolatedModules": true,
+        "skipLibCheck": true
+    }
+}