@delma/fylo 2.0.1 → 2.1.1

package/src/core/query.ts

@@ -1,53 +0,0 @@
-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>
-    ) {
-        let exprs = new Set<string>()
-
-        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)}"`
-                                )
-                            }
-                        }
-                    }
-
-                    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')}/**/*`
-                        )
-                }
-            }
-        } else exprs = new Set([`**/*`])
-
-        return Array.from(exprs)
-    }
-}

package/src/core/walker.ts

@@ -1,174 +0,0 @@
-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
-
-    private static get redis(): Redis {
-        if (!Walker._redis) Walker._redis = new Redis()
-        return Walker._redis
-    }
-
-    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
-
-        let filter = yield
-
-        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 (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)
-                    ) {
-                        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
-                    }
-                }
-            } else {
-                const _id = prefix.split('/').pop()! as _ttid
-
-                yield { _id, data: keys }
-
-                break
-            }
-
-            token = res.nextContinuationToken
-        } 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('/')
-
-            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 }
-                }
-            }
-    }
-
-    static async getDocData(collection: string, _id: _ttid) {
-        const prefix = _id.split('-')[0]
-
-        const data: string[] = []
-
-        let finished = false
-
-        const iter = this.searchS3(collection, prefix)
-
-        do {
-            const { value, done } = await iter.next()
-
-            if (done) {
-                finished = true
-                break
-            }
-
-            if (value) {
-                for (const key of value.data) {
-                    if (key.startsWith(_id + '/')) data.push(key)
-                }
-                finished = true
-                break
-            }
-        } 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)
-            ) {
-                const _id = keyId.split('/').pop()! as _ttid
-
-                if (!stackIds.has(_id)) {
-                    stackIds.add(_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)) {
-                stackIds.delete(keyId)
-            }
-        }
-    }
-
-    static async *listen(collection: string, pattern: string | string[]) {
-        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,59 +0,0 @@
-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> {
-        const now = Date.now()
-
-        return {
-            jobId: Bun.randomUUIDv7(),
-            collection,
-            docId,
-            operation: 'insert',
-            payload,
-            status: 'queued',
-            attempts: 0,
-            createdAt: now,
-            updatedAt: now
-        }
-    }
-
-    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> }> {
-        const now = Date.now()
-
-        return {
-            jobId: Bun.randomUUIDv7(),
-            collection,
-            docId,
-            operation: 'update',
-            payload,
-            status: 'queued',
-            attempts: 0,
-            createdAt: now,
-            updatedAt: now
-        }
-    }
-
-    static createDeleteJob(collection: string, docId: _ttid): WriteJob<{ _id: _ttid }> {
-        const now = Date.now()
-
-        return {
-            jobId: Bun.randomUUIDv7(),
-            collection,
-            docId,
-            operation: 'delete',
-            payload: { _id: docId },
-            status: 'queued',
-            attempts: 0,
-            createdAt: now,
-            updatedAt: now
-        }
-    }
-}