@quereus/store 4.13.1 → 4.15.2

package/dist/src/testing/memory-provider.js

@@ -0,0 +1,124 @@
+/**
+ * Shared in-memory {@link KVStoreProvider} test double — test-support, ships in
+ * `@quereus/store/testing`.
+ *
+ * Nearly every spec in this package's `test/` directory (and this package's benchmark
+ * suite) opens with its own private copy of an all-`InMemoryKVStore` provider. This is the
+ * one shared implementation, built to the same conventions as its sibling
+ * {@link createCountingProvider}:
+ *
+ *   - Store names come from {@link buildDataStoreName} / {@link buildIndexStoreName} and the
+ *     reserved {@link CATALOG_STORE_NAME} / {@link STATS_STORE_NAME} constants — never
+ *     hand-composed template strings, which drop the builders' lowercasing.
+ *   - {@link KVStoreProvider.getStatsStore} returns ONE unified `__stats__` store for every
+ *     table, as the interface specifies (its schema/table arguments are documented as
+ *     ignored) — not the per-table `schema.table.__stats__` spelling most local copies use.
+ *   - `options.costProfile` is spread in only when present, so a provider built with no
+ *     options (or `{}`) has no `costProfile` property at all, matching what a genuine
+ *     pre-profile third-party provider looks like.
+ *
+ * Unlike {@link createCountingProvider} — which deliberately omits `deleteIndexStore` /
+ * `deleteTableStores` — this provider implements both, and they ERASE rather than merely
+ * drop the map entry: see {@link erase} for why a live handle still needs its bytes cleared.
+ * `renameTableStores` is deliberately NOT implemented; `StoreModule` falls back to a generic
+ * copy for a provider without it (`test/rename-store-copy-fallback.spec.ts`), and nothing
+ * that needs this provider today renames.
+ *
+ * Neither is `beginAtomicBatch`, and that one is not a gap to fill later: separate
+ * `InMemoryKVStore`s share no commit domain, so there is nothing for a cross-store batch to
+ * make atomic. The consequence is worth knowing before reading numbers off this provider —
+ * `StoreModuleBase` sets `atomicProvider` from that method's presence and commits per store
+ * here, where a LevelDB-family provider commits in one physical write. A benchmark putting
+ * this provider next to LevelDB is comparing two commit PATHS, not one path over two
+ * backends.
+ */
+import { buildDataStoreName, buildIndexStoreName, CATALOG_STORE_NAME, STATS_STORE_NAME } from '../common/key-builder.js';
+import { InMemoryKVStore } from '../common/memory-store.js';
+/**
+ * Build an all-`InMemoryKVStore` {@link KVStoreProvider}. Every distinct built store name
+ * gets its own `InMemoryKVStore`, created lazily on first access.
+ */
+export function createInMemoryProvider(options) {
+    const stores = new Map();
+    // NOTE: a cached store the CALLER closed directly is handed back closed, so the next op
+    // on it throws `InMemoryKVStore is closed` rather than re-opening — unlike a real backend,
+    // which re-opens the name with its bytes intact. No StoreModule path does that today
+    // (`StoreTableBase.releaseIndexStore` is the only close, and its caller always deletes the
+    // store right after, which drops the entry). If a spec or benchmark ever closes a handle
+    // and keeps using the name, treat a closed cached store as absent here.
+    const getOrCreate = (key) => {
+        let store = stores.get(key);
+        if (!store) {
+            store = new InMemoryKVStore();
+            stores.set(key, store);
+        }
+        return store;
+    };
+    /**
+     * Erase the store named `key`: a caller re-opening this name afterwards must find it
+     * empty, and a caller still holding a LIVE handle to it must see the erase too (the
+     * reclaim battery's "handle the caller already closed" case is the other order — see
+     * below). Two cases, both ending in the map entry being dropped so the name re-opens
+     * fresh:
+     *
+     *   - Live store: `clear()` it first, so an existing handle observes the erase, THEN
+     *     drop the map entry.
+     *   - Already-closed store (the caller closed its handle before asking for the delete —
+     *     exactly what `StoreModuleIndex.tearDownIndexStore` does): `close()` already
+     *     cleared its entries and marked it closed, so `clear()` would just throw
+     *     (`checkOpen()`) for no benefit. Skip straight to dropping the map entry.
+     *
+     * A store that was never created (key absent from the map) is a no-op, matching the
+     * interface's speculative-delete contract.
+     *
+     * NOTE: the live handle is cleared, not closed, so a caller still holding it can go on
+     * PUTting into a store the provider has forgotten — those writes land nowhere anyone can
+     * read, silently. A real backend's handle is dead after its store is dropped. Closing here
+     * instead would trade the silence for a throw, but would also break the contract line
+     * above (a live handle must read back EMPTY, not throw); revisit if a spec is ever found
+     * writing through a post-delete handle.
+     */
+    const erase = async (key) => {
+        const store = stores.get(key);
+        if (!store)
+            return;
+        if (!store.isClosed) {
+            store.clear();
+        }
+        stores.delete(key);
+    };
+    return {
+        ...(options?.costProfile ? { costProfile: options.costProfile } : {}),
+        async getStore(schemaName, tableName) {
+            return getOrCreate(buildDataStoreName(schemaName, tableName));
+        },
+        async getIndexStore(schemaName, tableName, indexName) {
+            return getOrCreate(buildIndexStoreName(schemaName, tableName, indexName));
+        },
+        async getStatsStore() {
+            return getOrCreate(STATS_STORE_NAME);
+        },
+        async getCatalogStore() {
+            return getOrCreate(CATALOG_STORE_NAME);
+        },
+        async closeStore() { },
+        async closeIndexStore() { },
+        async closeAll() {
+            for (const store of stores.values())
+                await store.close();
+            stores.clear();
+        },
+        async deleteIndexStore(schemaName, tableName, indexName) {
+            await erase(buildIndexStoreName(schemaName, tableName, indexName));
+        },
+        async deleteTableStores(schemaName, tableName, indexNames) {
+            await erase(buildDataStoreName(schemaName, tableName));
+            for (const indexName of indexNames) {
+                await erase(buildIndexStoreName(schemaName, tableName, indexName));
+            }
+            // The unified __stats__ store is deliberately untouched — a table's row count is
+            // one ENTRY there, and removing it is the caller's business, not a store deletion.
+        },
+    };
+}
+//# sourceMappingURL=memory-provider.js.map

package/dist/src/testing/memory-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-provider.js","sourceRoot":"","sources":["../../../src/testing/memory-provider.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quereus/store",
-  "version": "4.13.1",
+  "version": "4.15.2",
   "type": "module",
   "description": "Abstract key-value storage module for Quereus",
   "keywords": [
@@ -52,12 +52,12 @@
     "test:single": "cd ../.. && node --import ./packages/quereus-store/register.mjs node_modules/mocha/bin/mocha.js --bail"
   },
   "peerDependencies": {
-    "@quereus/isolation": "^4.13.1",
-    "@quereus/quereus": "^4.13.1"
+    "@quereus/isolation": "^4.15.2",
+    "@quereus/quereus": "^4.15.2"
   },
   "dependencies": {
-    "@quereus/isolation": "^4.13.1",
-    "@quereus/quereus": "^4.13.1"
+    "@quereus/isolation": "^4.15.2",
+    "@quereus/quereus": "^4.15.2"
   },
   "devDependencies": {
     "@types/mocha": "^10.0.10",