@delma/fylo 2.0.0 → 2.1.0

package/tests/integration/sync.test.js

@@ -0,0 +1,154 @@
+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,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 { photosURL, todosURL } from '../data'
-import S3Mock from '../mocks/s3'
-import RedisMock from '../mocks/redis'
+import { createTestRoot } from '../helpers/root'
 const PHOTOS = `photo`
 const TODOS = `todo`
-const fylo = new Fylo()
-mock.module('../../src/adapters/s3', () => ({ S3: S3Mock }))
-mock.module('../../src/adapters/redis', () => ({ Redis: RedisMock }))
+const root = await createTestRoot('fylo-update-')
+const fylo = new Fylo({ root })
 beforeAll(async () => {
-    await Promise.all([Fylo.createCollection(PHOTOS), fylo.executeSQL(`CREATE TABLE ${TODOS}`)])
+    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)
@@ -18,12 +17,13 @@ beforeAll(async () => {
     }
 })
 afterAll(async () => {
-    await Promise.all([Fylo.dropCollection(PHOTOS), fylo.executeSQL(`DROP TABLE ${TODOS}`)])
+    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()) {
+        for await (const data of fylo.findDocs(PHOTOS, { $limit: 1, $onlyIds: true }).collect()) {
             ids.push(data)
         }
         try {
@@ -32,9 +32,11 @@ describe('NO-SQL', async () => {
             await fylo.rollback()
         }
         let results = {}
-        for await (const data of Fylo.findDocs(PHOTOS, {
-            $ops: [{ title: { $eq: 'All Mighty' } }]
-        }).collect()) {
+        for await (const data of fylo
+            .findDocs(PHOTOS, {
+                $ops: [{ title: { $eq: 'All Mighty' } }]
+            })
+            .collect()) {
             results = { ...results, ...data }
         }
         expect(Object.keys(results).length).toBe(1)
@@ -50,9 +52,11 @@ describe('NO-SQL', async () => {
             await fylo.rollback()
         }
         let results = {}
-        for await (const data of Fylo.findDocs(PHOTOS, {
-            $ops: [{ title: { $eq: 'All Mighti' } }]
-        }).collect()) {
+        for await (const data of fylo
+            .findDocs(PHOTOS, {
+                $ops: [{ title: { $eq: 'All Mighti' } }]
+            })
+            .collect()) {
             results = { ...results, ...data }
         }
         expect(Object.keys(results).length).toBe(count)
@@ -65,9 +69,11 @@ describe('NO-SQL', async () => {
             await fylo.rollback()
         }
         let results = {}
-        for await (const data of Fylo.findDocs(PHOTOS, {
-            $ops: [{ title: { $eq: 'All Mighter' } }]
-        }).collect()) {
+        for await (const data of fylo
+            .findDocs(PHOTOS, {
+                $ops: [{ title: { $eq: 'All Mighter' } }]
+            })
+            .collect()) {
             results = { ...results, ...data }
         }
         expect(Object.keys(results).length).toBe(count)