@delma/fylo 1.1.1 → 2.0.0

package/src/migrate-cli.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env bun
+import { migrateLegacyS3ToS3Files } from './migrate'
+
+const [, , ...args] = process.argv
+
+const collections = args.filter((arg) => !arg.startsWith('--'))
+const recreateCollections = !args.includes('--keep-existing')
+const verify = !args.includes('--no-verify')
+
+if (collections.length === 0) {
+    throw new Error(
+        'Usage: fylo.migrate <collection> [collection...] [--keep-existing] [--no-verify]'
+    )
+}
+
+const summary = await migrateLegacyS3ToS3Files({
+    collections,
+    recreateCollections,
+    verify
+})
+
+console.log(JSON.stringify(summary, null, 2))

package/src/migrate.ts

@@ -0,0 +1,74 @@
+import Fylo from './index'
+import { S3FilesEngine } from './engines/s3-files'
+
+type MigrateOptions = {
+    collections: string[]
+    s3FilesRoot?: string
+    recreateCollections?: boolean
+    verify?: boolean
+}
+
+function normalize<T>(value: T): T {
+    if (Array.isArray(value)) return value.map((item) => normalize(item)).sort() as T
+    if (value && typeof value === 'object') {
+        return Object.keys(value as Record<string, unknown>)
+            .sort()
+            .reduce(
+                (acc, key) => {
+                    acc[key] = normalize((value as Record<string, unknown>)[key])
+                    return acc
+                },
+                {} as Record<string, unknown>
+            ) as T
+    }
+    return value
+}
+
+export async function migrateLegacyS3ToS3Files({
+    collections,
+    s3FilesRoot = process.env.FYLO_S3FILES_ROOT,
+    recreateCollections = true,
+    verify = true
+}: MigrateOptions) {
+    if (!s3FilesRoot) throw new Error('s3FilesRoot is required')
+
+    const source = new Fylo({ engine: 'legacy-s3' })
+    const target = new S3FilesEngine(s3FilesRoot)
+
+    const summary: Record<string, { migrated: number; verified: boolean }> = {}
+
+    for (const collection of collections) {
+        if (recreateCollections) {
+            await target.dropCollection(collection)
+            await target.createCollection(collection)
+        } else if (!(await target.hasCollection(collection))) {
+            await target.createCollection(collection)
+        }
+
+        const docs = (await source.executeSQL<Record<string, any>>(
+            `SELECT * FROM ${collection}`
+        )) as Record<_ttid, Record<string, any>>
+
+        for (const [docId, doc] of Object.entries(docs) as Array<[_ttid, Record<string, any>]>) {
+            await target.putDocument(collection, docId, doc)
+        }
+
+        let verified = false
+
+        if (verify) {
+            const targetFylo = new Fylo({ engine: 's3-files', s3FilesRoot })
+            const migratedDocs = (await targetFylo.executeSQL<Record<string, any>>(
+                `SELECT * FROM ${collection}`
+            )) as Record<_ttid, Record<string, any>>
+            verified = JSON.stringify(normalize(docs)) === JSON.stringify(normalize(migratedDocs))
+            if (!verified) throw new Error(`Verification failed for ${collection}`)
+        }
+
+        summary[collection] = {
+            migrated: Object.keys(docs).length,
+            verified
+        }
+    }
+
+    return summary
+}

package/src/types/bun-runtime.d.ts

@@ -0,0 +1,73 @@
+declare namespace Bun {
+    function sleep(ms: number): Promise<void>
+    function randomUUIDv7(): string
+
+    class Glob {
+        constructor(pattern: string)
+        match(input: string): boolean
+    }
+
+    namespace JSONL {
+        function parseChunk(input: Uint8Array): { values: unknown[]; read: number }
+    }
+
+    interface S3ListObjectsOptions {
+        delimiter?: string
+        prefix?: string
+        maxKeys?: number
+        continuationToken?: string
+    }
+
+    interface S3ListObjectsResponse {
+        commonPrefixes?: Array<{ prefix?: string }>
+        contents?: Array<{ key?: string }>
+        isTruncated?: boolean
+        nextContinuationToken?: string
+    }
+}
+
+declare module 'bun' {
+    export const $: (
+        strings: TemplateStringsArray,
+        ...values: any[]
+    ) => {
+        quiet(): Promise<unknown>
+    }
+
+    export class S3Client {
+        static file(path: string, options: Record<string, any>): any
+        static list(
+            options: Bun.S3ListObjectsOptions | undefined,
+            config: Record<string, any>
+        ): Promise<Bun.S3ListObjectsResponse>
+        static write(path: string, data: string, config: Record<string, any>): Promise<void>
+        static delete(path: string, config: Record<string, any>): Promise<void>
+    }
+
+    export class RedisClient {
+        connected: boolean
+        onconnect?: () => void
+        onclose?: (err: Error) => void
+
+        constructor(url: string, options?: Record<string, any>)
+
+        connect(): void
+        send(command: string, args: string[]): Promise<any>
+        publish(channel: string, message: string): Promise<unknown>
+        subscribe(channel: string, listener: (message: string) => void): Promise<void>
+    }
+}
+
+declare module 'bun:sqlite' {
+    export class Database {
+        constructor(filename: string, options?: Record<string, any>)
+        exec(sql: string): void
+        close(): void
+        query(sql: string): {
+            run(...args: any[]): any
+            get(...args: any[]): any
+            all(...args: any[]): any[]
+        }
+        transaction<T extends (...args: any[]) => any>(fn: T): T
+    }
+}

package/src/types/fylo.d.ts

@@ -1,11 +1,15 @@
 interface _getDoc {
-    [Symbol.asyncIterator]<T>(): AsyncGenerator<_ttid | Record<_ttid, T>, void, unknown>;
+    [Symbol.asyncIterator]<T>(): AsyncGenerator<_ttid | Record<_ttid, T>, void, unknown>
     once<T>(): Promise<Record<_ttid, T>>
     onDelete(): AsyncGenerator<_ttid, void, unknown>
 }
 
 interface _findDocs {
-    [Symbol.asyncIterator]<T>(): AsyncGenerator<_ttid | Record<_ttid, T> | Record<string, _ttid[]> | Record<_ttid, Partial<T>> | undefined, void, unknown>
+    [Symbol.asyncIterator]<T>(): AsyncGenerator<
+        _ttid | Record<_ttid, T> | Record<string, _ttid[]> | Record<_ttid, Partial<T>> | undefined,
+        void,
+        unknown
+    >
     once<T>(): Promise<Record<_ttid, T>>
     onDelete(): AsyncGenerator<_ttid, void, unknown>
 }
@@ -17,18 +21,29 @@ interface _queuedWriteResult {
 }
 
 interface ObjectConstructor {
-    appendGroup: (target: Record<string, any>, source: Record<string, any>) => Record<string, any>;
+    appendGroup: (target: Record<string, any>, source: Record<string, any>) => Record<string, any>
 }
 
 interface Console {
     format: (docs: Record<string, any>) => void
 }
 
-type _joinDocs<T, U> = _ttid[] | Record<string, _ttid[]> | Record<string,  Record<_ttid, Partial<T | U>>> | Record<`${_ttid}, ${_ttid}`, T | U | (T & U) | (Partial<T> & Partial<U>)>
+type _joinDocs<T, U> =
+    | _ttid[]
+    | Record<string, _ttid[]>
+    | Record<string, Record<_ttid, Partial<T | U>>>
+    | Record<`${_ttid}, ${_ttid}`, T | U | (T & U) | (Partial<T> & Partial<U>)>
 
-declare module "@delma/fylo" {
+type _fyloEngineKind = 'legacy-s3' | 's3-files'
 
+interface _fyloOptions {
+    engine?: _fyloEngineKind
+    s3FilesRoot?: string
+}
+
+declare module '@delma/fylo' {
     export default class {
+        constructor(options?: _fyloOptions)
 
         /**
          * Rolls back all transcations in current instance
@@ -41,8 +56,10 @@ declare module "@delma/fylo" {
          * @param SQL The SQL query to execute.
          * @returns The results of the query.
          */
-        executeSQL<T extends Record<string, any>, U extends Record<string, any> = {}>(SQL: string): Promise<number | void | any[] | _ttid | Record<any, any>>
-        
+        executeSQL<T extends Record<string, any>, U extends Record<string, any> = {}>(
+            SQL: string
+        ): Promise<number | void | any[] | _ttid | Record<any, any>>
+
         /**
          * Creates a new schema for a collection.
          * @param collection The name of the collection.
@@ -68,7 +85,9 @@ declare module "@delma/fylo" {
          * @param collection The name of the collection.
          * @returns The current data exported from the collection.
          */
-        exportBulkData<T extends Record<string, any>>(collection: string): AsyncGenerator<T, void, unknown>
+        exportBulkData<T extends Record<string, any>>(
+            collection: string
+        ): AsyncGenerator<T, void, unknown>
 
         /**
          * Gets a document from a collection.
@@ -85,11 +104,21 @@ declare module "@delma/fylo" {
          * @param batch The documents to put.
          * @returns The IDs of the documents.
          */
-        batchPutData<T extends Record<string, any>>(collection: string, batch: Array<T>): Promise<_ttid[]>
+        batchPutData<T extends Record<string, any>>(
+            collection: string,
+            batch: Array<T>
+        ): Promise<_ttid[]>
 
-        queuePutData<T extends Record<string, any>>(collection: string, data: Record<_ttid, T> | T): Promise<_queuedWriteResult>
+        queuePutData<T extends Record<string, any>>(
+            collection: string,
+            data: Record<_ttid, T> | T
+        ): Promise<_queuedWriteResult>
 
-        queuePatchDoc<T extends Record<string, any>>(collection: string, newDoc: Record<_ttid, Partial<T>>, oldDoc?: Record<_ttid, T>): Promise<_queuedWriteResult>
+        queuePatchDoc<T extends Record<string, any>>(
+            collection: string,
+            newDoc: Record<_ttid, Partial<T>>,
+            oldDoc?: Record<_ttid, T>
+        ): Promise<_queuedWriteResult>
 
         queueDelDoc(collection: string, _id: _ttid): Promise<_queuedWriteResult>
 
@@ -99,7 +128,7 @@ declare module "@delma/fylo" {
 
         getDeadLetters(count?: number): Promise<Array<Record<string, any>>>
 
-        getQueueStats(): Promise<{ queued: number, pending: number, deadLetters: number }>
+        getQueueStats(): Promise<{ queued: number; pending: number; deadLetters: number }>
 
         replayDeadLetter(streamId: string): Promise<Record<string, any> | null>
 
@@ -112,11 +141,30 @@ declare module "@delma/fylo" {
          * @returns The ID of the document.
          */
         putData<T extends Record<string, any>>(collection: string, data: T): Promise<_ttid>
-        putData<T extends Record<string, any>>(collection: string, data: Record<_ttid, T>): Promise<_ttid>
-        putData<T extends Record<string, any>>(collection: string, data: T, options: { wait?: true, timeoutMs?: number }): Promise<_ttid>
-        putData<T extends Record<string, any>>(collection: string, data: Record<_ttid, T>, options: { wait?: true, timeoutMs?: number }): Promise<_ttid>
-        putData<T extends Record<string, any>>(collection: string, data: T, options: { wait: false, timeoutMs?: number }): Promise<_queuedWriteResult>
-        putData<T extends Record<string, any>>(collection: string, data: Record<_ttid, T>, options: { wait: false, timeoutMs?: number }): Promise<_queuedWriteResult>
+        putData<T extends Record<string, any>>(
+            collection: string,
+            data: Record<_ttid, T>
+        ): Promise<_ttid>
+        putData<T extends Record<string, any>>(
+            collection: string,
+            data: T,
+            options: { wait?: true; timeoutMs?: number }
+        ): Promise<_ttid>
+        putData<T extends Record<string, any>>(
+            collection: string,
+            data: Record<_ttid, T>,
+            options: { wait?: true; timeoutMs?: number }
+        ): Promise<_ttid>
+        putData<T extends Record<string, any>>(
+            collection: string,
+            data: T,
+            options: { wait: false; timeoutMs?: number }
+        ): Promise<_queuedWriteResult>
+        putData<T extends Record<string, any>>(
+            collection: string,
+            data: Record<_ttid, T>,
+            options: { wait: false; timeoutMs?: number }
+        ): Promise<_queuedWriteResult>
 
         /**
          * Patches a document in a collection.
@@ -125,9 +173,23 @@ declare module "@delma/fylo" {
          * @param oldDoc The old document data.
          * @returns The number of documents patched.
          */
-        patchDoc<T extends Record<string, any>>(collection: string, newDoc: Record<_ttid, Partial<T>>, oldDoc?: Record<_ttid, T>): Promise<_ttid>
-        patchDoc<T extends Record<string, any>>(collection: string, newDoc: Record<_ttid, Partial<T>>, oldDoc: Record<_ttid, T> | undefined, options: { wait?: true, timeoutMs?: number }): Promise<_ttid>
-        patchDoc<T extends Record<string, any>>(collection: string, newDoc: Record<_ttid, Partial<T>>, oldDoc: Record<_ttid, T> | undefined, options: { wait: false, timeoutMs?: number }): Promise<_queuedWriteResult>
+        patchDoc<T extends Record<string, any>>(
+            collection: string,
+            newDoc: Record<_ttid, Partial<T>>,
+            oldDoc?: Record<_ttid, T>
+        ): Promise<_ttid>
+        patchDoc<T extends Record<string, any>>(
+            collection: string,
+            newDoc: Record<_ttid, Partial<T>>,
+            oldDoc: Record<_ttid, T> | undefined,
+            options: { wait?: true; timeoutMs?: number }
+        ): Promise<_ttid>
+        patchDoc<T extends Record<string, any>>(
+            collection: string,
+            newDoc: Record<_ttid, Partial<T>>,
+            oldDoc: Record<_ttid, T> | undefined,
+            options: { wait: false; timeoutMs?: number }
+        ): Promise<_queuedWriteResult>
 
         /**
          * Patches documents in a collection.
@@ -135,7 +197,10 @@ declare module "@delma/fylo" {
          * @param updateSchema The update schema.
          * @returns The number of documents patched.
          */
-        patchDocs<T extends Record<string, any>>(collection: string, updateSchema: _storeUpdate<T>): Promise<number>
+        patchDocs<T extends Record<string, any>>(
+            collection: string,
+            updateSchema: _storeUpdate<T>
+        ): Promise<number>
 
         /**
          * Deletes a document from a collection.
@@ -144,8 +209,16 @@ declare module "@delma/fylo" {
          * @returns The number of documents deleted.
          */
         delDoc(collection: string, _id: _ttid): Promise<void>
-        delDoc(collection: string, _id: _ttid, options: { wait?: true, timeoutMs?: number }): Promise<void>
-        delDoc(collection: string, _id: _ttid, options: { wait: false, timeoutMs?: number }): Promise<_queuedWriteResult>
+        delDoc(
+            collection: string,
+            _id: _ttid,
+            options: { wait?: true; timeoutMs?: number }
+        ): Promise<void>
+        delDoc(
+            collection: string,
+            _id: _ttid,
+            options: { wait: false; timeoutMs?: number }
+        ): Promise<_queuedWriteResult>
 
         /**
          * Deletes documents from a collection.
@@ -153,21 +226,36 @@ declare module "@delma/fylo" {
          * @param deleteSchema The delete schema.
          * @returns The number of documents deleted.
          */
-        delDocs<T extends Record<string, any>>(collection: string, deleteSchema?: _storeDelete<T>): Promise<number>
+        delDocs<T extends Record<string, any>>(
+            collection: string,
+            deleteSchema?: _storeDelete<T>
+        ): Promise<number>
 
         /**
          * Joins documents from two collections.
          * @param join The join schema.
          * @returns The joined documents.
          */
-        static joinDocs<T extends Record<string, any>, U extends Record<string, any>>(join: _join<T, U>): Promise<_joinDocs<T, U>>
-        
+        static joinDocs<T extends Record<string, any>, U extends Record<string, any>>(
+            join: _join<T, U>
+        ): Promise<_joinDocs<T, U>>
+
         /**
          * Finds documents in a collection.
          * @param collection The name of the collection.
          * @param query The query schema.
          * @returns The found documents.
          */
-        static findDocs<T extends Record<string, any>>(collection: string, query?: _storeQuery<T>): _findDocs
+        static findDocs<T extends Record<string, any>>(
+            collection: string,
+            query?: _storeQuery<T>
+        ): _findDocs
     }
+
+    export function migrateLegacyS3ToS3Files(options: {
+        collections: string[]
+        s3FilesRoot?: string
+        recreateCollections?: boolean
+        verify?: boolean
+    }): Promise<Record<string, { migrated: number; verified: boolean }>>
 }

package/src/types/node-runtime.d.ts

@@ -0,0 +1,61 @@
+declare const process: {
+    env: Record<string, string | undefined>
+}
+
+declare const Buffer: {
+    alloc(size: number): Uint8Array & {
+        toString(encoding?: string): string
+    }
+}
+
+declare namespace NodeJS {
+    interface ErrnoException extends Error {
+        code?: string
+    }
+}
+
+declare module 'node:path' {
+    const path: {
+        join(...parts: string[]): string
+        dirname(target: string): string
+        basename(target: string, suffix?: string): string
+    }
+
+    export default path
+}
+
+declare module 'node:crypto' {
+    export function createHash(algorithm: string): {
+        update(value: string): {
+            digest(encoding: 'hex'): string
+        }
+    }
+}
+
+declare module 'node:fs/promises' {
+    export function mkdir(path: string, options?: { recursive?: boolean }): Promise<void>
+    export function readFile(path: string, encoding: string): Promise<string>
+    export function readdir(
+        path: string,
+        options?: { withFileTypes?: boolean }
+    ): Promise<
+        Array<{
+            name: string
+            isDirectory(): boolean
+        }>
+    >
+    export function rm(
+        path: string,
+        options?: { recursive?: boolean; force?: boolean }
+    ): Promise<void>
+    export function stat(path: string): Promise<{ size: number }>
+    export function writeFile(path: string, data: string, encoding: string): Promise<void>
+    export function open(
+        path: string,
+        flags: string
+    ): Promise<{
+        write(data: string): Promise<void>
+        read(buffer: Uint8Array, offset: number, length: number, position: number): Promise<void>
+        close(): Promise<void>
+    }>
+}

package/src/types/query.d.ts

@@ -33,7 +33,7 @@ type _join<T, U> = {
     $select?: Array<keyof T | keyof U>
     $leftCollection: string
     $rightCollection: string
-    $mode: "inner" | "left" | "right" | "outer"
+    $mode: 'inner' | 'left' | 'right' | 'outer'
     $on: _on<T, U>
     $limit?: number
     $onlyIds?: boolean
@@ -53,7 +53,11 @@ interface _storeQuery<T extends Record<string, any>> {
     $created?: _timestamp
 }
 
-interface _condition { column: string, operator: string, value: string | number| boolean | null }
+interface _condition {
+    column: string
+    operator: string
+    value: string | number | boolean | null
+}
 
 type _storeUpdate<T extends Record<string, any>> = {
     $collection?: string

package/src/types/vendor-modules.d.ts

@@ -1,5 +1,4 @@
-declare module "@delma/ttid" {
-
+declare module '@delma/ttid' {
     export type _ttid = string | `${string}-${string}` | `${string}-${string}-${string}`
 
     export interface _timestamps {
@@ -16,16 +15,18 @@ declare module "@delma/ttid" {
     }
 }
 
-declare module "@delma/chex" {
-
+declare module '@delma/chex' {
     export default class Gen {
         static generateDeclaration(json: unknown, interfaceName?: string): string
         static sanitizePropertyName(key: string): string
         static fromJsonString(jsonString: string, interfaceName?: string): string
         static fromObject(obj: unknown, interfaceName?: string): string
-        static validateData<T extends Record<string, unknown>>(collection: string, data: T): Promise<T>
+        static validateData<T extends Record<string, unknown>>(
+            collection: string,
+            data: T
+        ): Promise<T>
     }
 }
 
-type _ttid = import("@delma/ttid")._ttid
-type _timestamps = import("@delma/ttid")._timestamps
+type _ttid = import('@delma/ttid')._ttid
+type _timestamps = import('@delma/ttid')._timestamps

package/src/worker.ts

@@ -1,12 +1,18 @@
 #!/usr/bin/env bun
 import { WriteWorker } from './workers/write-worker'
 
+if (process.env.FYLO_STORAGE_ENGINE === 's3-files') {
+    throw new Error('fylo.worker is not supported in s3-files engine')
+}
+
 const worker = new WriteWorker(process.env.FYLO_WORKER_ID)
 
 await worker.run({
     batchSize: process.env.FYLO_WORKER_BATCH_SIZE ? Number(process.env.FYLO_WORKER_BATCH_SIZE) : 1,
     blockMs: process.env.FYLO_WORKER_BLOCK_MS ? Number(process.env.FYLO_WORKER_BLOCK_MS) : 1000,
     recoverOnStart: process.env.FYLO_WORKER_RECOVER_ON_START !== 'false',
-    recoverIdleMs: process.env.FYLO_WORKER_RECOVER_IDLE_MS ? Number(process.env.FYLO_WORKER_RECOVER_IDLE_MS) : 30_000,
+    recoverIdleMs: process.env.FYLO_WORKER_RECOVER_IDLE_MS
+        ? Number(process.env.FYLO_WORKER_RECOVER_IDLE_MS)
+        : 30_000,
     stopWhenIdle: process.env.FYLO_WORKER_STOP_WHEN_IDLE === 'true'
 })

package/src/workers/write-worker.ts

@@ -1,9 +1,8 @@
-import Fylo from "../index"
-import { Redis } from "../adapters/redis"
-import type { StreamJobEntry, WriteJob } from "../types/write-queue"
+import Fylo from '../index'
+import { Redis } from '../adapters/redis'
+import type { StreamJobEntry, WriteJob } from '../types/write-queue'
 
 export class WriteWorker {
-
     private static readonly MAX_WRITE_ATTEMPTS = Number(process.env.FYLO_WRITE_MAX_ATTEMPTS ?? 3)
 
     private static readonly WRITE_RETRY_BASE_MS = Number(process.env.FYLO_WRITE_RETRY_BASE_MS ?? 10)
@@ -22,21 +21,21 @@ export class WriteWorker {
 
     async recoverPending(minIdleMs: number = 30_000, count: number = 10) {
         const jobs = await this.redis.claimPendingJobs(this.workerId, minIdleMs, count)
-        for(const job of jobs) await this.processJob(job)
+        for (const job of jobs) await this.processJob(job)
         return jobs.length
     }
 
     async processNext(count: number = 1, blockMs: number = 1000) {
         const jobs = await this.redis.readWriteJobs(this.workerId, count, blockMs)
-        for(const job of jobs) await this.processJob(job)
+        for (const job of jobs) await this.processJob(job)
         return jobs.length
     }
 
     async processJob({ streamId, job }: StreamJobEntry) {
-        if(job.nextAttemptAt && job.nextAttemptAt > Date.now()) return false
+        if (job.nextAttemptAt && job.nextAttemptAt > Date.now()) return false
 
         const locked = await this.redis.acquireDocLock(job.collection, job.docId, job.jobId)
-        if(!locked) return false
+        if (!locked) return false
 
         try {
             await this.redis.setJobStatus(job.jobId, 'processing', {
@@ -52,29 +51,33 @@ export class WriteWorker {
             await this.redis.ackWriteJob(streamId)
 
             return true
-
-        } catch(err) {
+        } catch (err) {
             const attempts = job.attempts + 1
             const message = err instanceof Error ? err.message : String(err)
 
-            if(attempts >= WriteWorker.MAX_WRITE_ATTEMPTS) {
+            if (attempts >= WriteWorker.MAX_WRITE_ATTEMPTS) {
                 await this.redis.setJobStatus(job.jobId, 'dead-letter', {
                     workerId: this.workerId,
                     attempts,
                     error: message
                 })
                 await this.redis.setDocStatus(job.collection, job.docId, 'dead-letter', job.jobId)
-                await this.redis.deadLetterWriteJob(streamId, {
-                    ...job,
-                    attempts,
-                    status: 'dead-letter',
-                    workerId: this.workerId,
-                    error: message
-                }, message)
+                await this.redis.deadLetterWriteJob(
+                    streamId,
+                    {
+                        ...job,
+                        attempts,
+                        status: 'dead-letter',
+                        workerId: this.workerId,
+                        error: message
+                    },
+                    message
+                )
                 return false
             }
 
-            const nextAttemptAt = Date.now() + (WriteWorker.WRITE_RETRY_BASE_MS * Math.max(1, 2 ** (attempts - 1)))
+            const nextAttemptAt =
+                Date.now() + WriteWorker.WRITE_RETRY_BASE_MS * Math.max(1, 2 ** (attempts - 1))
 
             await this.redis.setJobStatus(job.jobId, 'failed', {
                 workerId: this.workerId,
@@ -85,7 +88,6 @@ export class WriteWorker {
             await this.redis.setDocStatus(job.collection, job.docId, 'failed', job.jobId)
 
             return false
-
         } finally {
             await this.redis.releaseDocLock(job.collection, job.docId, job.jobId)
         }
@@ -108,12 +110,11 @@ export class WriteWorker {
         recoverIdleMs?: number
         stopWhenIdle?: boolean
     } = {}) {
+        if (recoverOnStart) await this.recoverPending(recoverIdleMs, batchSize)
 
-        if(recoverOnStart) await this.recoverPending(recoverIdleMs, batchSize)
-
-        while(true) {
+        while (true) {
             const processed = await this.processNext(batchSize, blockMs)
-            if(stopWhenIdle && processed === 0) break
+            if (stopWhenIdle && processed === 0) break
         }
     }
 }