sliftutils 1.7.99 → 1.7.100

package/storage/dist/TransactionFile.ts.cache

@@ -0,0 +1,212 @@
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.TransactionFile = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const caching_1 = require("socket-function/src/caching");
+// A persistent Map that knows about time and about deletions. Every value carries the time it was written, so a write that arrives out of order is simply not applied - the map cannot be made to go backwards. A deleted key keeps its time too, as a tombstone in a second map, so "was this deleted, and when" is as cheap to ask as "does this exist", and expiring old tombstones is a walk of the tombstones alone rather than of everything.
+//
+// On disk it is one append-only log of the sets, deletes and purges that produced both maps, rewritten from them whenever it has grown to several times their size.
+// The log is rewritten once it holds this many times more records than there are keys (a log of 3 records per surviving key is mostly history)
+const COMPACT_RATIO = 3;
+// ...but never for a small log, where the rewrite would cost more than the history it removes
+const MIN_COMPACT_RECORDS = 1000;
+// Appends are coalesced for this long. A crash loses at most this much - the callers of this class treat their data as reconstructible - and the alternative is a file write per set.
+const FLUSH_DELAY = 500;
+class TransactionFile {
+    constructor(filePath) {
+        this.filePath = filePath;
+        this.values = new Map();
+        this.deleted = new Map();
+        // Records the log holds (written plus pending) - what compaction is decided against, NOT the number of keys
+        this.logRecords = 0;
+        this.pending = [];
+        // Serializes everything that touches the file, so an append can never interleave with a rewrite
+        this.writeChain = Promise.resolve();
+        /** Reads the log and replays it into memory. Every other method assumes this has finished. */
+        this.load = (0, caching_1.lazy)(async () => {
+            let data;
+            try {
+                data = await fs_1.default.promises.readFile(this.filePath, "utf8");
+            }
+            catch (e) {
+                if (e.code === "ENOENT")
+                    return;
+                throw e;
+            }
+            let applied = 0;
+            let damaged = 0;
+            for (let line of data.split("\n")) {
+                if (!line)
+                    continue;
+                let record;
+                try {
+                    record = JSON.parse(line);
+                }
+                catch (_a) {
+                    // A crash mid-append leaves a torn final line; anything earlier means real damage. Either way the rest of the log is still worth having - this is an index, and scanning rebuilds whatever we lose.
+                    damaged++;
+                    continue;
+                }
+                applied++;
+                // Replayed through the same ordering rules that produced it, so a log written out of order still lands on the same state
+                if (record.p) {
+                    this.values.delete(record.k);
+                    this.deleted.delete(record.k);
+                }
+                else if (record.d) {
+                    this.applyDelete(record.k, record.t, record.t);
+                }
+                else if (record.v !== undefined) {
+                    this.applySet(record.k, record.v, record.t, record.t);
+                }
+            }
+            this.logRecords = applied;
+            if (damaged) {
+                console.error(`${damaged} damaged record(s) in ${this.filePath} were skipped; ${applied} applied, leaving ${this.values.size} values and ${this.deleted.size} tombstones`);
+            }
+        });
+        this.directory = (0, caching_1.lazy)(async () => {
+            await fs_1.default.promises.mkdir(path_1.default.dirname(this.filePath), { recursive: true });
+        });
+    }
+    /** The live value, or undefined when the key does not exist here (deleted included - a deletion is an absence, see getDeleted for its time). */
+    get(key) {
+        return this.values.get(key);
+    }
+    /** When the key was deleted, if it was. Absent both here and in get means we have never heard of it. */
+    getDeleted(key) {
+        return this.deleted.get(key);
+    }
+    /** The time the key last changed either way, or 0 if we have never heard of it - what a new write has to beat. */
+    timeOf(key) {
+        var _a;
+        let live = this.values.get(key);
+        if (live)
+            return live.time;
+        return ((_a = this.deleted.get(key)) === null || _a === void 0 ? void 0 : _a.time) || 0;
+    }
+    /** O(1), and counts only what exists. */
+    get size() {
+        return this.values.size;
+    }
+    get deletedSize() {
+        return this.deleted.size;
+    }
+    /** Live values only. Live, in insertion order - deleting during iteration is safe (JS skips entries removed before they are reached), which is what the passes that walk everything and prune as they go rely on. */
+    entries() {
+        return this.values.entries();
+    }
+    /** The tombstones, which is a much smaller walk than the values - so expiring them, or listing what was deleted since some time, costs what it should. */
+    deletedEntries() {
+        return this.deleted.entries();
+    }
+    /** Stores a value as of `time`. Returns false when something at least as new is already here, in which case nothing changed - an out-of-order write is not an error, it is just late. */
+    set(key, value, time) {
+        if (!this.applySet(key, value, time, Date.now()))
+            return false;
+        this.append({ k: key, t: time, v: value });
+        return true;
+    }
+    /** Deletes as of `time`, keeping the tombstone. Returns false when something at least as new is already here. */
+    delete(key, time) {
+        if (!this.applyDelete(key, time, Date.now()))
+            return false;
+        this.append({ k: key, t: time, d: 1 });
+        return true;
+    }
+    /** Forgets the key entirely, tombstone included - for a tombstone old enough that nobody needs to hear about the deletion any more, and for an entry that turned out never to have existed. Not a deletion: it leaves nothing behind to propagate. */
+    purge(key) {
+        let had = this.values.delete(key);
+        had = this.deleted.delete(key) || had;
+        if (!had)
+            return;
+        this.append({ k: key, t: Date.now(), p: 1 });
+    }
+    applySet(key, value, time, changedAt) {
+        if (time < this.timeOf(key))
+            return false;
+        this.deleted.delete(key);
+        this.values.set(key, { value, time, changedAt });
+        return true;
+    }
+    applyDelete(key, time, changedAt) {
+        if (time < this.timeOf(key))
+            return false;
+        this.values.delete(key);
+        this.deleted.set(key, { time, changedAt });
+        return true;
+    }
+    append(record) {
+        this.pending.push(JSON.stringify(record));
+        this.logRecords++;
+        this.scheduleFlush();
+    }
+    scheduleFlush() {
+        var _a, _b;
+        if (this.flushTimer !== undefined)
+            return;
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = undefined;
+            void this.flush().catch((e) => { var _a; return console.error(`Flushing ${this.filePath} failed: ${(_a = e.stack) !== null && _a !== void 0 ? _a : e}`); });
+        }, FLUSH_DELAY);
+        (_b = (_a = this.flushTimer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    /** Writes everything pending (rewriting the log first if it has grown too far past what it describes). */
+    async flush() {
+        let result = this.writeChain.then(() => this.write());
+        // The chain only exists to serialize writes, so it must not stay rejected: a failure belongs to the caller that asked for this flush, not to every flush after it
+        this.writeChain = result.catch(() => { });
+        await result;
+    }
+    async write() {
+        if (this.logRecords > Math.max(MIN_COMPACT_RECORDS, (this.values.size + this.deleted.size) * COMPACT_RATIO)) {
+            await this.compact();
+            return;
+        }
+        await this.appendPending();
+    }
+    async appendPending() {
+        if (!this.pending.length)
+            return;
+        let records = this.pending;
+        this.pending = [];
+        await this.directory();
+        try {
+            await fs_1.default.promises.appendFile(this.filePath, records.join("\n") + "\n");
+        }
+        catch (e) {
+            // Put them back rather than lose them: the values are still in memory, so all that is at risk is having to rebuild them by scanning
+            this.pending = records.concat(this.pending);
+            this.scheduleFlush();
+            throw e;
+        }
+    }
+    // Rewrites the log as the current contents of both maps. They are the truth - the log only exists to rebuild them - so the snapshot IS the new log.
+    async compact() {
+        let records = [];
+        for (let [key, entry] of this.values) {
+            records.push(JSON.stringify({ k: key, t: entry.time, v: entry.value }));
+        }
+        for (let [key, tombstone] of this.deleted) {
+            records.push(JSON.stringify({ k: key, t: tombstone.time, d: 1 }));
+        }
+        // Cleared with the snapshot: every pending record is already reflected in the maps, so the snapshot contains it. Anything appended from here on is NOT in the snapshot, and lands in the new log after the rename.
+        this.pending = [];
+        let startedWith = this.logRecords;
+        let tempPath = `${this.filePath}.compacting`;
+        await this.directory();
+        await fs_1.default.promises.writeFile(tempPath, records.length && `${records.join("\n")}\n` || "");
+        // Replaces the old log in one step, so a crash leaves either the whole old log or the whole new one
+        await fs_1.default.promises.rename(tempPath, this.filePath);
+        this.logRecords = records.length + this.pending.length;
+        console.log(`Rewrote ${this.filePath}: ${startedWith} log records for ${this.values.size} values and ${this.deleted.size} tombstones`);
+        await this.appendPending();
+    }
+}
+exports.TransactionFile = TransactionFile;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TransactionFile.js","sourceRoot":"","sources":["TransactionFile.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from \"fs\";\nimport path from \"path\";\nimport { lazy } from \"socket-function/src/caching\";\n\n// A persistent Map that knows about time and about deletions. Every value carries the time it was written, so a write that arrives out of order is simply not applied - the map cannot be made to go backwards. A deleted key keeps its time too, as a tombstone in a second map, so \"was this deleted, and when\" is as cheap to ask as \"does this exist\", and expiring old tombstones is a walk of the tombstones alone rather than of everything.\n//\n// On disk it is one append-only log of the sets, deletes and purges that produced both maps, rewritten from them whenever it has grown to several times their size.\n\n// The log is rewritten once it holds this many times more records than there are keys (a log of 3 records per surviving key is mostly history)\nconst COMPACT_RATIO = 3;\n// ...but never for a small log, where the rewrite would cost more than the history it removes\nconst MIN_COMPACT_RECORDS = 1000;\n// Appends are coalesced for this long. A crash loses at most this much - the callers of this class treat their data as reconstructible - and the alternative is a file write per set.\nconst FLUSH_DELAY = 500;\n\n/** A live value: what was stored, when it was written (the caller's ordering), and when we last changed it (ours). */\nexport type LogEntry<T> = { value: T; time: number; changedAt: number };\n/** A deleted key: when it was deleted, and when we learned. The value is gone; the time is the point of a tombstone. */\nexport type LogTombstone = { time: number; changedAt: number };\n\n// One line of the log, with single-letter field names because there is one record per set/delete/purge ever made and the field names are most of a record's overhead. JSON.stringify escapes newlines inside keys and values, so a record can never contain the separator.\ntype LogRecord<T> = {\n    // key\n    k: string;\n    // time, lastModified time of the file, or the delete time, or the purge time\n    t: number;\n    // value\n    v?: T;\n    // deleted, the file on disk is deleted, preserved when we compact\n    d?: 1;\n    // purged, the file on disk is deleted, not preserved when we compact\n    p?: 1;\n};\n\nexport class TransactionFile<T> {\n    constructor(private filePath: string) { }\n\n    private values = new Map<string, LogEntry<T>>();\n    private deleted = new Map<string, LogTombstone>();\n    // Records the log holds (written plus pending) - what compaction is decided against, NOT the number of keys\n    private logRecords = 0;\n    private pending: string[] = [];\n    private flushTimer: ReturnType<typeof setTimeout> | undefined;\n    // Serializes everything that touches the file, so an append can never interleave with a rewrite\n    private writeChain: Promise<void> = Promise.resolve();\n\n    /** Reads the log and replays it into memory. Every other method assumes this has finished. */\n    public load = lazy(async () => {\n        let data: string;\n        try {\n            data = await fs.promises.readFile(this.filePath, \"utf8\");\n        } catch (e) {\n            if ((e as { code?: string }).code === \"ENOENT\") return;\n            throw e;\n        }\n        let applied = 0;\n        let damaged = 0;\n        for (let line of data.split(\"\\n\")) {\n            if (!line) continue;\n            let record: LogRecord<T> | undefined;\n            try {\n                record = JSON.parse(line) as LogRecord<T>;\n            } catch {\n                // A crash mid-append leaves a torn final line; anything earlier means real damage. Either way the rest of the log is still worth having - this is an index, and scanning rebuilds whatever we lose.\n                damaged++;\n                continue;\n            }\n            applied++;\n            // Replayed through the same ordering rules that produced it, so a log written out of order still lands on the same state\n            if (record.p) {\n                this.values.delete(record.k);\n                this.deleted.delete(record.k);\n            } else if (record.d) {\n                this.applyDelete(record.k, record.t, record.t);\n            } else if (record.v !== undefined) {\n                this.applySet(record.k, record.v, record.t, record.t);\n            }\n        }\n        this.logRecords = applied;\n        if (damaged) {\n            console.error(`${damaged} damaged record(s) in ${this.filePath} were skipped; ${applied} applied, leaving ${this.values.size} values and ${this.deleted.size} tombstones`);\n        }\n    });\n\n    /** The live value, or undefined when the key does not exist here (deleted included - a deletion is an absence, see getDeleted for its time). */\n    public get(key: string): LogEntry<T> | undefined {\n        return this.values.get(key);\n    }\n    /** When the key was deleted, if it was. Absent both here and in get means we have never heard of it. */\n    public getDeleted(key: string): LogTombstone | undefined {\n        return this.deleted.get(key);\n    }\n    /** The time the key last changed either way, or 0 if we have never heard of it - what a new write has to beat. */\n    public timeOf(key: string): number {\n        let live = this.values.get(key);\n        if (live) return live.time;\n        return this.deleted.get(key)?.time || 0;\n    }\n\n    /** O(1), and counts only what exists. */\n    public get size(): number {\n        return this.values.size;\n    }\n    public get deletedSize(): number {\n        return this.deleted.size;\n    }\n    /** Live values only. Live, in insertion order - deleting during iteration is safe (JS skips entries removed before they are reached), which is what the passes that walk everything and prune as they go rely on. */\n    public entries(): IterableIterator<[string, LogEntry<T>]> {\n        return this.values.entries();\n    }\n    /** The tombstones, which is a much smaller walk than the values - so expiring them, or listing what was deleted since some time, costs what it should. */\n    public deletedEntries(): IterableIterator<[string, LogTombstone]> {\n        return this.deleted.entries();\n    }\n\n    /** Stores a value as of `time`. Returns false when something at least as new is already here, in which case nothing changed - an out-of-order write is not an error, it is just late. */\n    public set(key: string, value: T, time: number): boolean {\n        if (!this.applySet(key, value, time, Date.now())) return false;\n        this.append({ k: key, t: time, v: value });\n        return true;\n    }\n\n    /** Deletes as of `time`, keeping the tombstone. Returns false when something at least as new is already here. */\n    public delete(key: string, time: number): boolean {\n        if (!this.applyDelete(key, time, Date.now())) return false;\n        this.append({ k: key, t: time, d: 1 });\n        return true;\n    }\n\n    /** Forgets the key entirely, tombstone included - for a tombstone old enough that nobody needs to hear about the deletion any more, and for an entry that turned out never to have existed. Not a deletion: it leaves nothing behind to propagate. */\n    public purge(key: string): void {\n        let had = this.values.delete(key);\n        had = this.deleted.delete(key) || had;\n        if (!had) return;\n        this.append({ k: key, t: Date.now(), p: 1 });\n    }\n\n    private applySet(key: string, value: T, time: number, changedAt: number): boolean {\n        if (time < this.timeOf(key)) return false;\n        this.deleted.delete(key);\n        this.values.set(key, { value, time, changedAt });\n        return true;\n    }\n\n    private applyDelete(key: string, time: number, changedAt: number): boolean {\n        if (time < this.timeOf(key)) return false;\n        this.values.delete(key);\n        this.deleted.set(key, { time, changedAt });\n        return true;\n    }\n\n    private append(record: LogRecord<T>): void {\n        this.pending.push(JSON.stringify(record));\n        this.logRecords++;\n        this.scheduleFlush();\n    }\n\n    private scheduleFlush(): void {\n        if (this.flushTimer !== undefined) return;\n        this.flushTimer = setTimeout(() => {\n            this.flushTimer = undefined;\n            void this.flush().catch((e: Error) => console.error(`Flushing ${this.filePath} failed: ${e.stack ?? e}`));\n        }, FLUSH_DELAY);\n        (this.flushTimer as { unref?: () => void }).unref?.();\n    }\n\n    /** Writes everything pending (rewriting the log first if it has grown too far past what it describes). */\n    public async flush(): Promise<void> {\n        let result = this.writeChain.then(() => this.write());\n        // The chain only exists to serialize writes, so it must not stay rejected: a failure belongs to the caller that asked for this flush, not to every flush after it\n        this.writeChain = result.catch(() => { });\n        await result;\n    }\n\n    private directory = lazy(async () => {\n        await fs.promises.mkdir(path.dirname(this.filePath), { recursive: true });\n    });\n\n    private async write(): Promise<void> {\n        if (this.logRecords > Math.max(MIN_COMPACT_RECORDS, (this.values.size + this.deleted.size) * COMPACT_RATIO)) {\n            await this.compact();\n            return;\n        }\n        await this.appendPending();\n    }\n\n    private async appendPending(): Promise<void> {\n        if (!this.pending.length) return;\n        let records = this.pending;\n        this.pending = [];\n        await this.directory();\n        try {\n            await fs.promises.appendFile(this.filePath, records.join(\"\\n\") + \"\\n\");\n        } catch (e) {\n            // Put them back rather than lose them: the values are still in memory, so all that is at risk is having to rebuild them by scanning\n            this.pending = records.concat(this.pending);\n            this.scheduleFlush();\n            throw e;\n        }\n    }\n\n    // Rewrites the log as the current contents of both maps. They are the truth - the log only exists to rebuild them - so the snapshot IS the new log.\n    private async compact(): Promise<void> {\n        let records: string[] = [];\n        for (let [key, entry] of this.values) {\n            records.push(JSON.stringify({ k: key, t: entry.time, v: entry.value } satisfies LogRecord<T>));\n        }\n        for (let [key, tombstone] of this.deleted) {\n            records.push(JSON.stringify({ k: key, t: tombstone.time, d: 1 } satisfies LogRecord<T>));\n        }\n        // Cleared with the snapshot: every pending record is already reflected in the maps, so the snapshot contains it. Anything appended from here on is NOT in the snapshot, and lands in the new log after the rename.\n        this.pending = [];\n        let startedWith = this.logRecords;\n        let tempPath = `${this.filePath}.compacting`;\n        await this.directory();\n        await fs.promises.writeFile(tempPath, records.length && `${records.join(\"\\n\")}\\n` || \"\");\n        // Replaces the old log in one step, so a crash leaves either the whole old log or the whole new one\n        await fs.promises.rename(tempPath, this.filePath);\n        this.logRecords = records.length + this.pending.length;\n        console.log(`Rewrote ${this.filePath}: ${startedWith} log records for ${this.values.size} values and ${this.deleted.size} tombstones`);\n        await this.appendPending();\n    }\n}\n"]}
+ /* _JS_SOURCE_HASH = "721f22728293dfd0510cfdad96ff16d96bdc9ba934a1513eb2222ffe41ec1642"; */