@prestack/thread 0.1.3 → 0.1.5

package/dist/operations/memory.js

@@ -1,365 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { backoffMs, isExhausted } from "./queue-policy.js";
-function projectRow(row, fields, key) {
-    const keep = new Set([key, 'version', ...fields]);
-    const projected = {};
-    for (const [name, value] of Object.entries(row)) {
-        if (keep.has(name))
-            projected[name] = value;
-    }
-    return projected;
-}
-export class UnknownColumnError extends Error {
-    constructor(entity, key) {
-        super(`${entity} does not declare "${key}", so writing it would be silently discarded. ` +
-            'Declare the field or relation on the entity, or stop writing the key.');
-        this.name = 'UnknownColumnError';
-    }
-}
-export class VersionConflictError extends Error {
-    constructor(entity, id, expectedVersion) {
-        super(`${entity} ${id} was not at version ${expectedVersion} — someone else changed it first. ` +
-            're-read the row and retry with its current ETag.');
-        this.name = 'VersionConflictError';
-    }
-}
-export class MemoryStore {
-    data = new Map();
-    declared;
-    keys;
-    constructor(declared, keys) {
-        this.declared = declared ?? new Map();
-        this.keys = keys ?? new Map();
-    }
-    keyOf(entity) {
-        const held = this.keys.get(entity);
-        if (held === undefined) {
-            throw new Error(`nothing told this store which value identifies a ${entity}, so it cannot find one row rather than all of ` +
-                'them. An entity states that with a `unique` invariant over one of its values, and whatever builds this ' +
-                'store passes those along with the columns each entity declares.');
-        }
-        return held;
-    }
-    static SYSTEM = new Set(['version']);
-    assertDeclared(entity, row) {
-        const allowed = this.declared.get(entity);
-        if (allowed === undefined)
-            return;
-        for (const key of Object.keys(row)) {
-            if (allowed.has(key) || MemoryStore.SYSTEM.has(key))
-                continue;
-            throw new UnknownColumnError(entity, key);
-        }
-    }
-    depth = 0;
-    async transaction(_actor, fn) {
-        if (this.depth > 0)
-            return fn();
-        const snapshot = new Map();
-        for (const [key, rows] of this.data)
-            snapshot.set(key, rows.map((r) => ({ ...r })));
-        this.depth += 1;
-        try {
-            return await fn();
-        }
-        catch (err) {
-            this.data = snapshot;
-            throw err;
-        }
-        finally {
-            this.depth -= 1;
-        }
-    }
-    async insert(_actor, entity, row) {
-        this.assertDeclared(entity, row);
-        const rows = this.data.get(entity) ?? [];
-        const rec = { ...row, version: 1 };
-        rows.push(rec);
-        this.data.set(entity, rows);
-        return { ...rec };
-    }
-    async get(_actor, entity, key, fields) {
-        const named = this.keyOf(entity);
-        const row = this.data.get(entity)?.find((r) => r[named] === key) ?? null;
-        return row === null ? null : projectRow(row, fields, named);
-    }
-    async list(_actor, entity, opts) {
-        const all = this.data.get(entity) ?? [];
-        const where = Object.entries(opts?.where ?? {});
-        for (const [field] of where)
-            this.assertDeclared(entity, { [field]: null });
-        const matched = where.length === 0 ? all : all.filter((row) => where.every(([f, v]) => (row[f] ?? null) === v));
-        return opts?.limit ? matched.slice(0, opts.limit).map((r) => ({ ...r })) : matched.map((r) => ({ ...r }));
-    }
-    async update(_actor, entity, key, patch, expectedVersion) {
-        this.assertDeclared(entity, patch);
-        const named = this.keyOf(entity);
-        const rows = this.data.get(entity) ?? [];
-        const i = rows.findIndex((r) => r[named] === key);
-        const cur = rows[i];
-        if (i < 0 || !cur)
-            throw new Error(`record ${String(key)} not found`);
-        const currentVersion = typeof cur['version'] === 'number' ? cur['version'] : 1;
-        if (expectedVersion !== undefined && expectedVersion !== currentVersion) {
-            throw new VersionConflictError(entity, String(key), expectedVersion);
-        }
-        const next = { ...cur, ...patch, [named]: key, version: currentVersion + 1 };
-        rows[i] = next;
-        return { ...next };
-    }
-    async remove(_actor, entity, key) {
-        const named = this.keyOf(entity);
-        this.data.set(entity, (this.data.get(entity) ?? []).filter((r) => r[named] !== key));
-    }
-}
-export class MemoryQueue {
-    jobs = new Map();
-    dead = [];
-    seq = 0;
-    async enqueue(actor, kind, payload, opts) {
-        if (opts?.dedupeKey) {
-            for (const [id, job] of this.jobs) {
-                if (job.dedupeKey === opts.dedupeKey)
-                    return id;
-            }
-        }
-        const id = `job_${++this.seq}`;
-        this.jobs.set(id, {
-            id,
-            kind,
-            payload,
-            attempts: 0,
-            runAt: opts?.runAt ?? 0,
-            claimed: false,
-            dedupeKey: opts?.dedupeKey,
-            actor,
-        });
-        return id;
-    }
-    async poll(kinds, limit, now) {
-        const due = [];
-        for (const job of this.jobs.values()) {
-            if (due.length >= limit)
-                break;
-            if (job.claimed || !kinds.includes(job.kind) || job.runAt > now)
-                continue;
-            job.claimed = true;
-            due.push({ ...job });
-        }
-        return due;
-    }
-    async ack(id) {
-        this.jobs.delete(id);
-    }
-    async fail(id, error, now) {
-        const job = this.jobs.get(id);
-        if (!job)
-            return;
-        job.attempts += 1;
-        job.claimed = false;
-        if (isExhausted(job.attempts)) {
-            this.dead.push({ ...job });
-            this.jobs.delete(id);
-            return;
-        }
-        job.runAt = now + backoffMs(job.attempts);
-        void error;
-    }
-    async deadLetter(id, error) {
-        const job = this.jobs.get(id);
-        if (!job)
-            return;
-        this.dead.push({ ...job });
-        this.jobs.delete(id);
-        void error;
-    }
-    async deadLetters() {
-        return this.dead.map((j) => ({ ...j }));
-    }
-}
-export class MemoryIdempotency {
-    records;
-    onCheck;
-    constructor(opts) {
-        this.records = opts.records ?? new Map();
-        this.onCheck = opts.onCheck;
-    }
-    keyFor(key, action) {
-        return `${key}:${action}`;
-    }
-    async check(key, action) {
-        this.onCheck?.();
-        if (!key)
-            return null;
-        const k = this.keyFor(key, action);
-        return this.records.has(k) ? (this.records.get(k) ?? null) : null;
-    }
-    async store(key, action, output) {
-        if (!key)
-            return;
-        const k = this.keyFor(key, action);
-        if (!this.records.has(k))
-            this.records.set(k, output);
-    }
-}
-export function memoryVault(seed = {}) {
-    return {
-        async resolve(refs) {
-            const found = {};
-            for (const ref of refs) {
-                const value = seed[ref];
-                if (value === undefined)
-                    throw new Error(`vault has no value for "${ref}"`);
-                found[ref] = value;
-            }
-            return found;
-        },
-    };
-}
-export const arrived = () => Date.now();
-export const fresh = () => randomUUID();
-export function inMemorySeams(opts) {
-    const sink = {
-        logs: [], events: [], audits: [], errors: [], costs: [], indexed: [], spans: [],
-        outbox: [], gateOrder: [], quota: { reserved: [], committed: [], released: 0 },
-        files: [], queries: [],
-    };
-    const store = new MemoryStore(opts?.entities, opts?.keys);
-    const queue = new MemoryQueue();
-    const searchIdx = new Map();
-    const telemetry = {
-        start(action) {
-            let status = 'ok';
-            return {
-                ok() { status = 'ok'; },
-                error() { status = 'error'; },
-                end() { sink.spans.push({ action, status }); },
-            };
-        },
-    };
-    const log = { write(level, action, _actor, data) { sink.logs.push({ level, action, data }); } };
-    const audit = { async append(_actor, record) { sink.audits.push(record); } };
-    const errors = { async record(_actor, record) { sink.errors.push(record); } };
-    const cost = { meter(action) { sink.costs.push(action); } };
-    const events = { async publish(e) { sink.events.push(e); } };
-    const rateLimiter = {
-        async check() {
-            sink.gateOrder.push('rate');
-            return opts?.allowRate ?? true;
-        },
-        async checkPolicy() {
-            sink.gateOrder.push('rate');
-            return opts?.allowRate ?? true;
-        },
-    };
-    const featureGate = opts?.features === undefined
-        ? undefined
-        : {
-            async check(_actor, feature) {
-                sink.gateOrder.push('feature');
-                return (opts.features ?? []).includes(feature);
-            },
-        };
-    const used = new Map();
-    const quotas = opts?.quota === undefined
-        ? undefined
-        : {
-            async reserve(_actor, meter, estimate) {
-                sink.gateOrder.push('quota');
-                sink.quota.reserved.push(estimate);
-                const allowance = opts.quota?.[meter] ?? Number.POSITIVE_INFINITY;
-                const before = used.get(meter) ?? 0;
-                if (before + estimate > allowance) {
-                    return {
-                        ok: false,
-                        behavior: opts.onExceed ?? 'block',
-                        retryAfterSeconds: 60,
-                        async commit() { },
-                        async release() { },
-                    };
-                }
-                used.set(meter, before + estimate);
-                let settled = false;
-                return {
-                    ok: true,
-                    behavior: null,
-                    retryAfterSeconds: 0,
-                    async commit(actual) {
-                        if (settled)
-                            return;
-                        settled = true;
-                        sink.quota.committed.push(actual);
-                        used.set(meter, (used.get(meter) ?? 0) - estimate + actual);
-                    },
-                    async release() {
-                        if (settled)
-                            return;
-                        settled = true;
-                        sink.quota.released += 1;
-                        used.set(meter, (used.get(meter) ?? 0) - estimate);
-                    },
-                };
-            },
-        };
-    const outbox = {
-        async emit(_actor, event) {
-            sink.outbox.push(event);
-        },
-    };
-    const idempotency = new MemoryIdempotency({
-        onCheck: () => sink.gateOrder.push('idempotency'),
-    });
-    const search = {
-        async index(_actor, entity, row) {
-            sink.indexed.push({ entity, row });
-            searchIdx.set(entity, [...(searchIdx.get(entity) ?? []), row]);
-        },
-        async query(_actor, entity, q) {
-            const needle = q.toLowerCase();
-            return (searchIdx.get(entity) ?? []).filter((r) => JSON.stringify(r).toLowerCase().includes(needle));
-        },
-    };
-    const vault = opts?.secrets === undefined ? undefined : memoryVault(opts.secrets);
-    const stored = new Map();
-    const files = {
-        async put(_actor, key, body, contentType) {
-            stored.set(key, { body, contentType });
-            sink.files.push({ action: 'put', key, bytes: body.byteLength });
-            return { size: body.byteLength };
-        },
-        async get(_actor, key) {
-            const found = stored.get(key);
-            sink.files.push({ action: 'get', key, bytes: found === undefined ? null : found.body.byteLength });
-            return found === undefined ? null : { body: found.body, contentType: found.contentType };
-        },
-        async signedUrl(_actor, key, expiresInSeconds) {
-            sink.files.push({ action: 'signed', key, bytes: null });
-            return `https://files.invalid/unsigned-in-memory/${encodeURIComponent(key)}?expires_in=${String(expiresInSeconds)}`;
-        },
-        async remove(_actor, key) {
-            stored.delete(key);
-            sink.files.push({ action: 'remove', key, bytes: null });
-        },
-    };
-    const answers = opts?.views;
-    const views = answers === undefined
-        ? undefined
-        : {
-            async query(_actor, sql, params) {
-                const found = (answers[sql] ?? []);
-                sink.queries.push({ sql, params, rows: found.length });
-                return found;
-            },
-        };
-    return {
-        seams: {
-            store, telemetry, log, audit, errors, search, cost, idempotency, events, rateLimiter, queue,
-            outbox, files, clock: { now: arrived }, random: { next: Math.random, uuid: fresh },
-            ...(featureGate ? { featureGate } : {}),
-            ...(quotas ? { quotas } : {}),
-            ...(vault ? { vault } : {}),
-            ...(views ? { views } : {}),
-        },
-        sink, store, queue,
-    };
-}