@pixagram/lacerta-db 0.5.4 → 0.5.5

package/index.js

@@ -1,5 +1,5 @@
 /**
- * LacertaDB V5.0.0 - Complete Production Library (Corrected)
+ * LacertaDB V5.0.0 - Complete Production Library
  * A powerful browser-based document database with encryption, compression, OPFS support,
  * custom indexes, LRU caching, and database-level security for private keys
  * @version 5.0.0
@@ -488,44 +488,22 @@ class BrowserEncryptionUtility {
 }
 
 // ========================
-// Database-Level Encryption (CORRECTED)
+// Database-Level Encryption
 // ========================
 
 class SecureDatabaseEncryption {
-    constructor(config = {}) {
+    constructor() {
         this.masterKey = null;
         this.salt = null;
-        // Make iterations configurable with higher default for better security
-        this.iterations = config.iterations || 2000000; // Increased from 1M to 2M
-        this.minPasswordLength = config.minPasswordLength || 12; // Minimum password length
+        this.iterations = 1000000;
         this.initialized = false;
     }
 
-    validatePassword(password) {
-        if (password.length < this.minPasswordLength) {
-            throw new Error(`Password must be at least ${this.minPasswordLength} characters for secure encryption`);
-        }
-
-        // Check password complexity
-        const hasUpperCase = /[A-Z]/.test(password);
-        const hasLowerCase = /[a-z]/.test(password);
-        const hasNumbers = /\d/.test(password);
-        const hasNonalphas = /\W/.test(password);
-        const complexity = [hasUpperCase, hasLowerCase, hasNumbers, hasNonalphas].filter(Boolean).length;
-
-        if (complexity < 3) {
-            throw new Error('Password must contain at least 3 of: uppercase, lowercase, numbers, special characters');
-        }
-    }
-
     async initialize(pin, salt = null) {
         if (this.initialized) {
             throw new Error('Database encryption already initialized');
         }
 
-        // Validate password strength
-        this.validatePassword(pin);
-
         this.salt = salt || crypto.getRandomValues(new Uint8Array(32));
 
         const encoder = new TextEncoder();
@@ -732,12 +710,11 @@ class SecureDatabaseEncryption {
         return new TextDecoder().decode(decryptedKey);
     }
 
-    static generateSecurePassword(length = 20) {
-        const charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()_+-=[]{}|;:,.<>?';
-        const randomValues = new Uint8Array(length);
-        crypto.getRandomValues(randomValues);
-        return Array.from(randomValues)
-            .map(x => charset[x % charset.length])
+    static generateSecurePIN(length = 6) {
+        const digits = new Uint8Array(length);
+        crypto.getRandomValues(digits);
+        return Array.from(digits)
+            .map(b => (b % 10).toString())
             .join('');
     }
 
@@ -762,17 +739,12 @@ class SecureDatabaseEncryption {
             throw new Error('Database encryption not initialized');
         }
 
-        // Validate new password
-        this.validatePassword(newPin);
-
         const currentSalt = this.salt;
-        const currentIterations = this.iterations;
 
         this.destroy();
         await this.initialize(oldPin, currentSalt);
 
         this.destroy();
-        this.iterations = currentIterations;
         const newSalt = await this.initialize(newPin);
 
         return newSalt;
@@ -787,8 +759,7 @@ class SecureDatabaseEncryption {
             salt: base64.encode(this.salt),
             iterations: this.iterations,
             algorithm: 'AES-GCM-256',
-            kdf: 'PBKDF2-SHA-512',
-            minPasswordLength: this.minPasswordLength
+            kdf: 'PBKDF2-SHA-512'
         };
     }
 
@@ -798,8 +769,7 @@ class SecureDatabaseEncryption {
         }
 
         this.salt = base64.decode(metadata.salt);
-        this.iterations = metadata.iterations || 2000000;
-        this.minPasswordLength = metadata.minPasswordLength || 12;
+        this.iterations = metadata.iterations || 1000000;
 
         return true;
     }
@@ -1830,7 +1800,7 @@ class Document {
             _created: this._created,
             _modified: this._modified,
             _permanent: this._permanent,
-            ...this.data
+            ...(this.data || {})  // Fixed: handle undefined data
         };
         if (includeAttachments && this._attachments.length > 0) {
             output._attachments = this._attachments;
@@ -1853,7 +1823,7 @@ class Document {
 }
 
 // ========================
-// Metadata Classes (CORRECTED)
+// Metadata Classes
 // ========================
 
 class CollectionMetadata {
@@ -1921,20 +1891,6 @@ class CollectionMetadata {
             .slice(0, count)
             .map(([docId]) => docId);
     }
-
-    toJSON() {
-        return {
-            name: this.name,
-            sizeKB: this.sizeKB,
-            length: this.length,
-            createdAt: this.createdAt,
-            modifiedAt: this.modifiedAt,
-            documentSizes: this.documentSizes,
-            documentModifiedAt: this.documentModifiedAt,
-            documentPermanent: this.documentPermanent,
-            documentAttachments: this.documentAttachments
-        };
-    }
 }
 
 class DatabaseMetadata {
@@ -1982,18 +1938,16 @@ class DatabaseMetadata {
     }
 
     setCollection(collectionMetadata) {
-        this.collections[collectionMetadata.name] = collectionMetadata.toJSON ?
-            collectionMetadata.toJSON() :
-            {
-                sizeKB: collectionMetadata.sizeKB,
-                length: collectionMetadata.length,
-                createdAt: collectionMetadata.createdAt,
-                modifiedAt: collectionMetadata.modifiedAt,
-                documentSizes: collectionMetadata.documentSizes,
-                documentModifiedAt: collectionMetadata.documentModifiedAt,
-                documentPermanent: collectionMetadata.documentPermanent,
-                documentAttachments: collectionMetadata.documentAttachments
-            };
+        this.collections[collectionMetadata.name] = {
+            sizeKB: collectionMetadata.sizeKB,
+            length: collectionMetadata.length,
+            createdAt: collectionMetadata.createdAt,
+            modifiedAt: collectionMetadata.modifiedAt,
+            documentSizes: collectionMetadata.documentSizes,
+            documentModifiedAt: collectionMetadata.documentModifiedAt,
+            documentPermanent: collectionMetadata.documentPermanent,
+            documentAttachments: collectionMetadata.documentAttachments
+        };
         this.recalculate();
         this.save();
     }
@@ -2146,16 +2100,16 @@ class QuickStore {
     }
 
     clear() {
-        const index = this._readIndex();
+        const index = this._readIndex();  // Fixed: was this.readIndex()
         for (const docId of index) {
-            localStorage.removeItem(`${this.keyPrefix}data_${docId}`);
+            localStorage.removeItem(`${this.keyPrefix}data_${docId}`);  // Fixed: added underscore
         }
         localStorage.removeItem(this.indexKey);
     }
 }
 
 // ========================
-// Query Engine (CORRECTED)
+// Query Engine
 // ========================
 
 class QueryEngine {
@@ -2539,7 +2493,7 @@ class PerformanceMonitor {
 }
 
 // ========================
-// Collection Class (CORRECTED)
+// Collection Class
 // ========================
 
 class Collection {
@@ -2777,15 +2731,13 @@ class Collection {
         }
 
         // Get full document for index cleanup
-        const fullDoc = await this.get(docId, { password: options.password }).catch(() => null);
+        const fullDoc = await this.get(docId);
 
         // Remove from indexes
-        if (fullDoc) {
-            for (const [indexName, index] of this.indexManager.indexes) {
-                const value = this.indexManager.getFieldValue(fullDoc, index.fieldPath);
-                if (value !== undefined && value !== null) {
-                    await this.indexManager.updateIndex(indexName, docId, value, undefined);
-                }
+        for (const [indexName, index] of this.indexManager.indexes) {
+            const value = this.indexManager.getFieldValue(fullDoc, index.fieldPath);
+            if (value !== undefined && value !== null) {
+                await this.indexManager.updateIndex(indexName, docId, value, undefined);
             }
         }
 
@@ -2822,7 +2774,15 @@ class Collection {
         for (const [indexName, index] of this.indexManager.indexes) {
             const fieldValue = filter[index.fieldPath];
             if (fieldValue !== undefined) {
-                const docIds = await this.indexManager.query(indexName, fieldValue);
+                // Fixed: Handle query operators properly
+                let queryOptions;
+                if (typeof fieldValue === 'object' && fieldValue !== null && !Array.isArray(fieldValue)) {
+                    queryOptions = fieldValue;  // e.g., { $gte: 25 }
+                } else {
+                    queryOptions = { $eq: fieldValue };  // e.g., simple value
+                }
+
+                const docIds = await this.indexManager.query(indexName, queryOptions);
                 results = await Promise.all(
                     docIds.map(id => this.get(id).catch(() => null))
                 );
@@ -2965,7 +2925,7 @@ class Collection {
 }
 
 // ========================
-// Database Class (CORRECTED)
+// Database Class
 // ========================
 
 class Database {
@@ -2996,7 +2956,7 @@ class Database {
     }
 
     async initializeEncryption(pin, salt = null) {
-        this.encryption = new SecureDatabaseEncryption(this.database?.encryptionConfig || {});
+        this.encryption = new SecureDatabaseEncryption();
 
         // Check if we have existing salt in metadata
         const encMetaKey = `lacertadb_${this.name}_encryption`;
@@ -3051,9 +3011,9 @@ class Database {
         );
 
         // Store in a special collection
-        let keyStore = await this.getCollection('__private_keys__').catch(() => null);
+        let keyStore = await this.getCollection('private_keys').catch(() => null);
         if (!keyStore) {
-            keyStore = await this.createCollection('__private_keys__', {
+            keyStore = await this.createCollection('private_keys', {
                 encrypted: false // Already encrypted at database level
             });
         }
@@ -3075,7 +3035,7 @@ class Database {
             throw new Error('Database must be encrypted to retrieve private keys');
         }
 
-        const keyStore = await this.getCollection('__private_keys__');
+        const keyStore = await this.getCollection('private_keys');
         const doc = await keyStore.get(keyName);
 
         if (!doc) {
@@ -3202,11 +3162,7 @@ class Database {
             try {
                 collection = await this.createCollection(collName);
             } catch (e) {
-                if (e.code === 'COLLECTION_EXISTS') {
-                    collection = await this.getCollection(collName);
-                } else {
-                    throw e;
-                }
+                collection = await this.getCollection(collName);
             }
             await collection.batchAdd(docs);
         }
@@ -3236,10 +3192,10 @@ class Database {
 }
 
 // ========================
-// Main LacertaDB Class (CORRECTED)
+// Main LacertaDB Class
 // ========================
 
-class LacertaDB {
+export class LacertaDB {
     constructor() {
         this.databases = new Map();
         this.performanceMonitor = new PerformanceMonitor();
@@ -3254,12 +3210,8 @@ class LacertaDB {
         return this.databases.get(name);
     }
 
-    async getSecureDatabase(name, pin, salt = null, encryptionConfig = {}) {
-        return this.getDatabase(name, {
-            pin,
-            salt,
-            encryptionConfig
-        });
+    async getSecureDatabase(name, pin, salt = null) {
+        return this.getDatabase(name, { pin, salt });
     }
 
     async dropDatabase(name) {
@@ -3279,32 +3231,15 @@ class LacertaDB {
 
     listDatabases() {
         const dbNames = new Set();
-        const prefixesToCheck = ['lacertadb_'];
-
         for (let i = 0; i < localStorage.length; i++) {
             const key = localStorage.key(i);
-            if (!key) continue;
-
-            for (const prefix of prefixesToCheck) {
-                if (key.startsWith(prefix)) {
-                    // Extract database name - everything between prefix and next underscore
-                    const afterPrefix = key.substring(prefix.length);
-                    const suffixes = ['_metadata', '_settings', '_version', '_encryption', '_quickstore', '_indexes'];
-
-                    for (const suffix of suffixes) {
-                        const suffixIndex = afterPrefix.lastIndexOf(suffix);
-                        if (suffixIndex > 0) {
-                            const dbName = afterPrefix.substring(0, suffixIndex);
-                            if (dbName) {
-                                dbNames.add(dbName);
-                            }
-                            break;
-                        }
-                    }
+            if (key && key.startsWith('lacertadb_')) {  // Fixed: was 'lacertadb'
+                const parts = key.split('_');  // Fixed: was split('')
+                if (parts.length >= 2) {
+                    dbNames.add(parts[1]);
                 }
             }
         }
-
         return [...dbNames];
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pixagram/lacerta-db",
-  "version": "0.5.4",
+  "version": "0.5.5",
   "description": "Lacerta-DB is a Javascript IndexedDB Database for Web Browsers. Simple, Fast, Secure.",
   "devDependencies": {
     "@babel/core": "^7.23.6",