@delma/fylo 2.1.0 → 2.1.1

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

@@ -1,205 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
-import { mkdtemp, readFile, rm, stat } from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-import Fylo from '../../src'
-const root = await mkdtemp(path.join(os.tmpdir(), 'fylo-s3files-'))
-const fylo = new Fylo({ root })
-const POSTS = 's3files-posts'
-const USERS = 's3files-users'
-describe('s3-files engine', () => {
-    beforeAll(async () => {
-        await fylo.createCollection(POSTS)
-        await fylo.createCollection(USERS)
-    })
-    afterAll(async () => {
-        await rm(root, { recursive: true, force: true })
-    })
-    test('put/get/patch/delete works without Redis or S3 adapters', async () => {
-        const id = await fylo.putData(POSTS, {
-            title: 'Hello',
-            tags: ['bun', 'aws'],
-            meta: { score: 1 }
-        })
-        const created = await fylo.getDoc(POSTS, id).once()
-        expect(created[id].title).toBe('Hello')
-        expect(created[id].tags).toEqual(['bun', 'aws'])
-        const nextId = await fylo.patchDoc(POSTS, {
-            [id]: {
-                title: 'Hello 2',
-                meta: { score: 2 }
-            }
-        })
-        const updated = await fylo.getDoc(POSTS, nextId).once()
-        expect(updated[nextId].title).toBe('Hello 2')
-        expect(updated[nextId].meta.score).toBe(2)
-        expect(await fylo.getDoc(POSTS, id).once()).toEqual({})
-        await fylo.delDoc(POSTS, nextId)
-        expect(await fylo.getDoc(POSTS, nextId).once()).toEqual({})
-    })
-    test('findDocs listener is backed by the filesystem event journal', async () => {
-        const iter = fylo
-            .findDocs(POSTS, {
-                $ops: [{ title: { $eq: 'Live event' } }]
-            })
-            [Symbol.asyncIterator]()
-        const pending = iter.next()
-        await Bun.sleep(100)
-        const id = await fylo.putData(POSTS, { title: 'Live event' })
-        const { value } = await pending
-        expect(value).toEqual({ [id]: { title: 'Live event' } })
-        await iter.return?.()
-    })
-    test('supports long values without path-length issues', async () => {
-        const longBody = 'x'.repeat(5000)
-        const id = await fylo.putData(POSTS, {
-            title: 'Long payload',
-            body: longBody
-        })
-        const result = await fylo.getDoc(POSTS, id).once()
-        expect(result[id].body).toBe(longBody)
-    })
-    test('stores only user document data in the file body', async () => {
-        const id = await fylo.putData(POSTS, {
-            title: 'Lean doc',
-            body: 'payload only'
-        })
-        const raw = JSON.parse(
-            await readFile(
-                path.join(root, POSTS, '.fylo', 'docs', id.slice(0, 2), `${id}.json`),
-                'utf8'
-            )
-        )
-
-        expect(raw).toEqual({
-            title: 'Lean doc',
-            body: 'payload only'
-        })
-        expect(raw.id).toBeUndefined()
-        expect(raw.createdAt).toBeUndefined()
-        expect(raw.updatedAt).toBeUndefined()
-    })
-    test('stores indexes in a single collection file instead of SQLite or per-entry files', async () => {
-        const indexStat = await stat(
-            path.join(root, POSTS, '.fylo', 'indexes', `${POSTS}.idx.json`)
-        )
-        expect(indexStat.isFile()).toBe(true)
-        await expect(stat(path.join(root, POSTS, '.fylo', 'index.db'))).rejects.toThrow()
-    })
-    test('uses the collection index file to support exact, range, and contains queries', async () => {
-        const queryCollection = 's3files-query'
-        await fylo.createCollection(queryCollection)
-
-        const bunId = await fylo.putData(queryCollection, {
-            title: 'Bun launch',
-            tags: ['bun', 'aws'],
-            meta: { score: 10 }
-        })
-        const nodeId = await fylo.putData(queryCollection, {
-            title: 'Node launch',
-            tags: ['node'],
-            meta: { score: 2 }
-        })
-
-        let eqResults = {}
-        for await (const data of fylo
-            .findDocs(queryCollection, {
-                $ops: [{ title: { $eq: 'Bun launch' } }]
-            })
-            .collect()) {
-            eqResults = { ...eqResults, ...data }
-        }
-        expect(Object.keys(eqResults)).toEqual([bunId])
-
-        let rangeResults = {}
-        for await (const data of fylo
-            .findDocs(queryCollection, {
-                $ops: [{ ['meta.score']: { $gte: 5 } }]
-            })
-            .collect()) {
-            rangeResults = { ...rangeResults, ...data }
-        }
-        expect(Object.keys(rangeResults)).toEqual([bunId])
-
-        let containsResults = {}
-        for await (const data of fylo
-            .findDocs(queryCollection, {
-                $ops: [{ tags: { $contains: 'aws' } }]
-            })
-            .collect()) {
-            containsResults = { ...containsResults, ...data }
-        }
-        expect(Object.keys(containsResults)).toEqual([bunId])
-        expect(containsResults[nodeId]).toBeUndefined()
-
-        const index = JSON.parse(
-            await readFile(
-                path.join(root, queryCollection, '.fylo', 'indexes', `${queryCollection}.idx.json`),
-                'utf8'
-            )
-        )
-        const rows = index.docs[bunId]
-
-        expect(rows).toEqual(
-            expect.arrayContaining([
-                expect.objectContaining({
-                    fieldPath: 'title',
-                    rawValue: 'Bun launch',
-                    valueType: 'string',
-                    numericValue: null
-                }),
-                expect.objectContaining({
-                    fieldPath: 'meta/score',
-                    rawValue: '10',
-                    valueType: 'number',
-                    numericValue: 10
-                }),
-                expect.objectContaining({
-                    fieldPath: 'tags/1',
-                    rawValue: 'aws',
-                    valueType: 'string',
-                    numericValue: null
-                })
-            ])
-        )
-    })
-    test('joins work in s3-files mode', async () => {
-        const userId = await fylo.putData(USERS, { id: 42, name: 'Ada' })
-        const postId = await fylo.putData(POSTS, { id: 42, title: 'Shared', content: 'join me' })
-        const joined = await fylo.joinDocs({
-            $leftCollection: USERS,
-            $rightCollection: POSTS,
-            $mode: 'inner',
-            $on: {
-                id: { $eq: 'id' }
-            }
-        })
-        expect(joined[`${userId}, ${postId}`]).toBeDefined()
-    })
-    test('queue APIs are explicitly unsupported', async () => {
-        await expect(fylo.queuePutData(POSTS, { title: 'no queue' })).rejects.toThrow(
-            'queuePutData was removed'
-        )
-        await expect(fylo.processQueuedWrites(1)).rejects.toThrow('processQueuedWrites was removed')
-    })
-    test('rejects collection names that are unsafe for cross-platform filesystems', async () => {
-        await expect(fylo.createCollection('bad/name')).rejects.toThrow('Invalid collection name')
-        await expect(fylo.createCollection('bad\\name')).rejects.toThrow('Invalid collection name')
-        await expect(fylo.createCollection('bad:name')).rejects.toThrow('Invalid collection name')
-    })
-    test('static helpers can use filesystem root env defaults', async () => {
-        const prevFyloRoot = process.env.FYLO_ROOT
-        const prevS3FilesRoot = process.env.FYLO_S3FILES_ROOT
-        process.env.FYLO_ROOT = root
-        process.env.FYLO_S3FILES_ROOT = root
-        const collection = 's3files-static'
-        await Fylo.createCollection(collection)
-        const id = await fylo.putData(collection, { title: 'Static path' })
-        const result = await Fylo.getDoc(collection, id).once()
-        expect(result[id].title).toBe('Static path')
-        if (prevFyloRoot === undefined) delete process.env.FYLO_ROOT
-        else process.env.FYLO_ROOT = prevFyloRoot
-        if (prevS3FilesRoot === undefined) delete process.env.FYLO_S3FILES_ROOT
-        else process.env.FYLO_S3FILES_ROOT = prevS3FilesRoot
-    })
-})

package/tests/integration/sync.test.js

@@ -1,154 +0,0 @@
-import { afterAll, describe, expect, test } from 'bun:test'
-import { mkdtemp, rm } from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-import Fylo, { FyloSyncError } from '../../src'
-
-const roots = []
-
-async function createRoot(prefix) {
-    const root = await mkdtemp(path.join(os.tmpdir(), prefix))
-    roots.push(root)
-    return root
-}
-
-afterAll(async () => {
-    await Promise.all(roots.map((root) => rm(root, { recursive: true, force: true })))
-})
-
-describe('sync hooks', () => {
-    test('await-sync emits write, patch, and delete events with filesystem paths', async () => {
-        const root = await createRoot('fylo-sync-await-')
-        const calls = []
-        const fylo = new Fylo({
-            root,
-            sync: {
-                onWrite: async (event) => {
-                    calls.push({ hook: 'write', ...event })
-                },
-                onDelete: async (event) => {
-                    calls.push({ hook: 'delete', ...event })
-                }
-            }
-        })
-
-        const collection = 'sync-posts'
-        await fylo.createCollection(collection)
-
-        const id = await fylo.putData(collection, { title: 'Hello sync' })
-        const nextId = await fylo.patchDoc(collection, {
-            [id]: { title: 'Hello sync 2' }
-        })
-        await fylo.delDoc(collection, nextId)
-
-        expect(calls).toEqual([
-            {
-                hook: 'write',
-                operation: 'put',
-                collection,
-                docId: id,
-                path: path.join(root, collection, '.fylo', 'docs', id.slice(0, 2), `${id}.json`),
-                data: { title: 'Hello sync' }
-            },
-            {
-                hook: 'delete',
-                operation: 'patch',
-                collection,
-                docId: id,
-                path: path.join(root, collection, '.fylo', 'docs', id.slice(0, 2), `${id}.json`)
-            },
-            {
-                hook: 'write',
-                operation: 'patch',
-                collection,
-                docId: nextId,
-                previousDocId: id,
-                path: path.join(
-                    root,
-                    collection,
-                    '.fylo',
-                    'docs',
-                    nextId.slice(0, 2),
-                    `${nextId}.json`
-                ),
-                data: { title: 'Hello sync 2' }
-            },
-            {
-                hook: 'delete',
-                operation: 'delete',
-                collection,
-                docId: nextId,
-                path: path.join(
-                    root,
-                    collection,
-                    '.fylo',
-                    'docs',
-                    nextId.slice(0, 2),
-                    `${nextId}.json`
-                )
-            }
-        ])
-    })
-
-    test('fire-and-forget does not block the local write', async () => {
-        const root = await createRoot('fylo-sync-fire-')
-        let releaseHook
-        let writeStarted = false
-        const started = Promise.withResolvers()
-        const hookBlocker = new Promise((resolve) => {
-            releaseHook = resolve
-        })
-
-        const fylo = new Fylo({
-            root,
-            syncMode: 'fire-and-forget',
-            sync: {
-                onWrite: async () => {
-                    writeStarted = true
-                    started.resolve()
-                    await hookBlocker
-                }
-            }
-        })
-
-        await fylo.createCollection('fire-posts')
-
-        const putPromise = fylo.putData('fire-posts', { title: 'Fast local write' })
-        await started.promise
-
-        const state = await Promise.race([
-            putPromise.then(() => 'resolved'),
-            Bun.sleep(25).then(() => 'pending')
-        ])
-
-        expect(writeStarted).toBe(true)
-        expect(state).toBe('resolved')
-
-        releaseHook()
-        await putPromise
-    })
-
-    test('await-sync surfaces sync failures as FyloSyncError after the local write', async () => {
-        const root = await createRoot('fylo-sync-error-')
-        let failedDocId
-        const fylo = new Fylo({
-            root,
-            sync: {
-                onWrite: async (event) => {
-                    failedDocId = event.docId
-                    throw new Error('remote unavailable')
-                }
-            }
-        })
-
-        await fylo.createCollection('error-posts')
-
-        await expect(
-            fylo.putData('error-posts', { title: 'Still written locally' })
-        ).rejects.toBeInstanceOf(FyloSyncError)
-
-        expect(failedDocId).toBeDefined()
-        const stored = await fylo.getDoc('error-posts', failedDocId).once()
-        expect(stored[failedDocId]).toEqual({ title: 'Still written locally' })
-    })
-})

package/tests/integration/update.test.js

@@ -1,105 +0,0 @@
-import { test, expect, describe, beforeAll, afterAll } from 'bun:test'
-import { rm } from 'node:fs/promises'
-import Fylo from '../../src'
-import { photosURL, todosURL } from '../data'
-import { createTestRoot } from '../helpers/root'
-const PHOTOS = `photo`
-const TODOS = `todo`
-const root = await createTestRoot('fylo-update-')
-const fylo = new Fylo({ root })
-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}`)])
-    await rm(root, { recursive: true, force: true })
-})
-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.js

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

package/tests/schemas/album.d.ts

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

package/tests/schemas/album.json

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

package/tests/schemas/comment.d.ts

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

package/tests/schemas/comment.json

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

package/tests/schemas/photo.d.ts

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

package/tests/schemas/photo.json

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

package/tests/schemas/post.d.ts

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

package/tests/schemas/post.json

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

package/tests/schemas/tip.d.ts

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

package/tests/schemas/tip.json

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

package/tests/schemas/todo.d.ts

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

package/tests/schemas/todo.json

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

package/tests/schemas/user.d.ts

@@ -1,23 +0,0 @@
-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

@@ -1,23 +0,0 @@
-{
-    "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

@@ -1,21 +0,0 @@
-{
-    "compilerOptions": {
-        "strict": true,
-        "outDir": "dist",
-        "target": "ESNext",
-        "lib": ["ESNext"],
-        "module": "ES2022",
-        "moduleResolution": "bundler",
-        "sourceMap": true,
-        "experimentalDecorators": true,
-        "pretty": true,
-        "noFallthroughCasesInSwitch": true,
-        "noImplicitReturns": true,
-        "forceConsistentCasingInFileNames": true,
-        "types": ["bun-types", "node"],
-        "isolatedModules": true,
-        "skipLibCheck": true
-    },
-    "include": ["src/**/*"],
-    "exclude": ["dist", "tests", "node_modules"]
-}