@delma/fylo 1.1.2 → 2.0.1

package/src/core/query.ts

@@ -1,46 +1,51 @@
-import { Cipher } from "../adapters/cipher"
+import { Cipher } from '../adapters/cipher'
 
 const ENCRYPTED_FIELD_OPS = ['$ne', '$gt', '$gte', '$lt', '$lte', '$like', '$contains'] as const
 
 export class Query {
-
-    static async getExprs<T extends Record<string, any>>(collection: string, query: _storeQuery<T>) {
-
+    static async getExprs<T extends Record<string, any>>(
+        collection: string,
+        query: _storeQuery<T>
+    ) {
         let exprs = new Set<string>()
 
-        if(query.$ops) {
-
-            for(const op of query.$ops) {
-
-                for(const column in op) {
-
+        if (query.$ops) {
+            for (const op of query.$ops) {
+                for (const column in op) {
                     const col = op[column as keyof T]!
 
                     const fieldPath = String(column).replaceAll('.', '/')
-                    const encrypted = Cipher.isConfigured() && Cipher.isEncryptedField(collection, fieldPath)
-
-                    if(encrypted) {
-                        for(const opKey of ENCRYPTED_FIELD_OPS) {
-                            if(col[opKey] !== undefined) {
-                                throw new Error(`Operator ${opKey} is not supported on encrypted field "${String(column)}"`)
+                    const encrypted =
+                        Cipher.isConfigured() && Cipher.isEncryptedField(collection, fieldPath)
+
+                    if (encrypted) {
+                        for (const opKey of ENCRYPTED_FIELD_OPS) {
+                            if (col[opKey] !== undefined) {
+                                throw new Error(
+                                    `Operator ${opKey} is not supported on encrypted field "${String(column)}"`
+                                )
                             }
                         }
                     }
 
-                    if(col.$eq) {
-                        const val = encrypted ? await Cipher.encrypt(String(col.$eq).replaceAll('/', '%2F')) : col.$eq
+                    if (col.$eq) {
+                        const val = encrypted
+                            ? await Cipher.encrypt(String(col.$eq).replaceAll('/', '%2F'))
+                            : col.$eq
                         exprs.add(`${column}/${val}/**/*`)
                     }
-                    if(col.$ne) exprs.add(`${column}/**/*`)
-                    if(col.$gt) exprs.add(`${column}/**/*`)
-                    if(col.$gte) exprs.add(`${column}/**/*`)
-                    if(col.$lt) exprs.add(`${column}/**/*`)
-                    if(col.$lte) exprs.add(`${column}/**/*`)
-                    if(col.$like) exprs.add(`${column}/${col.$like.replaceAll('%', '*')}/**/*`)
-                    if(col.$contains !== undefined) exprs.add(`${column}/*/${String(col.$contains).split('/').join('%2F')}/**/*`)
+                    if (col.$ne) exprs.add(`${column}/**/*`)
+                    if (col.$gt) exprs.add(`${column}/**/*`)
+                    if (col.$gte) exprs.add(`${column}/**/*`)
+                    if (col.$lt) exprs.add(`${column}/**/*`)
+                    if (col.$lte) exprs.add(`${column}/**/*`)
+                    if (col.$like) exprs.add(`${column}/${col.$like.replaceAll('%', '*')}/**/*`)
+                    if (col.$contains !== undefined)
+                        exprs.add(
+                            `${column}/*/${String(col.$contains).split('/').join('%2F')}/**/*`
+                        )
                 }
             }
-
         } else exprs = new Set([`**/*`])
 
         return Array.from(exprs)

package/src/core/walker.ts

@@ -1,9 +1,8 @@
-import { S3 } from "../adapters/s3"
-import TTID from "@delma/ttid"
-import { Redis } from "../adapters/redis"
+import { S3 } from '../adapters/s3'
+import TTID from '@delma/ttid'
+import { Redis } from '../adapters/redis'
 
 export class Walker {
-
     private static readonly MAX_KEYS = 1000
 
     private static _redis: Redis | null = null
@@ -13,8 +12,15 @@ export class Walker {
         return Walker._redis
     }
 
-    private static async *searchS3(collection: string, prefix: string, pattern?: string): AsyncGenerator<{ _id: _ttid, data: string[] } | void, void, { count: number, limit?: number  }> {
-
+    private static async *searchS3(
+        collection: string,
+        prefix: string,
+        pattern?: string
+    ): AsyncGenerator<
+        { _id: _ttid; data: string[] } | void,
+        void,
+        { count: number; limit?: number }
+    > {
         const uniqueIds = new Set<string>()
 
         let token: string | undefined
@@ -24,39 +30,38 @@ export class Walker {
         let limit = filter ? filter.limit : this.MAX_KEYS
 
         do {
-
             const res = await S3.list(collection, {
                 prefix,
                 maxKeys: pattern ? limit : undefined,
                 continuationToken: token
             })
 
-            if(res.contents === undefined) break
-
-            const keys = res.contents.map(item => item.key!)
+            if (res.contents === undefined) break
 
-            if(pattern) {
-
-                for(const key of keys) {
+            const keys = res.contents.map((item) => item.key!)
 
+            if (pattern) {
+                for (const key of keys) {
                     const segements = key.split('/')
 
                     const _id = segements.pop()! as _ttid
 
-                    if((TTID.isTTID(_id) && !uniqueIds.has(_id)) && pattern.length <= 1024 && new Bun.Glob(pattern).match(key)) {
-
+                    if (
+                        TTID.isTTID(_id) &&
+                        !uniqueIds.has(_id) &&
+                        pattern.length <= 1024 &&
+                        new Bun.Glob(pattern).match(key)
+                    ) {
                         filter = yield { _id, data: await this.getDocData(collection, _id) }
 
                         limit = filter.limit ? filter.limit : this.MAX_KEYS
 
                         uniqueIds.add(_id)
 
-                        if(filter.count === limit) break
+                        if (filter.count === limit) break
                     }
                 }
-
             } else {
-
                 const _id = prefix.split('/').pop()! as _ttid
 
                 yield { _id, data: keys }
@@ -65,35 +70,41 @@ export class Walker {
             }
 
             token = res.nextContinuationToken
-
-        } while(token !== undefined)
+        } while (token !== undefined)
     }
 
-    static async *search(collection: string, pattern: string, { listen = false, skip = false }: { listen: boolean, skip: boolean }, action: "insert" | "delete" = "insert"): AsyncGenerator<{ _id: _ttid, data: string[] } | void, void, { count: number, limit?: number  }> {
-
-        if(!skip) {
-            const segments = pattern.split('/');
-            const idx = segments.findIndex(seg => seg.includes('*'));
-            const prefix = segments.slice(0, idx).join('/');
+    static async *search(
+        collection: string,
+        pattern: string,
+        { listen = false, skip = false }: { listen: boolean; skip: boolean },
+        action: 'insert' | 'delete' = 'insert'
+    ): AsyncGenerator<
+        { _id: _ttid; data: string[] } | void,
+        void,
+        { count: number; limit?: number }
+    > {
+        if (!skip) {
+            const segments = pattern.split('/')
+            const idx = segments.findIndex((seg) => seg.includes('*'))
+            const prefix = segments.slice(0, idx).join('/')
 
             yield* this.searchS3(collection, prefix, pattern)
         }
 
         const eventIds = new Set<string>()
 
-        if(listen) for await (const event of this.listen(collection, pattern)) {
-
-            if(event.action !== action && eventIds.has(event.id))  {
-                eventIds.delete(event.id)
-            } else if(event.action === action && !eventIds.has(event.id)) {
-                eventIds.add(event.id)
-                yield { _id: event.id, data: event.data }
+        if (listen)
+            for await (const event of this.listen(collection, pattern)) {
+                if (event.action !== action && eventIds.has(event.id)) {
+                    eventIds.delete(event.id)
+                } else if (event.action === action && !eventIds.has(event.id)) {
+                    eventIds.add(event.id)
+                    yield { _id: event.id, data: event.data }
+                }
             }
-        }
     }
 
     static async getDocData(collection: string, _id: _ttid) {
-
         const prefix = _id.split('-')[0]
 
         const data: string[] = []
@@ -103,63 +114,59 @@ export class Walker {
         const iter = this.searchS3(collection, prefix)
 
         do {
-
             const { value, done } = await iter.next()
 
-            if(done) {
+            if (done) {
                 finished = true
                 break
             }
 
-            if(value) {
-                for(const key of value.data) {
-                    if(key.startsWith(_id + '/')) data.push(key)
+            if (value) {
+                for (const key of value.data) {
+                    if (key.startsWith(_id + '/')) data.push(key)
                 }
                 finished = true
                 break
             }
-
-        } while(!finished)
+        } while (!finished)
 
         return data
     }
 
     private static async *processPattern(collection: string, pattern: string) {
-
         const stackIds = new Set<string>()
 
         for await (const { action, keyId } of Walker.redis.subscribe(collection)) {
-
-            if(action === 'insert' && !TTID.isTTID(keyId) && pattern.length <= 1024 && new Bun.Glob(pattern).match(keyId)) {
-
+            if (
+                action === 'insert' &&
+                !TTID.isTTID(keyId) &&
+                pattern.length <= 1024 &&
+                new Bun.Glob(pattern).match(keyId)
+            ) {
                 const _id = keyId.split('/').pop()! as _ttid
 
-                if(!stackIds.has(_id)) {
-
+                if (!stackIds.has(_id)) {
                     stackIds.add(_id)
 
-                    yield { id: _id, action: "insert", data: await this.getDocData(collection, _id) }
+                    yield {
+                        id: _id,
+                        action: 'insert',
+                        data: await this.getDocData(collection, _id)
+                    }
                 }
-
-            } else if(action === 'delete' && TTID.isTTID(keyId)) {
-
-                yield { id: keyId as _ttid, action: "delete", data: [] }
-
-            } else if(TTID.isTTID(keyId) && stackIds.has(keyId)) {
-
+            } else if (action === 'delete' && TTID.isTTID(keyId)) {
+                yield { id: keyId as _ttid, action: 'delete', data: [] }
+            } else if (TTID.isTTID(keyId) && stackIds.has(keyId)) {
                 stackIds.delete(keyId)
             }
         }
     }
 
     static async *listen(collection: string, pattern: string | string[]) {
-
-        if(Array.isArray(pattern)) {
-
-            for(const p of pattern) {
+        if (Array.isArray(pattern)) {
+            for (const p of pattern) {
                 for await (const event of this.processPattern(collection, p)) yield event
             }
-
         } else {
             for await (const event of this.processPattern(collection, pattern)) yield event
         }

package/src/core/write-queue.ts

@@ -1,8 +1,11 @@
 import type { WriteJob } from '../types/write-queue'
 
 export class WriteQueue {
-
-    static createInsertJob<T extends Record<string, any>>(collection: string, docId: _ttid, payload: T): WriteJob<T> {
+    static createInsertJob<T extends Record<string, any>>(
+        collection: string,
+        docId: _ttid,
+        payload: T
+    ): WriteJob<T> {
         const now = Date.now()
 
         return {
@@ -21,8 +24,8 @@ export class WriteQueue {
     static createUpdateJob<T extends Record<string, any>>(
         collection: string,
         docId: _ttid,
-        payload: { newDoc: Record<_ttid, Partial<T>>, oldDoc?: Record<_ttid, T> }
-    ): WriteJob<{ newDoc: Record<_ttid, Partial<T>>, oldDoc?: Record<_ttid, T> }> {
+        payload: { newDoc: Record<_ttid, Partial<T>>; oldDoc?: Record<_ttid, T> }
+    ): WriteJob<{ newDoc: Record<_ttid, Partial<T>>; oldDoc?: Record<_ttid, T> }> {
         const now = Date.now()
 
         return {