@proteinjs/db 1.35.1 → 1.37.0

package/dist/src/encryption/DataEncryptionKeyTable.d.ts

@@ -0,0 +1,33 @@
+import { Table } from '../Table';
+import { Record } from '../Record';
+/**
+ * One wrapped per-owner data key version (see `DataKeyStore`).
+ *
+ * - `active` — encrypts new writes (the highest active version) and fingerprints queries.
+ * - `retired` — decrypt-only: envelopes referencing it still unwrap, but no new writes or
+ *   query fingerprints use it. A rotation walk moves every row off a version, then retires it.
+ *
+ * Crypto-shred = deleting an owner's rows here: every envelope naming that owner becomes
+ * permanently unreadable, including inside backups.
+ */
+export interface DataEncryptionKey extends Record {
+    /** The key owner (a user id — the row's permission-source scope owner). */
+    owner: string;
+    /** Monotonic per-owner version; envelopes name (owner, version). */
+    version: number;
+    /** The data-key material, wrapped by the master key (`MasterKeyProvider`). */
+    wrappedKey: string;
+    status: 'active' | 'retired';
+}
+export declare class DataEncryptionKeyTable extends Table<DataEncryptionKey> {
+    name: string;
+    columns: Table<DataEncryptionKey>['columns'];
+    /** (owner, version) is the identity an envelope names — the race loser on concurrent
+     *  first-write key creation fails here and re-reads the winner's key. */
+    indexes: {
+        columns: (keyof DataEncryptionKey)[];
+        name?: string;
+        unique?: boolean;
+    }[];
+}
+//# sourceMappingURL=DataEncryptionKeyTable.d.ts.map

package/dist/src/encryption/DataEncryptionKeyTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataEncryptionKeyTable.d.ts","sourceRoot":"","sources":["../../../src/encryption/DataEncryptionKeyTable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAAE,MAAM,EAAqB,MAAM,WAAW,CAAC;AAGtD;;;;;;;;;GASG;AACH,MAAM,WAAW,iBAAkB,SAAQ,MAAM;IAC/C,2EAA2E;IAC3E,KAAK,EAAE,MAAM,CAAC;IACd,oEAAoE;IACpE,OAAO,EAAE,MAAM,CAAC;IAChB,8EAA8E;IAC9E,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,QAAQ,GAAG,SAAS,CAAC;CAC9B;AAED,qBAAa,sBAAuB,SAAQ,KAAK,CAAC,iBAAiB,CAAC;IAC3D,IAAI,SAAyB;IAC7B,OAAO,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC,SAAS,CAAC,CAKhD;IACH;6EACyE;IAClE,OAAO,EAAE;QAAE,OAAO,EAAE,CAAC,MAAM,iBAAiB,CAAC,EAAE,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,EAAE,CAEzF;CAGH"}

package/dist/src/encryption/DataEncryptionKeyTable.js

@@ -0,0 +1,45 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataEncryptionKeyTable = void 0;
+var Table_1 = require("../Table");
+var Record_1 = require("../Record");
+var Columns_1 = require("../Columns");
+var DataEncryptionKeyTable = /** @class */ (function (_super) {
+    __extends(DataEncryptionKeyTable, _super);
+    function DataEncryptionKeyTable() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.name = 'data_encryption_key';
+        _this.columns = (0, Record_1.withRecordColumns)({
+            owner: new Columns_1.StringColumn('owner', { nullable: false }, 36),
+            version: new Columns_1.IntegerColumn('version', { nullable: false }),
+            wrappedKey: new Columns_1.StringColumn('wrapped_key', { nullable: false }, 'MAX'),
+            status: new Columns_1.StringColumn('status', { nullable: false }, 16),
+        });
+        /** (owner, version) is the identity an envelope names — the race loser on concurrent
+         *  first-write key creation fails here and re-reads the winner's key. */
+        _this.indexes = [
+            { columns: ['owner', 'version'], name: 'data_encryption_key_owner_version_unique', unique: true },
+        ];
+        return _this;
+        // No auth block: default-deny for every non-system caller. Key rows are framework
+        // machinery, only ever touched through system paths (DataKeyStore).
+    }
+    return DataEncryptionKeyTable;
+}(Table_1.Table));
+exports.DataEncryptionKeyTable = DataEncryptionKeyTable;
+//# sourceMappingURL=DataEncryptionKeyTable.js.map

package/dist/src/encryption/DataEncryptionKeyTable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataEncryptionKeyTable.js","sourceRoot":"","sources":["../../../src/encryption/DataEncryptionKeyTable.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAAA,kCAAiC;AACjC,oCAAsD;AACtD,sCAAyD;AAsBzD;IAA4C,0CAAwB;IAApE;QAAA,qEAeC;QAdQ,UAAI,GAAG,qBAAqB,CAAC;QAC7B,aAAO,GAAwC,IAAA,0BAAiB,EAAoB;YACzF,KAAK,EAAE,IAAI,sBAAY,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;YACzD,OAAO,EAAE,IAAI,uBAAa,CAAC,SAAS,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;YAC1D,UAAU,EAAE,IAAI,sBAAY,CAAC,aAAa,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC;YACvE,MAAM,EAAE,IAAI,sBAAY,CAAC,QAAQ,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;SAC5D,CAAC,CAAC;QACH;iFACyE;QAClE,aAAO,GAAgF;YAC5F,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,SAAS,CAAC,EAAE,IAAI,EAAE,0CAA0C,EAAE,MAAM,EAAE,IAAI,EAAE;SAClG,CAAC;;QACF,kFAAkF;QAClF,oEAAoE;IACtE,CAAC;IAAD,6BAAC;AAAD,CAAC,AAfD,CAA4C,aAAK,GAehD;AAfY,wDAAsB"}

package/dist/src/encryption/DataKeyStore.d.ts

@@ -0,0 +1,84 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/**
+ * Decrypt was asked for a key that does not exist — most often because the owner's keys were
+ * crypto-shredded (account deletion): the ciphertext is permanently unreadable, by design.
+ */
+export declare class EncryptionKeyUnavailableError extends Error {
+    constructor(owner: string, version: number);
+}
+/** Unwrapped material of one data-key version. */
+export interface DataKeyMaterial {
+    owner: string;
+    version: number;
+    /** AES-256 key for row values (first half of the 64-byte material). */
+    cipherKey: Buffer;
+    /** HMAC key for search-token fingerprints (second half). */
+    indexKey: Buffer;
+}
+/**
+ * Per-owner data keys for column encryption: creation, unwrap-once caching, rotation,
+ * retirement, and crypto-shred. Key rows live in `DataEncryptionKeyTable`, wrapped by the
+ * deployment's `MasterKeyProvider`; the vault is called once per key (then cached), never
+ * per row.
+ *
+ * All database access runs as system, OUTSIDE any ambient transaction: a key row must be
+ * durable independent of the caller's transaction outcome, because unwrapped material is
+ * cached in-process the moment it exists — a key created inside a transaction that later
+ * rolls back would leave the cache claiming a key the database lost. An orphaned key row
+ * from a rolled-back first write is harmless (a key no envelope names).
+ *
+ * The caches live on the global object (the per-package-install duplicate-module pattern —
+ * see `Db.getDefaultDbDriver`), so every live copy of this package shares one cache.
+ */
+export declare class DataKeyStore {
+    /** Unwrapped material cache TTL — bounds how long a shredded key can linger in a warm process. */
+    private static readonly MATERIAL_TTL_MS;
+    /** Owner key-row list TTL — bounds cross-process staleness of the active-version set. */
+    private static readonly OWNER_ROWS_TTL_MS;
+    private static readonly CACHES_GLOBAL_KEY;
+    private static readonly KEY_MATERIAL_BYTES;
+    private logger;
+    private table;
+    /**
+     * The key that encrypts new writes for `owner`: the highest active version, created on
+     * first use (each owner gets a randomly generated data key, wrapped by the master key).
+     */
+    getWriteKey(owner: string): Promise<DataKeyMaterial>;
+    /** The key an envelope names — any status; decrypt must work until the key is shredded. */
+    getKeyByVersion(owner: string, version: number): Promise<DataKeyMaterial>;
+    /**
+     * The index keys a query fingerprints with: every ACTIVE version of every accessible
+     * owner (normally one per owner; two during a rotation window). Owners with no keys yet
+     * contribute nothing — they cannot have encrypted rows.
+     */
+    getQueryIndexKeys(owners: string[]): Promise<DataKeyMaterial[]>;
+    /**
+     * Mint the next key version for `owner` (new writes use it immediately; the old version
+     * stays active — still fingerprinting queries — until a rotation walk
+     * (`EncryptionLifecycleWalker` mode 'rotate-keys') has rewritten every row, after which
+     * the caller retires it via `retireKeyVersion`).
+     * @returns the new version number
+     */
+    rotateKey(owner: string): Promise<number>;
+    /** Retire a version: envelopes naming it still decrypt; queries and writes stop using it. */
+    retireKeyVersion(owner: string, version: number): Promise<void>;
+    /**
+     * Crypto-shred: delete every key version of `owner` and evict the caches. Every envelope
+     * naming the owner — in live rows and in every backup — becomes permanently unreadable.
+     */
+    shredOwnerKeys(owner: string): Promise<number>;
+    private createKeyVersion;
+    private getOwnerRows;
+    private unwrap;
+    private highestActive;
+    private requireOwner;
+    /**
+     * A system Db pinned OUTSIDE any ambient transaction (see class doc). Imported lazily —
+     * this module is reachable from the serializer layer, below `Db` in the module graph.
+     */
+    private systemDb;
+    private caches;
+    private evictOwner;
+}
+//# sourceMappingURL=DataKeyStore.d.ts.map

package/dist/src/encryption/DataKeyStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataKeyStore.d.ts","sourceRoot":"","sources":["../../../src/encryption/DataKeyStore.ts"],"names":[],"mappings":";;AAKA;;;GAGG;AACH,qBAAa,6BAA8B,SAAQ,KAAK;gBAC1C,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAQ3C;AAED,kDAAkD;AAClD,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,uEAAuE;IACvE,SAAS,EAAE,MAAM,CAAC;IAClB,4DAA4D;IAC5D,QAAQ,EAAE,MAAM,CAAC;CAClB;AAiBD;;;;;;;;;;;;;;GAcG;AACH,qBAAa,YAAY;IACvB,kGAAkG;IAClG,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAkB;IACzD,yFAAyF;IACzF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAa;IACtD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAkC;IAC3E,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAM;IAChD,OAAO,CAAC,MAAM,CAA+C;IAC7D,OAAO,CAAC,KAAK,CAAgC;IAE7C;;;OAGG;IACG,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAiB1D,2FAA2F;IACrF,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAkB/E;;;;OAIG;IACG,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAcrE;;;;;;OAMG;IACG,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAU/C,6FAA6F;IACvF,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAarE;;;OAGG;IACG,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;YAetC,gBAAgB;YAsBhB,YAAY;YAsBZ,MAAM;IA2BpB,OAAO,CAAC,aAAa;IAMrB,OAAO,CAAC,YAAY;IAMpB;;;OAGG;YACW,QAAQ;IAuBtB,OAAO,CAAC,MAAM;IAYd,OAAO,CAAC,UAAU;CAGnB"}

package/dist/src/encryption/DataKeyStore.js

@@ -0,0 +1,481 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataKeyStore = exports.EncryptionKeyUnavailableError = void 0;
+var crypto_1 = require("crypto");
+var logger_1 = require("@proteinjs/logger");
+var DbEncryptionConfig_1 = require("./DbEncryptionConfig");
+var DataEncryptionKeyTable_1 = require("./DataEncryptionKeyTable");
+/**
+ * Decrypt was asked for a key that does not exist — most often because the owner's keys were
+ * crypto-shredded (account deletion): the ciphertext is permanently unreadable, by design.
+ */
+var EncryptionKeyUnavailableError = /** @class */ (function (_super) {
+    __extends(EncryptionKeyUnavailableError, _super);
+    function EncryptionKeyUnavailableError(owner, version) {
+        var _this = _super.call(this, "No data key exists for owner '".concat(owner, "' version ").concat(version, ". If the owner's keys were ") +
+            "deleted (crypto-shred), rows encrypted under them are permanently unreadable.") || this;
+        _this.name = 'EncryptionKeyUnavailableError';
+        Object.setPrototypeOf(_this, EncryptionKeyUnavailableError.prototype);
+        return _this;
+    }
+    return EncryptionKeyUnavailableError;
+}(Error));
+exports.EncryptionKeyUnavailableError = EncryptionKeyUnavailableError;
+/**
+ * Per-owner data keys for column encryption: creation, unwrap-once caching, rotation,
+ * retirement, and crypto-shred. Key rows live in `DataEncryptionKeyTable`, wrapped by the
+ * deployment's `MasterKeyProvider`; the vault is called once per key (then cached), never
+ * per row.
+ *
+ * All database access runs as system, OUTSIDE any ambient transaction: a key row must be
+ * durable independent of the caller's transaction outcome, because unwrapped material is
+ * cached in-process the moment it exists — a key created inside a transaction that later
+ * rolls back would leave the cache claiming a key the database lost. An orphaned key row
+ * from a rolled-back first write is harmless (a key no envelope names).
+ *
+ * The caches live on the global object (the per-package-install duplicate-module pattern —
+ * see `Db.getDefaultDbDriver`), so every live copy of this package shares one cache.
+ */
+var DataKeyStore = /** @class */ (function () {
+    function DataKeyStore() {
+        this.logger = new logger_1.Logger({ name: this.constructor.name });
+        this.table = new DataEncryptionKeyTable_1.DataEncryptionKeyTable();
+    }
+    /**
+     * The key that encrypts new writes for `owner`: the highest active version, created on
+     * first use (each owner gets a randomly generated data key, wrapped by the master key).
+     */
+    DataKeyStore.prototype.getWriteKey = function (owner) {
+        return __awaiter(this, void 0, void 0, function () {
+            var rows, active;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.requireOwner(owner);
+                        return [4 /*yield*/, this.getOwnerRows(owner)];
+                    case 1:
+                        rows = _a.sent();
+                        active = this.highestActive(rows);
+                        if (!!active) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.createKeyVersion(owner, 1)];
+                    case 2:
+                        _a.sent();
+                        this.evictOwner(owner);
+                        return [4 /*yield*/, this.getOwnerRows(owner)];
+                    case 3:
+                        rows = _a.sent();
+                        active = this.highestActive(rows);
+                        if (!active) {
+                            throw new EncryptionKeyUnavailableError(owner, 1);
+                        }
+                        _a.label = 4;
+                    case 4: return [4 /*yield*/, this.unwrap(active)];
+                    case 5: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /** The key an envelope names — any status; decrypt must work until the key is shredded. */
+    DataKeyStore.prototype.getKeyByVersion = function (owner, version) {
+        return __awaiter(this, void 0, void 0, function () {
+            var rows, row, freshRows, freshRow;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getOwnerRows(owner)];
+                    case 1:
+                        rows = _a.sent();
+                        row = rows.find(function (candidate) { return candidate.version === version; });
+                        if (!!row) return [3 /*break*/, 4];
+                        // The row list may be cached from before this version existed (e.g. a fresh rotation
+                        // in another process) — refresh once before declaring the key gone.
+                        this.evictOwner(owner);
+                        return [4 /*yield*/, this.getOwnerRows(owner)];
+                    case 2:
+                        freshRows = _a.sent();
+                        freshRow = freshRows.find(function (candidate) { return candidate.version === version; });
+                        if (!freshRow) {
+                            throw new EncryptionKeyUnavailableError(owner, version);
+                        }
+                        return [4 /*yield*/, this.unwrap(freshRow)];
+                    case 3: return [2 /*return*/, _a.sent()];
+                    case 4: return [4 /*yield*/, this.unwrap(row)];
+                    case 5: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * The index keys a query fingerprints with: every ACTIVE version of every accessible
+     * owner (normally one per owner; two during a rotation window). Owners with no keys yet
+     * contribute nothing — they cannot have encrypted rows.
+     */
+    DataKeyStore.prototype.getQueryIndexKeys = function (owners) {
+        return __awaiter(this, void 0, void 0, function () {
+            var keys, _i, owners_1, owner, rows, _a, rows_1, row, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        keys = [];
+                        _i = 0, owners_1 = owners;
+                        _d.label = 1;
+                    case 1:
+                        if (!(_i < owners_1.length)) return [3 /*break*/, 7];
+                        owner = owners_1[_i];
+                        return [4 /*yield*/, this.getOwnerRows(owner)];
+                    case 2:
+                        rows = _d.sent();
+                        _a = 0, rows_1 = rows;
+                        _d.label = 3;
+                    case 3:
+                        if (!(_a < rows_1.length)) return [3 /*break*/, 6];
+                        row = rows_1[_a];
+                        if (!(row.status === 'active')) return [3 /*break*/, 5];
+                        _c = (_b = keys).push;
+                        return [4 /*yield*/, this.unwrap(row)];
+                    case 4:
+                        _c.apply(_b, [_d.sent()]);
+                        _d.label = 5;
+                    case 5:
+                        _a++;
+                        return [3 /*break*/, 3];
+                    case 6:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 7: return [2 /*return*/, keys];
+                }
+            });
+        });
+    };
+    /**
+     * Mint the next key version for `owner` (new writes use it immediately; the old version
+     * stays active — still fingerprinting queries — until a rotation walk
+     * (`EncryptionLifecycleWalker` mode 'rotate-keys') has rewritten every row, after which
+     * the caller retires it via `retireKeyVersion`).
+     * @returns the new version number
+     */
+    DataKeyStore.prototype.rotateKey = function (owner) {
+        return __awaiter(this, void 0, void 0, function () {
+            var rows, highest, newVersion;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.requireOwner(owner);
+                        return [4 /*yield*/, this.getOwnerRows(owner)];
+                    case 1:
+                        rows = _a.sent();
+                        highest = rows.reduce(function (max, row) { return Math.max(max, row.version); }, 0);
+                        newVersion = highest + 1;
+                        return [4 /*yield*/, this.createKeyVersion(owner, newVersion)];
+                    case 2:
+                        _a.sent();
+                        this.evictOwner(owner);
+                        return [2 /*return*/, newVersion];
+                }
+            });
+        });
+    };
+    /** Retire a version: envelopes naming it still decrypt; queries and writes stop using it. */
+    DataKeyStore.prototype.retireKeyVersion = function (owner, version) {
+        return __awaiter(this, void 0, void 0, function () {
+            var db;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.systemDb()];
+                    case 1:
+                        db = _a.sent();
+                        return [4 /*yield*/, db.update(this.table, { status: 'retired' }, {
+                                owner: owner,
+                                version: version,
+                            })];
+                    case 2:
+                        _a.sent();
+                        this.evictOwner(owner);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Crypto-shred: delete every key version of `owner` and evict the caches. Every envelope
+     * naming the owner — in live rows and in every backup — becomes permanently unreadable.
+     */
+    DataKeyStore.prototype.shredOwnerKeys = function (owner) {
+        return __awaiter(this, void 0, void 0, function () {
+            var db, deleted, caches, _i, _a, cacheKey;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.systemDb()];
+                    case 1:
+                        db = _b.sent();
+                        return [4 /*yield*/, db.delete(this.table, { owner: owner })];
+                    case 2:
+                        deleted = _b.sent();
+                        this.evictOwner(owner);
+                        caches = this.caches();
+                        for (_i = 0, _a = Array.from(caches.material.keys()); _i < _a.length; _i++) {
+                            cacheKey = _a[_i];
+                            if (cacheKey.startsWith("".concat(owner, ":"))) {
+                                caches.material.delete(cacheKey);
+                            }
+                        }
+                        this.logger.info({ message: "Crypto-shredded data keys", obj: { owner: owner, deleted: deleted } });
+                        return [2 /*return*/, deleted];
+                }
+            });
+        });
+    };
+    DataKeyStore.prototype.createKeyVersion = function (owner, version) {
+        return __awaiter(this, void 0, void 0, function () {
+            var config, material, wrappedKey, db, error_1, rows;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        config = (0, DbEncryptionConfig_1.getDbEncryptionConfig)();
+                        material = (0, crypto_1.randomBytes)(DataKeyStore.KEY_MATERIAL_BYTES);
+                        return [4 /*yield*/, config.masterKeyProvider.wrapDataKey(material)];
+                    case 1:
+                        wrappedKey = _a.sent();
+                        return [4 /*yield*/, this.systemDb()];
+                    case 2:
+                        db = _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        _a.trys.push([3, 5, , 7]);
+                        return [4 /*yield*/, db.insert(this.table, { owner: owner, version: version, wrappedKey: wrappedKey, status: 'active' })];
+                    case 4:
+                        _a.sent();
+                        return [3 /*break*/, 7];
+                    case 5:
+                        error_1 = _a.sent();
+                        // Named race: two first writes for the same owner both create version 1; the unique
+                        // (owner, version) index rejects the loser. Re-read — if the winner's key is there,
+                        // use it; otherwise the failure was real.
+                        this.evictOwner(owner);
+                        return [4 /*yield*/, this.getOwnerRows(owner)];
+                    case 6:
+                        rows = _a.sent();
+                        if (!rows.some(function (row) { return row.version === version; })) {
+                            throw error_1;
+                        }
+                        return [3 /*break*/, 7];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DataKeyStore.prototype.getOwnerRows = function (owner) {
+        return __awaiter(this, void 0, void 0, function () {
+            var caches, cached, db, rows, entry;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        caches = this.caches();
+                        cached = caches.ownerRows.get(owner);
+                        if (cached && Date.now() - cached.fetchedAt < DataKeyStore.OWNER_ROWS_TTL_MS) {
+                            return [2 /*return*/, cached.rows];
+                        }
+                        return [4 /*yield*/, this.systemDb()];
+                    case 1:
+                        db = _a.sent();
+                        return [4 /*yield*/, db.query(this.table, { owner: owner })];
+                    case 2:
+                        rows = _a.sent();
+                        entry = {
+                            fetchedAt: Date.now(),
+                            rows: rows.map(function (row) { return ({
+                                owner: row.owner,
+                                version: row.version,
+                                wrappedKey: row.wrappedKey,
+                                status: row.status,
+                            }); }),
+                        };
+                        caches.ownerRows.set(owner, entry);
+                        return [2 /*return*/, entry.rows];
+                }
+            });
+        });
+    };
+    DataKeyStore.prototype.unwrap = function (row) {
+        return __awaiter(this, void 0, void 0, function () {
+            var caches, cacheKey, cached, config, materialBytes, material;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        caches = this.caches();
+                        cacheKey = "".concat(row.owner, ":").concat(row.version);
+                        cached = caches.material.get(cacheKey);
+                        if (cached && Date.now() - cached.cachedAt < DataKeyStore.MATERIAL_TTL_MS) {
+                            return [2 /*return*/, cached.material];
+                        }
+                        config = (0, DbEncryptionConfig_1.getDbEncryptionConfig)();
+                        return [4 /*yield*/, config.masterKeyProvider.unwrapDataKey(row.wrappedKey)];
+                    case 1:
+                        materialBytes = _a.sent();
+                        if (materialBytes.length !== DataKeyStore.KEY_MATERIAL_BYTES) {
+                            throw new Error("Data key material for owner '".concat(row.owner, "' version ").concat(row.version, " has unexpected length ") +
+                                "".concat(materialBytes.length, " (expected ").concat(DataKeyStore.KEY_MATERIAL_BYTES, ") \u2014 wrong master key?"));
+                        }
+                        material = {
+                            owner: row.owner,
+                            version: row.version,
+                            cipherKey: materialBytes.subarray(0, 32),
+                            indexKey: materialBytes.subarray(32, 64),
+                        };
+                        caches.material.set(cacheKey, { cachedAt: Date.now(), material: material });
+                        return [2 /*return*/, material];
+                }
+            });
+        });
+    };
+    DataKeyStore.prototype.highestActive = function (rows) {
+        return rows.filter(function (row) { return row.status === 'active'; }).sort(function (a, b) { return b.version - a.version; })[0];
+    };
+    DataKeyStore.prototype.requireOwner = function (owner) {
+        if (!owner || typeof owner !== 'string') {
+            throw new Error("Data key operations require a non-empty owner id; got: ".concat(JSON.stringify(owner)));
+        }
+    };
+    /**
+     * A system Db pinned OUTSIDE any ambient transaction (see class doc). Imported lazily —
+     * this module is reachable from the serializer layer, below `Db` in the module graph.
+     */
+    DataKeyStore.prototype.systemDb = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var Db, getDefaultTransactionContextFactory, db, factory;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require('../Db')); })];
+                    case 1:
+                        Db = (_a.sent()).Db;
+                        return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require('../transaction/TransactionContextFactory')); })];
+                    case 2:
+                        getDefaultTransactionContextFactory = (_a.sent()).getDefaultTransactionContextFactory;
+                        db = new Db(undefined, undefined, undefined, true);
+                        factory = getDefaultTransactionContextFactory();
+                        if (!factory) {
+                            return [2 /*return*/, db];
+                        }
+                        // Proxy every operation through an empty transaction context so key-table IO
+                        // auto-commits even when the caller is mid-transaction.
+                        return [2 /*return*/, new Proxy(db, {
+                                get: function (target, prop, receiver) {
+                                    var _this = this;
+                                    var value = Reflect.get(target, prop, receiver);
+                                    if (typeof value !== 'function') {
+                                        return value;
+                                    }
+                                    return function () {
+                                        var args = [];
+                                        for (var _i = 0; _i < arguments.length; _i++) {
+                                            args[_i] = arguments[_i];
+                                        }
+                                        return factory.runInContext({}, function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                                            switch (_a.label) {
+                                                case 0: return [4 /*yield*/, value.apply(target, args)];
+                                                case 1: return [2 /*return*/, _a.sent()];
+                                            }
+                                        }); }); });
+                                    };
+                                },
+                            })];
+                }
+            });
+        });
+    };
+    DataKeyStore.prototype.caches = function () {
+        var globalObject = globalThis;
+        if (!globalObject[DataKeyStore.CACHES_GLOBAL_KEY]) {
+            globalObject[DataKeyStore.CACHES_GLOBAL_KEY] = {
+                ownerRows: new Map(),
+                material: new Map(),
+            };
+        }
+        return globalObject[DataKeyStore.CACHES_GLOBAL_KEY];
+    };
+    DataKeyStore.prototype.evictOwner = function (owner) {
+        this.caches().ownerRows.delete(owner);
+    };
+    /** Unwrapped material cache TTL — bounds how long a shredded key can linger in a warm process. */
+    DataKeyStore.MATERIAL_TTL_MS = 10 * 60 * 1000;
+    /** Owner key-row list TTL — bounds cross-process staleness of the active-version set. */
+    DataKeyStore.OWNER_ROWS_TTL_MS = 60 * 1000;
+    DataKeyStore.CACHES_GLOBAL_KEY = '__proteinjs_db_dataKeyCaches';
+    DataKeyStore.KEY_MATERIAL_BYTES = 64;
+    return DataKeyStore;
+}());
+exports.DataKeyStore = DataKeyStore;
+//# sourceMappingURL=DataKeyStore.js.map