@delma/fylo 2.0.1 → 2.1.0

package/tests/mocks/redis.js

@@ -1,123 +0,0 @@
-export default class RedisMock {
-    static stream = []
-    static jobs = new Map()
-    static docs = new Map()
-    static locks = new Map()
-    static deadLetters = []
-    static nextId = 0
-    async publish(_collection, _action, _keyId) {}
-    async claimTTID(_id, _ttlSeconds = 10) {
-        return true
-    }
-    async enqueueWrite(job) {
-        RedisMock.jobs.set(job.jobId, { ...job, nextAttemptAt: job.nextAttemptAt ?? Date.now() })
-        RedisMock.docs.set(`fylo:doc:${job.collection}:${job.docId}`, {
-            status: 'queued',
-            lastJobId: job.jobId,
-            updatedAt: String(Date.now())
-        })
-        const streamId = String(++RedisMock.nextId)
-        RedisMock.stream.push({
-            streamId,
-            jobId: job.jobId,
-            collection: job.collection,
-            docId: job.docId,
-            operation: job.operation
-        })
-        return streamId
-    }
-    async readWriteJobs(workerId, count = 1) {
-        const available = RedisMock.stream.filter((entry) => !entry.claimedBy).slice(0, count)
-        for (const entry of available) entry.claimedBy = workerId
-        return available.map((entry) => ({
-            streamId: entry.streamId,
-            job: { ...RedisMock.jobs.get(entry.jobId) }
-        }))
-    }
-    async ackWriteJob(streamId) {
-        RedisMock.stream = RedisMock.stream.filter((item) => item.streamId !== streamId)
-    }
-    async deadLetterWriteJob(streamId, job, reason) {
-        RedisMock.deadLetters.push({
-            streamId: String(RedisMock.deadLetters.length + 1),
-            jobId: job.jobId,
-            reason,
-            failedAt: Date.now()
-        })
-        await this.ackWriteJob(streamId)
-    }
-    async claimPendingJobs(workerId, _minIdleMs = 30000, count = 10) {
-        const pending = RedisMock.stream.filter((entry) => entry.claimedBy).slice(0, count)
-        for (const entry of pending) entry.claimedBy = workerId
-        return pending.map((entry) => ({
-            streamId: entry.streamId,
-            job: { ...RedisMock.jobs.get(entry.jobId) }
-        }))
-    }
-    async setJobStatus(jobId, status, extra = {}) {
-        const job = RedisMock.jobs.get(jobId)
-        if (job) Object.assign(job, extra, { status, updatedAt: Date.now() })
-    }
-    async setDocStatus(collection, docId, status, jobId) {
-        const key = `fylo:doc:${collection}:${docId}`
-        const curr = RedisMock.docs.get(key) ?? {}
-        RedisMock.docs.set(key, {
-            ...curr,
-            status,
-            updatedAt: String(Date.now()),
-            ...(jobId ? { lastJobId: jobId } : {})
-        })
-    }
-    async getJob(jobId) {
-        const job = RedisMock.jobs.get(jobId)
-        return job ? { ...job } : null
-    }
-    async getDocStatus(collection, docId) {
-        return RedisMock.docs.get(`fylo:doc:${collection}:${docId}`) ?? null
-    }
-    async readDeadLetters(count = 10) {
-        return RedisMock.deadLetters.slice(0, count).map((item) => ({
-            streamId: item.streamId,
-            job: { ...RedisMock.jobs.get(item.jobId) },
-            reason: item.reason,
-            failedAt: item.failedAt
-        }))
-    }
-    async replayDeadLetter(streamId) {
-        const item = RedisMock.deadLetters.find((entry) => entry.streamId === streamId)
-        if (!item) return null
-        const job = RedisMock.jobs.get(item.jobId)
-        if (!job) return null
-        const replayed = {
-            ...job,
-            status: 'queued',
-            error: undefined,
-            workerId: undefined,
-            attempts: 0,
-            updatedAt: Date.now(),
-            nextAttemptAt: Date.now()
-        }
-        RedisMock.jobs.set(item.jobId, replayed)
-        await this.enqueueWrite(replayed)
-        RedisMock.deadLetters = RedisMock.deadLetters.filter((entry) => entry.streamId !== streamId)
-        return { ...replayed }
-    }
-    async getQueueStats() {
-        return {
-            queued: RedisMock.stream.length,
-            pending: RedisMock.stream.filter((entry) => entry.claimedBy).length,
-            deadLetters: RedisMock.deadLetters.length
-        }
-    }
-    async acquireDocLock(collection, docId, jobId) {
-        const key = `fylo:lock:${collection}:${docId}`
-        if (RedisMock.locks.has(key)) return false
-        RedisMock.locks.set(key, jobId)
-        return true
-    }
-    async releaseDocLock(collection, docId, jobId) {
-        const key = `fylo:lock:${collection}:${docId}`
-        if (RedisMock.locks.get(key) === jobId) RedisMock.locks.delete(key)
-    }
-    async *subscribe(_collection) {}
-}

package/tests/mocks/s3.js

@@ -1,80 +0,0 @@
-const store = new Map()
-function getBucket(name) {
-    if (!store.has(name)) store.set(name, new Map())
-    return store.get(name)
-}
-export default class S3Mock {
-    static BUCKET_ENV = process.env.BUCKET_PREFIX
-    static CREDS = {
-        accessKeyId: 'mock',
-        secretAccessKey: 'mock',
-        region: 'mock',
-        endpoint: undefined
-    }
-    static getBucketFormat(collection) {
-        return S3Mock.BUCKET_ENV ? `${S3Mock.BUCKET_ENV}-${collection}` : collection
-    }
-    static file(collection, path) {
-        const bucket = getBucket(S3Mock.getBucketFormat(collection))
-        return {
-            get size() {
-                const val = bucket.get(path)
-                return val !== undefined ? val.length : 0
-            },
-            async text() {
-                return bucket.get(path) ?? ''
-            }
-        }
-    }
-    static async list(collection, options = {}) {
-        const bucket = getBucket(S3Mock.getBucketFormat(collection))
-        const prefix = options.prefix ?? ''
-        const delimiter = options.delimiter
-        const maxKeys = options.maxKeys ?? 1000
-        const token = options.continuationToken
-        const allKeys = Array.from(bucket.keys())
-            .filter((k) => k.startsWith(prefix))
-            .sort()
-        if (delimiter) {
-            const prefixSet = new Set()
-            const contents = []
-            for (const key of allKeys) {
-                const rest = key.slice(prefix.length)
-                const idx = rest.indexOf(delimiter)
-                if (idx >= 0) {
-                    prefixSet.add(prefix + rest.slice(0, idx + 1))
-                } else {
-                    contents.push({ key })
-                }
-            }
-            const allPrefixes = Array.from(prefixSet).map((p) => ({ prefix: p }))
-            const limitedPrefixes = allPrefixes.slice(0, maxKeys)
-            return {
-                contents: contents.length ? contents : undefined,
-                commonPrefixes: limitedPrefixes.length ? limitedPrefixes : undefined,
-                isTruncated: allPrefixes.length > maxKeys,
-                nextContinuationToken: undefined
-            }
-        }
-        const startIdx = token ? parseInt(token) : 0
-        const page = allKeys.slice(startIdx, startIdx + maxKeys)
-        const nextToken =
-            startIdx + maxKeys < allKeys.length ? String(startIdx + maxKeys) : undefined
-        return {
-            contents: page.length ? page.map((k) => ({ key: k })) : undefined,
-            isTruncated: !!nextToken,
-            nextContinuationToken: nextToken,
-            commonPrefixes: undefined
-        }
-    }
-    static async put(collection, path, data) {
-        getBucket(S3Mock.getBucketFormat(collection)).set(path, data)
-    }
-    static async delete(collection, path) {
-        getBucket(S3Mock.getBucketFormat(collection)).delete(path)
-    }
-    static async createBucket(_collection) {}
-    static async deleteBucket(collection) {
-        store.delete(S3Mock.getBucketFormat(collection))
-    }
-}