toiljs 0.0.59 → 0.0.60

package/build/devserver/database.js

@@ -1,418 +0,0 @@
-const STORE = new Map();
-const VIEWS = new Map();
-const MEMBERS = new Map();
-const COUNTERS = new Map();
-const EVENTS = new Map();
-const CAPACITY = new Map();
-function capLedger(sk) {
-    let l = CAPACITY.get(sk);
-    if (l === undefined) {
-        l = { total: 0n, confirmed: 0n, holds: new Map(), nextId: 1n };
-        CAPACITY.set(sk, l);
-    }
-    return l;
-}
-function capPrune(l, nowMs) {
-    for (const [id, h] of l.holds)
-        if (h.expiresMs <= nowMs)
-            l.holds.delete(id);
-}
-function capHeld(l) {
-    let sum = 0n;
-    for (const h of l.holds.values())
-        sum += h.amount;
-    return sum;
-}
-const MAX_NAME = 512;
-const MAX_KEY = 4096;
-const MAX_VALUE = 256 * 1024;
-const I64_MIN = -(2n ** 63n);
-const I64_MAX = 2n ** 63n - 1n;
-function satI64(v) {
-    return v < I64_MIN ? I64_MIN : v > I64_MAX ? I64_MAX : v;
-}
-const ABSENT = -2;
-const TOO_SMALL = -1;
-const INVALID_HANDLE = -1001;
-const PRODUCT_ERR = -1000;
-export function freshDbState() {
-    return { handles: [], lastResult: null };
-}
-function mem(ref) {
-    if (!ref.memory)
-        throw new Error('data host import called before memory was bound');
-    return Buffer.from(ref.memory.buffer);
-}
-function readCopy(ref, ptr, len) {
-    const m = mem(ref);
-    if (ptr < 0 || len < 0 || ptr + len > m.length)
-        throw new Error(`data read out of bounds: ptr=${String(ptr)} len=${String(len)}`);
-    return Buffer.from(m.subarray(ptr, ptr + len));
-}
-function storeKey(collection, key) {
-    return collection + '\0' + key.toString('latin1');
-}
-function collOf(db, handle) {
-    return handle >= 0 && handle < db.handles.length ? db.handles[handle] : null;
-}
-export function buildDatabaseImports(ref, db) {
-    return {
-        'data.resolve_collection': (namePtr, nameLen, outHandlePtr) => {
-            if (nameLen < 0 || nameLen > MAX_NAME)
-                throw new Error('data: collection name too long');
-            const name = readCopy(ref, namePtr, nameLen).toString('utf8');
-            const handle = db.handles.length;
-            db.handles.push(name);
-            const m = mem(ref);
-            if (outHandlePtr < 0 || outHandlePtr + 4 > m.length)
-                throw new Error('data: resolve out-handle out of bounds');
-            m.writeUInt32LE(handle, outHandlePtr);
-            return 0;
-        },
-        'data.get': (handle, keyPtr, keyLen) => {
-            const coll = collOf(db, handle);
-            if (coll === null)
-                return INVALID_HANDLE;
-            if (keyLen > MAX_KEY)
-                throw new Error('data: key too long');
-            const v = STORE.get(storeKey(coll, readCopy(ref, keyPtr, keyLen)));
-            if (v === undefined)
-                return ABSENT;
-            db.lastResult = v;
-            return v.length;
-        },
-        'data.get_many': (handle, keysPtr, keysLen) => {
-            const coll = collOf(db, handle);
-            if (coll === null)
-                return INVALID_HANDLE;
-            if (keysLen > MAX_VALUE)
-                throw new Error('data: keys blob too large');
-            const blob = readCopy(ref, keysPtr, keysLen);
-            let off = 0;
-            const count = blob.readUInt32LE(off);
-            off += 4;
-            if (count > 1024)
-                return PRODUCT_ERR;
-            const header = Buffer.alloc(4);
-            header.writeUInt32LE(count, 0);
-            const parts = [header];
-            for (let i = 0; i < count; i++) {
-                const len = blob.readUInt32LE(off);
-                off += 4;
-                const key = blob.subarray(off, off + len);
-                off += len;
-                const v = STORE.get(storeKey(coll, key));
-                if (v === undefined) {
-                    parts.push(Buffer.from([0]));
-                }
-                else {
-                    const h = Buffer.alloc(5);
-                    h.writeUInt8(1, 0);
-                    h.writeUInt32LE(v.length, 1);
-                    parts.push(h, v);
-                }
-            }
-            db.lastResult = Buffer.concat(parts);
-            return db.lastResult.length;
-        },
-        'data.exists': (handle, keyPtr, keyLen) => {
-            const coll = collOf(db, handle);
-            if (coll === null)
-                return INVALID_HANDLE;
-            return STORE.has(storeKey(coll, readCopy(ref, keyPtr, keyLen))) ? 1 : 0;
-        },
-        'data.create': (handle, keyPtr, keyLen, valPtr, valLen, _idemPtr) => {
-            const coll = collOf(db, handle);
-            if (coll === null)
-                return INVALID_HANDLE;
-            if (keyLen > MAX_KEY || valLen > MAX_VALUE)
-                throw new Error('data: key/value too large');
-            const sk = storeKey(coll, readCopy(ref, keyPtr, keyLen));
-            if (STORE.has(sk))
-                return PRODUCT_ERR;
-            STORE.set(sk, readCopy(ref, valPtr, valLen));
-            return 0;
-        },
-        'data.patch': (handle, keyPtr, keyLen, patchPtr, patchLen, _idemPtr) => {
-            const coll = collOf(db, handle);
-            if (coll === null)
-                return INVALID_HANDLE;
-            if (keyLen > MAX_KEY || patchLen > MAX_VALUE)
-                throw new Error('data: key/patch too large');
-            const sk = storeKey(coll, readCopy(ref, keyPtr, keyLen));
-            if (!STORE.has(sk))
-                return PRODUCT_ERR;
-            const v = readCopy(ref, patchPtr, patchLen);
-            STORE.set(sk, v);
-            db.lastResult = v;
-            return v.length;
-        },
-        'data.delete': (handle, keyPtr, keyLen, _idemPtr) => {
-            const coll = collOf(db, handle);
-            if (coll === null)
-                return INVALID_HANDLE;
-            STORE.delete(storeKey(coll, readCopy(ref, keyPtr, keyLen)));
-            return 0;
-        },
-        'data.get_delete': (handle, keyPtr, keyLen, _idemPtr) => {
-            const coll = collOf(db, handle);
-            if (coll === null)
-                return INVALID_HANDLE;
-            const sk = storeKey(coll, readCopy(ref, keyPtr, keyLen));
-            const v = STORE.get(sk);
-            if (v === undefined)
-                return ABSENT;
-            STORE.delete(sk);
-            db.lastResult = v;
-            return v.length;
-        },
-        'data.unique_lookup': (handle, keyPtr, keyLen) => {
-            const coll = collOf(db, handle);
-            if (coll === null)
-                return INVALID_HANDLE;
-            const v = STORE.get(storeKey(coll, readCopy(ref, keyPtr, keyLen)));
-            if (v === undefined)
-                return ABSENT;
-            db.lastResult = v;
-            return v.length;
-        },
-        'data.unique_claim': (handle, keyPtr, keyLen, valPtr, valLen, _idemPtr) => {
-            const coll = collOf(db, handle);
-            if (coll === null)
-                return INVALID_HANDLE;
-            if (keyLen > MAX_KEY || valLen > MAX_VALUE)
-                throw new Error('data: key/value too large');
-            const sk = storeKey(coll, readCopy(ref, keyPtr, keyLen));
-            const owner = readCopy(ref, valPtr, valLen);
-            const existing = STORE.get(sk);
-            if (existing === undefined) {
-                STORE.set(sk, owner);
-                return 0;
-            }
-            if (existing.equals(owner))
-                return 2;
-            db.lastResult = existing;
-            return 1;
-        },
-        'data.unique_release': (handle, keyPtr, keyLen, valPtr, valLen, _idemPtr) => {
-            const coll = collOf(db, handle);
-            if (coll === null)
-                return INVALID_HANDLE;
-            const sk = storeKey(coll, readCopy(ref, keyPtr, keyLen));
-            const existing = STORE.get(sk);
-            if (existing === undefined)
-                return 0;
-            if (!existing.equals(readCopy(ref, valPtr, valLen)))
-                return PRODUCT_ERR;
-            STORE.delete(sk);
-            return 0;
-        },
-        'data.membership_contains': (handle, setPtr, setLen, memberPtr, memberLen) => {
-            const coll = collOf(db, handle);
-            if (coll === null)
-                return INVALID_HANDLE;
-            const set = MEMBERS.get(storeKey(coll, readCopy(ref, setPtr, setLen)));
-            if (set === undefined)
-                return 0;
-            return set.has(readCopy(ref, memberPtr, memberLen).toString('latin1')) ? 1 : 0;
-        },
-        'data.membership_add': (handle, setPtr, setLen, memberPtr, memberLen, _idemPtr) => {
-            const coll = collOf(db, handle);
-            if (coll === null)
-                return INVALID_HANDLE;
-            if (setLen > MAX_KEY || memberLen > MAX_VALUE)
-                throw new Error('data: set/member too large');
-            const sk = storeKey(coll, readCopy(ref, setPtr, setLen));
-            const member = readCopy(ref, memberPtr, memberLen);
-            let set = MEMBERS.get(sk);
-            if (set === undefined) {
-                set = new Map();
-                MEMBERS.set(sk, set);
-            }
-            set.set(member.toString('latin1'), member);
-            return 0;
-        },
-        'data.membership_remove': (handle, setPtr, setLen, memberPtr, memberLen, _idemPtr) => {
-            const coll = collOf(db, handle);
-            if (coll === null)
-                return INVALID_HANDLE;
-            const set = MEMBERS.get(storeKey(coll, readCopy(ref, setPtr, setLen)));
-            if (set !== undefined)
-                set.delete(readCopy(ref, memberPtr, memberLen).toString('latin1'));
-            return 0;
-        },
-        'data.membership_list': (handle, setPtr, setLen, limit) => {
-            const coll = collOf(db, handle);
-            if (coll === null)
-                return INVALID_HANDLE;
-            const set = MEMBERS.get(storeKey(coll, readCopy(ref, setPtr, setLen)));
-            const n = Math.max(0, Math.min(limit, 0xffff));
-            const members = set === undefined ? [] : Array.from(set.values()).sort(Buffer.compare).slice(0, n);
-            const header = Buffer.alloc(4);
-            header.writeUInt32LE(members.length, 0);
-            const parts = [header];
-            for (const m of members) {
-                const h = Buffer.alloc(4);
-                h.writeUInt32LE(m.length, 0);
-                parts.push(h, m);
-            }
-            db.lastResult = Buffer.concat(parts);
-            return db.lastResult.length;
-        },
-        'data.view_get': (handle, keyPtr, keyLen) => {
-            const coll = collOf(db, handle);
-            if (coll === null)
-                return INVALID_HANDLE;
-            const v = VIEWS.get(storeKey(coll, readCopy(ref, keyPtr, keyLen)));
-            if (v === undefined)
-                return ABSENT;
-            db.lastResult = v;
-            return v.length;
-        },
-        'data.view_publish': (handle, keyPtr, keyLen, valPtr, valLen, _idemPtr) => {
-            const coll = collOf(db, handle);
-            if (coll === null)
-                return INVALID_HANDLE;
-            if (keyLen > MAX_KEY || valLen > MAX_VALUE)
-                throw new Error('data: key/view too large');
-            VIEWS.set(storeKey(coll, readCopy(ref, keyPtr, keyLen)), readCopy(ref, valPtr, valLen));
-            return 0;
-        },
-        'data.counter_get': (handle, keyPtr, keyLen) => {
-            const coll = collOf(db, handle);
-            if (coll === null)
-                return INVALID_HANDLE;
-            const sum = COUNTERS.get(storeKey(coll, readCopy(ref, keyPtr, keyLen))) ?? 0n;
-            const out = Buffer.alloc(8);
-            out.writeBigInt64LE(sum);
-            db.lastResult = out;
-            return out.length;
-        },
-        'data.counter_add': (handle, keyPtr, keyLen, delta, _idemPtr) => {
-            const coll = collOf(db, handle);
-            if (coll === null)
-                return INVALID_HANDLE;
-            const sk = storeKey(coll, readCopy(ref, keyPtr, keyLen));
-            COUNTERS.set(sk, satI64((COUNTERS.get(sk) ?? 0n) + BigInt(delta)));
-            return 0;
-        },
-        'data.append': (handle, keyPtr, keyLen, evPtr, evLen, _idemPtr) => {
-            const coll = collOf(db, handle);
-            if (coll === null)
-                return INVALID_HANDLE;
-            if (keyLen > MAX_KEY || evLen > MAX_VALUE)
-                throw new Error('data: key/event too large');
-            const sk = storeKey(coll, readCopy(ref, keyPtr, keyLen));
-            const log = EVENTS.get(sk);
-            const ev = readCopy(ref, evPtr, evLen);
-            if (log === undefined)
-                EVENTS.set(sk, [ev]);
-            else
-                log.push(ev);
-            return 0;
-        },
-        'data.latest': (handle, keyPtr, keyLen, limit) => {
-            const coll = collOf(db, handle);
-            if (coll === null)
-                return INVALID_HANDLE;
-            const log = EVENTS.get(storeKey(coll, readCopy(ref, keyPtr, keyLen))) ?? [];
-            const n = Math.max(0, Math.min(limit, 0xffff));
-            const newest = log.slice(Math.max(0, log.length - n)).reverse();
-            let size = 4;
-            for (const ev of newest)
-                size += 4 + ev.length;
-            const out = Buffer.alloc(size);
-            let off = out.writeUInt32LE(newest.length, 0);
-            for (const ev of newest) {
-                off = out.writeUInt32LE(ev.length, off);
-                off += ev.copy(out, off);
-            }
-            db.lastResult = out;
-            return out.length;
-        },
-        'data.capacity_set_total': (handle, keyPtr, keyLen, total, _idemPtr) => {
-            const coll = collOf(db, handle);
-            if (coll === null)
-                return INVALID_HANDLE;
-            const l = capLedger(storeKey(coll, readCopy(ref, keyPtr, keyLen)));
-            const t = BigInt(total);
-            l.total = satI64(t < 0n ? 0n : t);
-            return 0;
-        },
-        'data.capacity_available': (handle, keyPtr, keyLen) => {
-            const coll = collOf(db, handle);
-            if (coll === null)
-                return INVALID_HANDLE;
-            const l = capLedger(storeKey(coll, readCopy(ref, keyPtr, keyLen)));
-            capPrune(l, Date.now());
-            const avail = l.total - l.confirmed - capHeld(l);
-            const out = Buffer.alloc(8);
-            out.writeBigInt64LE(avail < 0n ? 0n : avail);
-            db.lastResult = out;
-            return out.length;
-        },
-        'data.capacity_reserve': (handle, keyPtr, keyLen, amount, ttlMs, _idemPtr) => {
-            const coll = collOf(db, handle);
-            if (coll === null)
-                return INVALID_HANDLE;
-            const want = BigInt(amount);
-            if (want <= 0n)
-                return ABSENT;
-            const l = capLedger(storeKey(coll, readCopy(ref, keyPtr, keyLen)));
-            const now = Date.now();
-            capPrune(l, now);
-            if (l.total - l.confirmed - capHeld(l) < want)
-                return ABSENT;
-            const id = l.nextId++;
-            l.holds.set(id, { amount: want, expiresMs: now + Math.max(0, Number(ttlMs)) });
-            const out = Buffer.alloc(8);
-            out.writeBigUInt64LE(id);
-            db.lastResult = out;
-            return out.length;
-        },
-        'data.capacity_confirm': (handle, keyPtr, keyLen, reservationId, _idemPtr) => {
-            const coll = collOf(db, handle);
-            if (coll === null)
-                return INVALID_HANDLE;
-            const l = capLedger(storeKey(coll, readCopy(ref, keyPtr, keyLen)));
-            capPrune(l, Date.now());
-            const h = l.holds.get(BigInt(reservationId));
-            if (h === undefined)
-                return 0;
-            l.holds.delete(BigInt(reservationId));
-            l.confirmed = satI64(l.confirmed + h.amount);
-            return 1;
-        },
-        'data.capacity_cancel': (handle, keyPtr, keyLen, reservationId, _idemPtr) => {
-            const coll = collOf(db, handle);
-            if (coll === null)
-                return INVALID_HANDLE;
-            const l = capLedger(storeKey(coll, readCopy(ref, keyPtr, keyLen)));
-            capPrune(l, Date.now());
-            return l.holds.delete(BigInt(reservationId)) ? 1 : 0;
-        },
-        'data.take_result': (outPtr, outCap) => {
-            const v = db.lastResult;
-            if (v === null)
-                return 0;
-            if (v.length > outCap)
-                return TOO_SMALL;
-            const m = mem(ref);
-            if (outPtr < 0 || outPtr + v.length > m.length)
-                throw new Error('data: take_result out of bounds');
-            v.copy(m, outPtr);
-            db.lastResult = null;
-            return v.length;
-        },
-        'data.result_schema_version': () => -1n,
-        'data.write_allowed': () => 1,
-    };
-}
-export function __resetDbForTests() {
-    STORE.clear();
-    VIEWS.clear();
-    MEMBERS.clear();
-    COUNTERS.clear();
-    EVENTS.clear();
-    CAPACITY.clear();
-}