@pixagram/lacerta-db 0.11.0 → 0.11.2

package/index.js

@@ -1,7 +1,7 @@
 /**
- * LacertaDB V0.11.0 - Production Library
+ * LacertaDB V0.11.2 - Production Library
  * @module LacertaDB
- * @version 0.11.0
+ * @version 0.11.2
  * @license MIT
  * @author Pixagram SA
  */
@@ -29,14 +29,14 @@ import TurboBase64 from "@pixagram/turbobase64";
 // Default TurboSerial configuration (overridable via LacertaDB constructor)
 const TURBO_SERIAL_DEFAULTS = {
     compression: false,
-    preservePropertyDescriptors: true,
+    preservePropertyDescriptors: false,
     deduplication: false,
     simdOptimization: true,
-    detectCircular: true,
-    shareArrayBuffers: true,
+    detectCircular: false,
+    shareArrayBuffers: false,
     allowFunction: false,
     serializeFunctions: false,
-    memoryPoolSize: 65536 * 16
+    memoryPoolSize: 65536
 };
 
 // ========================
@@ -54,11 +54,11 @@ class QuickStore {
         this._base64 = base64;
         this._keyPrefix = `lacertadb_${dbName}_quickstore_`;
         this._indexKey = `${this._keyPrefix}index`;
-        
+
         // Optimization: Keep index in memory using a Set for O(1) lookups
         this._indexCache = new Set();
         this._indexLoaded = false;
-        
+
         // Async persistence state
         this._saveIndexTimer = null;
         this._dirty = false;
@@ -88,7 +88,7 @@ class QuickStore {
 
     _ensureIndexLoaded() {
         if (this._indexLoaded) return;
-        
+
         const indexStr = localStorage.getItem(this._indexKey);
         if (indexStr) {
             try {
@@ -568,7 +568,7 @@ class CacheStrategy {
         const type = this._config.type || 'lru';
         const max = this._config.maxSize || 100;
         const ttl = this._config.ttl;
-        
+
         if (type === 'none' || this._config.enabled === false) return null;
         if (type === 'ttl') return new TTLCache(ttl);
         if (type === 'lfu') return new LFUCache(max, ttl);
@@ -615,9 +615,9 @@ class CacheStrategy {
 // ========================
 
 class BrowserCompressionUtility {
-    // Magic header to distinguish compressed data. 
+    // Magic header to distinguish compressed data.
     // 0x01 = Compressed (Deflate), 0x00 = Raw
-    
+
     async compress(input) {
         if (!(input instanceof Uint8Array)) {
             throw new TypeError('Input must be Uint8Array');
@@ -643,7 +643,7 @@ class BrowserCompressionUtility {
             throw new TypeError('Input must be Uint8Array');
         }
         if (input.length === 0) return input;
-        
+
         const marker = input[0];
         const data = input.slice(1);
 
@@ -777,7 +777,7 @@ class SecureDatabaseEncryption {
         this._initialized = false;
         this._serializer = serializer;
         this._base64 = base64;
-        
+
         this._masterKey = null; // The actual key used for data encryption
         this._hmacKey = null;   // Key for HMAC operations
         this._salt = null;      // Salt for KEK derivation
@@ -798,7 +798,7 @@ class SecureDatabaseEncryption {
             // Load existing
             this._salt = this._base64.decode(existingMetadata.salt);
             const kek = await this._deriveKEK(pinBytes, this._salt);
-            
+
             // Unwrap Master Key
             const wrappedBytes = this._base64.decode(existingMetadata.wrappedKey);
             const iv = wrappedBytes.slice(0, 12);
@@ -816,21 +816,21 @@ class SecureDatabaseEncryption {
             // New Database
             this._salt = crypto.getRandomValues(new Uint8Array(this._saltLength));
             const kek = await this._deriveKEK(pinBytes, this._salt);
-            
+
             // Generate Master Keys (64 bytes: 32 enc + 32 hmac)
             const rawKeys = crypto.getRandomValues(new Uint8Array(64));
             await this._importMasterKeys(rawKeys.buffer);
-            
+
             // Wrap Master Key
             const iv = crypto.getRandomValues(new Uint8Array(12));
             const encryptedMK = await crypto.subtle.encrypt(
                 { name: 'AES-GCM', iv }, kek, rawKeys
             );
-            
+
             const wrappedKey = new Uint8Array(12 + encryptedMK.byteLength);
             wrappedKey.set(iv, 0);
             wrappedKey.set(new Uint8Array(encryptedMK), 12);
-            
+
             this._wrappedKeyBlob = this._base64.encode(wrappedKey);
         }
 
@@ -914,7 +914,7 @@ class SecureDatabaseEncryption {
         // Update State
         this._salt = newSalt;
         this._wrappedKeyBlob = this._base64.encode(wrappedKey);
-        
+
         return this.exportMetadata();
     }
 
@@ -1141,7 +1141,7 @@ class QuadTree {
         if (!this.divided) this._subdivide();
 
         return (this.northeast.insert(point) || this.northwest.insert(point) ||
-                this.southeast.insert(point) || this.southwest.insert(point));
+            this.southeast.insert(point) || this.southwest.insert(point));
     }
 
     query(range, found = []) { // range: {x, y, w, h}
@@ -1183,12 +1183,12 @@ class QuadTree {
 
     _contains(b, p) {
         return (p.x >= b.x - b.w && p.x <= b.x + b.w &&
-                p.y >= b.y - b.h && p.y <= b.y + b.h);
+            p.y >= b.y - b.h && p.y <= b.y + b.h);
     }
 
     _intersects(a, b) {
         return !(b.x - b.w > a.x + a.w || b.x + b.w < a.x - a.w ||
-                 b.y - b.h > a.y + a.h || b.y + b.h < a.y - a.h);
+            b.y - b.h > a.y + a.h || b.y + b.h < a.y - a.h);
     }
 }
 
@@ -1782,7 +1782,7 @@ class TextIndex {
     constructor() {
         this._invertedIndex = new Map();
         this._docTokens = new Map();
-        this._segmenter = typeof Intl !== 'undefined' && Intl.Segmenter ? 
+        this._segmenter = typeof Intl !== 'undefined' && Intl.Segmenter ?
             new Intl.Segmenter(undefined, { granularity: 'word' }) : null;
     }
 
@@ -1868,7 +1868,7 @@ class TextIndex {
 
 class GeoIndex {
     constructor() {
-        this._tree = new QuadTree({x: 0, y: 0, w: 180, h: 90}); 
+        this._tree = new QuadTree({x: 0, y: 0, w: 180, h: 90});
         this._size = 0;
     }
 
@@ -1891,15 +1891,15 @@ class GeoIndex {
     }
 
     findNear(center, maxDistance) {
-        const rangeDeg = maxDistance / 111; 
+        const rangeDeg = maxDistance / 111;
         const range = {
-            x: center.lng, y: center.lat, 
+            x: center.lng, y: center.lat,
             w: rangeDeg, h: rangeDeg
         };
-        
+
         const candidates = this._tree.query(range);
         const results = [];
-        
+
         for (const p of candidates) {
             const distance = this._haversine(center, {lat: p.y, lng: p.x});
             if (distance <= maxDistance) {
@@ -1918,7 +1918,7 @@ class GeoIndex {
         const h = (bounds.maxLat - bounds.minLat) / 2;
         const x = bounds.minLng + w;
         const y = bounds.minLat + h;
-        
+
         const candidates = this._tree.query({x, y, w, h});
         return candidates.map(p => p.data);
     }
@@ -2003,30 +2003,30 @@ class IndexManager {
         // This prevents transaction timeouts caused by async crypto operations inside the loop
         let lastKey = null;
         const batchSize = 100; // Keep batch small for responsiveness
-        
+
         while (true) {
             // 1. Fetch Batch (Transaction opens and closes here)
             const batch = await this._collection._indexedDB.getBatch(
-                this._collection._db, 
-                'documents', 
-                lastKey, 
+                this._collection._db,
+                'documents',
+                lastKey,
                 batchSize
             );
-            
+
             if (batch.length === 0) break;
-            
+
             // 2. Process Batch (Async crypto operations safe here)
             for (const docData of batch) {
                 lastKey = docData._id; // Update for next batch
                 let doc = docData;
-                
+
                 if (docData.packedData) {
                     const d = new Document(docData, {
-                        compressed: docData._compressed, 
+                        compressed: docData._compressed,
                         encrypted: docData._encrypted
                     }, this._serializer);
                     // This await is what killed the transaction before
-                    await d.unpack(this._collection.database.encryption); 
+                    await d.unpack(this._collection.database.encryption);
                     doc = d.objectOutput();
                 }
 
@@ -2047,7 +2047,7 @@ class IndexManager {
 
                 this._addToIndex(indexData, value, doc._id, index.type);
             }
-            
+
             // Optional: Yield to main thread briefly to prevent UI freeze
             if (window.requestIdleCallback) await new Promise(r => window.requestIdleCallback(r));
         }
@@ -2087,7 +2087,7 @@ class IndexManager {
                 break;
         }
     }
-    
+
     async _hashVal(val) {
         const msg = new TextEncoder().encode(String(val));
         const hash = await crypto.subtle.digest('SHA-256', msg);
@@ -2101,7 +2101,7 @@ class IndexManager {
 
             let oldValue = oldDoc ? this._getFieldValue(oldDoc, index.fieldPath) : undefined;
             let newValue = newDoc ? this._getFieldValue(newDoc, index.fieldPath) : undefined;
-            
+
             if (index.hashed) {
                 if (oldValue) oldValue = await this._hashVal(oldValue);
                 if (newValue) newValue = await this._hashVal(newValue);
@@ -2147,9 +2147,9 @@ class IndexManager {
         if (!index || !indexData) {
             throw new Error(`Index '${indexName}' not found`);
         }
-        
+
         if (index.hashed && typeof queryOptions !== 'object') {
-             queryOptions = await this._hashVal(queryOptions);
+            queryOptions = await this._hashVal(queryOptions);
         }
 
         return this._queryIndex(indexData, queryOptions, index.type);
@@ -2753,45 +2753,221 @@ class Document {
 // ========================
 
 class CollectionMetadata {
-    constructor(name, data = {}) {
+    constructor(name, data = {}, serializer, base64, dbName) {
         this.name = name;
+        this._serializer = serializer;
+        this._base64 = base64;
+        this._dbName = dbName;
+        this._storageKey = dbName ? `lacertadb_${dbName}_${name}_collmeta` : null;
+
+        // Aggregate stats
         this.sizeKB = data.sizeKB || 0;
         this.length = data.length || 0;
         this.createdAt = data.createdAt || Date.now();
         this.modifiedAt = data.modifiedAt || Date.now();
-        // Removed detailed per-doc tracking to save space
-        this.documentSizes = {};
-        this.documentModifiedAt = {};
-        this.documentPermanent = {};
-        this.documentAttachments = {};
+
+        // Per-document tracking (in-memory Maps for O(1) ops)
+        this._docSizes = new Map(data._docSizes || []);        // docId -> sizeKB
+        this._docModified = new Map(data._docModified || []);   // docId -> timestamp
+        this._docPermanent = new Map(data._docPermanent || []); // docId -> boolean
+        this._docAttachments = new Map(data._docAttachments || []); // docId -> count
+
+        // Debounced persistence
+        this._dirty = false;
+        this._saveTimer = null;
+
+        // Safety: flush on page unload
+        this._flushHandler = () => this._flushSync();
+        if (typeof window !== 'undefined') {
+            window.addEventListener('beforeunload', this._flushHandler);
+        }
     }
 
-    addDocument(docId, sizeKB, isPermanent, attachmentCount) {
-        // Optimization: Don't store detailed map in LS to avoid QuotaExceeded
-        // this.documentSizes[docId] = sizeKB;
+    // ---- Mutations (in-memory only, schedule async save) ----
+
+    addDocument(docId, sizeKB, isPermanent = false, attachmentCount = 0) {
+        this._docSizes.set(docId, sizeKB);
+        this._docModified.set(docId, Date.now());
+        this._docPermanent.set(docId, isPermanent);
+        this._docAttachments.set(docId, attachmentCount);
+
         this.sizeKB += sizeKB;
         this.length++;
         this.modifiedAt = Date.now();
+        this._scheduleSave();
     }
 
-    updateDocument(docId, newSizeKB, isPermanent, attachmentCount) {
-        // Approximate tracking
-        // const oldSize = this.documentSizes[docId] || 0;
-        // this.sizeKB = this.sizeKB - oldSize + newSizeKB;
+    updateDocument(docId, newSizeKB, isPermanent = false, attachmentCount = 0) {
+        const oldSize = this._docSizes.get(docId) || 0;
+        this.sizeKB = this.sizeKB - oldSize + newSizeKB;
+
+        this._docSizes.set(docId, newSizeKB);
+        this._docModified.set(docId, Date.now());
+        this._docPermanent.set(docId, isPermanent);
+        this._docAttachments.set(docId, attachmentCount);
+
         this.modifiedAt = Date.now();
+        this._scheduleSave();
     }
 
     removeDocument(docId) {
-        // const sizeKB = this.documentSizes[docId] || 0;
-        // this.sizeKB -= sizeKB;
-        // this.length--;
+        const sizeKB = this._docSizes.get(docId) || 0;
+        this.sizeKB -= sizeKB;
+        this.length--;
+
+        this._docSizes.delete(docId);
+        this._docModified.delete(docId);
+        this._docPermanent.delete(docId);
+        this._docAttachments.delete(docId);
+
         this.modifiedAt = Date.now();
+        this._scheduleSave();
     }
 
+    // ---- Queries (instant from memory) ----
+
     getOldestNonPermanentDocuments(count) {
-        // If we removed the maps, we can't do this efficiently from metadata alone.
-        // Should query DB index 'modified' instead.
-        return []; 
+        const candidates = [];
+        for (const [docId, modified] of this._docModified) {
+            if (!this._docPermanent.get(docId)) {
+                candidates.push({ id: docId, modified });
+            }
+        }
+        candidates.sort((a, b) => a.modified - b.modified);
+        return candidates.slice(0, count).map(c => c.id);
+    }
+
+    getDocumentSize(docId) {
+        return this._docSizes.get(docId) || 0;
+    }
+
+    isDocumentPermanent(docId) {
+        return this._docPermanent.get(docId) || false;
+    }
+
+    hasDocument(docId) {
+        return this._docSizes.has(docId);
+    }
+
+    // ---- Aggregate snapshot (for DatabaseMetadata) ----
+
+    getAggregateSnapshot() {
+        return {
+            sizeKB: this.sizeKB,
+            length: this.length,
+            createdAt: this.createdAt,
+            modifiedAt: this.modifiedAt
+        };
+    }
+
+    // ---- Persistence ----
+
+    _scheduleSave() {
+        this._dirty = true;
+        if (this._saveTimer) return;
+
+        const save = () => {
+            this._saveTimer = null;
+            if (!this._dirty) return;
+            this._persistToStorage();
+        };
+
+        if (typeof window !== 'undefined' && window.requestIdleCallback) {
+            this._saveTimer = window.requestIdleCallback(save);
+        } else {
+            this._saveTimer = setTimeout(save, 300);
+        }
+    }
+
+    _flushSync() {
+        if (!this._dirty) return;
+        this._persistToStorage();
+    }
+
+    _persistToStorage() {
+        if (!this._storageKey || !this._serializer || !this._base64) return;
+        try {
+            const dataToStore = {
+                sizeKB: this.sizeKB,
+                length: this.length,
+                createdAt: this.createdAt,
+                modifiedAt: this.modifiedAt,
+                _docSizes: Array.from(this._docSizes.entries()),
+                _docModified: Array.from(this._docModified.entries()),
+                _docPermanent: Array.from(this._docPermanent.entries()),
+                _docAttachments: Array.from(this._docAttachments.entries())
+            };
+            const serialized = this._serializer.serialize(dataToStore);
+            const encoded = this._base64.encode(serialized);
+            localStorage.setItem(this._storageKey, encoded);
+            this._dirty = false;
+        } catch (e) {
+            if (e.name === 'QuotaExceededError') {
+                // Fallback: persist only aggregate stats (drop per-doc maps)
+                console.warn('CollectionMetadata: quota exceeded, saving aggregates only');
+                try {
+                    const fallback = {
+                        sizeKB: this.sizeKB,
+                        length: this.length,
+                        createdAt: this.createdAt,
+                        modifiedAt: this.modifiedAt
+                    };
+                    const serialized = this._serializer.serialize(fallback);
+                    const encoded = this._base64.encode(serialized);
+                    localStorage.setItem(this._storageKey, encoded);
+                    this._dirty = false;
+                } catch (e2) {
+                    console.error('CollectionMetadata: fallback save also failed:', e2);
+                }
+            } else {
+                console.error('CollectionMetadata save failed:', e);
+            }
+        }
+    }
+
+    static load(dbName, collName, serializer, base64) {
+        const key = `lacertadb_${dbName}_${collName}_collmeta`;
+        const stored = localStorage.getItem(key);
+        if (stored) {
+            try {
+                const decoded = base64.decode(stored);
+                const data = serializer.deserialize(decoded);
+                return new CollectionMetadata(collName, data, serializer, base64, dbName);
+            } catch (e) {
+                console.warn('CollectionMetadata corrupted, resetting:', e);
+            }
+        }
+        return new CollectionMetadata(collName, {}, serializer, base64, dbName);
+    }
+
+    // ---- Lifecycle ----
+
+    destroy() {
+        this._flushSync();
+        if (typeof window !== 'undefined' && this._flushHandler) {
+            window.removeEventListener('beforeunload', this._flushHandler);
+            this._flushHandler = null;
+        }
+        if (this._saveTimer) {
+            if (typeof window !== 'undefined' && window.cancelIdleCallback) {
+                window.cancelIdleCallback(this._saveTimer);
+            } else {
+                clearTimeout(this._saveTimer);
+            }
+            this._saveTimer = null;
+        }
+    }
+
+    clear() {
+        this.sizeKB = 0;
+        this.length = 0;
+        this.modifiedAt = Date.now();
+        this._docSizes.clear();
+        this._docModified.clear();
+        this._docPermanent.clear();
+        this._docAttachments.clear();
+        this._dirty = true;
+        this._flushSync();
     }
 }
 
@@ -2804,6 +2980,15 @@ class DatabaseMetadata {
         this.totalSizeKB = data.totalSizeKB || 0;
         this.totalLength = data.totalLength || 0;
         this.modifiedAt = data.modifiedAt || Date.now();
+
+        // Debounced persistence
+        this._dirty = false;
+        this._saveTimer = null;
+
+        this._flushHandler = () => this._flushSync();
+        if (typeof window !== 'undefined') {
+            window.addEventListener('beforeunload', this._flushHandler);
+        }
     }
 
     static load(dbName, serializer, base64) {
@@ -2821,7 +3006,54 @@ class DatabaseMetadata {
         return new DatabaseMetadata(dbName, {}, serializer, base64);
     }
 
-    save() {
+    setCollection(collectionMetadata) {
+        this.collections[collectionMetadata.name] = collectionMetadata.getAggregateSnapshot();
+        this._recalculate();
+        this._scheduleSave();
+    }
+
+    removeCollection(collectionName) {
+        delete this.collections[collectionName];
+        this._recalculate();
+        this._scheduleSave();
+    }
+
+    _recalculate() {
+        this.totalSizeKB = 0;
+        this.totalLength = 0;
+        for (const collName in this.collections) {
+            const coll = this.collections[collName];
+            this.totalSizeKB += coll.sizeKB;
+            this.totalLength += coll.length;
+        }
+        this.modifiedAt = Date.now();
+    }
+
+    // ---- Debounced persistence ----
+
+    _scheduleSave() {
+        this._dirty = true;
+        if (this._saveTimer) return;
+
+        const save = () => {
+            this._saveTimer = null;
+            if (!this._dirty) return;
+            this._persistToStorage();
+        };
+
+        if (typeof window !== 'undefined' && window.requestIdleCallback) {
+            this._saveTimer = window.requestIdleCallback(save);
+        } else {
+            this._saveTimer = setTimeout(save, 300);
+        }
+    }
+
+    _flushSync() {
+        if (!this._dirty) return;
+        this._persistToStorage();
+    }
+
+    _persistToStorage() {
         const key = `lacertadb_${this.name}_metadata`;
         try {
             const dataToStore = {
@@ -2833,6 +3065,7 @@ class DatabaseMetadata {
             const serializedData = this._serializer.serialize(dataToStore);
             const encodedData = this._base64.encode(serializedData);
             localStorage.setItem(key, encodedData);
+            this._dirty = false;
         } catch (e) {
             if (e.name === 'QuotaExceededError') {
                 console.error('CRITICAL: LocalStorage quota exceeded. Metadata not saved for db:', this.name);
@@ -2845,32 +3078,28 @@ class DatabaseMetadata {
         }
     }
 
-    setCollection(collectionMetadata) {
-        this.collections[collectionMetadata.name] = {
-            sizeKB: collectionMetadata.sizeKB,
-            length: collectionMetadata.length,
-            createdAt: collectionMetadata.createdAt,
-            modifiedAt: collectionMetadata.modifiedAt
-        };
-        this._recalculate();
-        this.save();
+    // Force immediate save (for critical operations like clearAll)
+    save() {
+        this._dirty = true;
+        this._flushSync();
     }
 
-    removeCollection(collectionName) {
-        delete this.collections[collectionName];
-        this._recalculate();
-        this.save();
-    }
+    // ---- Lifecycle ----
 
-    _recalculate() {
-        this.totalSizeKB = 0;
-        this.totalLength = 0;
-        for (const collName in this.collections) {
-            const coll = this.collections[collName];
-            this.totalSizeKB += coll.sizeKB;
-            this.totalLength += coll.length;
+    destroy() {
+        this._flushSync();
+        if (typeof window !== 'undefined' && this._flushHandler) {
+            window.removeEventListener('beforeunload', this._flushHandler);
+            this._flushHandler = null;
+        }
+        if (this._saveTimer) {
+            if (typeof window !== 'undefined' && window.cancelIdleCallback) {
+                window.cancelIdleCallback(this._saveTimer);
+            } else {
+                clearTimeout(this._saveTimer);
+            }
+            this._saveTimer = null;
         }
-        this.modifiedAt = Date.now();
     }
 }
 
@@ -3403,8 +3632,10 @@ class Collection {
             }
         });
 
-        const metadataData = this.database.metadata.collections[this.name];
-        this._metadata = new CollectionMetadata(this.name, metadataData);
+        // Load per-collection metadata (with per-doc tracking) from its own localStorage key
+        this._metadata = CollectionMetadata.load(
+            this.database.name, this.name, this._serializer, this._base64
+        );
 
         await this._indexManager.loadIndexMetadata();
 
@@ -3917,7 +4148,11 @@ class Collection {
             await this._indexedDB.clear(this._db, 'documents');
 
             // Reset metadata
-            this._metadata = new CollectionMetadata(this.name);
+            if (this._metadata) this._metadata.destroy();
+            this._metadata = new CollectionMetadata(
+                this.name, {}, this._serializer, this._base64, this.database.name
+            );
+            this._metadata._flushSync();
             this.database.metadata.setCollection(this._metadata);
 
             // Clear cache
@@ -3945,6 +4180,11 @@ class Collection {
     }
 
     destroy() {
+        // Flush and destroy collection metadata
+        if (this._metadata) {
+            this._metadata.destroy();
+        }
+
         // Clear the cleanup interval
         if (this._cleanupInterval) {
             clearInterval(this._cleanupInterval);
@@ -4031,7 +4271,7 @@ class Database {
         const encMetaKey = `lacertadb_${this.name}_encryption`;
         let existingMetadata = null;
         const stored = localStorage.getItem(encMetaKey);
-        
+
         if (stored) {
             const decoded = this._base64.decode(stored);
             existingMetadata = this._serializer.deserialize(decoded);
@@ -4114,7 +4354,9 @@ class Database {
         this._collections.set(name, collection);
 
         if (!this._metadata.collections[name]) {
-            this._metadata.setCollection(new CollectionMetadata(name));
+            this._metadata.setCollection(new CollectionMetadata(
+                name, {}, this._serializer, this._base64, this.name
+            ));
         }
         return collection;
     }
@@ -4148,6 +4390,10 @@ class Database {
 
         this._metadata.removeCollection(name);
 
+        // Clean up collection-level metadata and index localStorage keys
+        localStorage.removeItem(`lacertadb_${this.name}_${name}_collmeta`);
+        localStorage.removeItem(`lacertadb_${this.name}_${name}_indexes`);
+
         const dbName = `${this.name}_${name}`;
         await new Promise((resolve, reject) => {
             const deleteReq = indexedDB.deleteDatabase(dbName);
@@ -4246,6 +4492,7 @@ class Database {
     async clearAll() {
         await Promise.all([...this._collections.keys()].map(name => this.dropCollection(name)));
         this._collections.clear();
+        if (this._metadata) this._metadata.destroy();
         this._metadata = new DatabaseMetadata(this.name, {}, this._serializer, this._base64);
         this._metadata.save();
         this._quickStore.clear();
@@ -4266,6 +4513,11 @@ class Database {
             this._quickStore.destroy();
         }
 
+        // Destroy database metadata
+        if (this._metadata) {
+            this._metadata.destroy();
+        }
+
         // Destroy encryption
         if (this._encryption) {
             this._encryption.destroy();