idb-ts 3.2.0 → 3.7.0

package/lib/index.esm.js

@@ -1,60 +1,298 @@
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataClass = exports.KeyPath = exports.Database = void 0;
+exports.KeyGenerators = exports.Index = exports.DataClass = exports.CompositeKeyPath = exports.KeyPath = exports.Database = void 0;
 const tslib_1 = require("tslib");
 require("reflect-metadata");
-function KeyPath() {
+class QueryBuilder {
+    constructor(db, storeName) {
+        this.conditions = [];
+        this.orderDirection = 'asc';
+        this.db = db;
+        this.storeName = storeName;
+    }
+    where(field) {
+        this.currentField = field;
+        return this;
+    }
+    and(field) {
+        this.currentField = field;
+        return this;
+    }
+    equals(value) {
+        if (!this.currentField)
+            throw new Error('No field specified for equals');
+        this.conditions.push({ field: this.currentField, op: 'equals', value });
+        this.currentField = undefined;
+        return this;
+    }
+    gt(value) {
+        if (!this.currentField)
+            throw new Error('No field specified for gt');
+        this.conditions.push({ field: this.currentField, op: 'gt', value });
+        this.currentField = undefined;
+        return this;
+    }
+    gte(value) {
+        if (!this.currentField)
+            throw new Error('No field specified for gte');
+        this.conditions.push({ field: this.currentField, op: 'gte', value });
+        this.currentField = undefined;
+        return this;
+    }
+    lt(value) {
+        if (!this.currentField)
+            throw new Error('No field specified for lt');
+        this.conditions.push({ field: this.currentField, op: 'lt', value });
+        this.currentField = undefined;
+        return this;
+    }
+    lte(value) {
+        if (!this.currentField)
+            throw new Error('No field specified for lte');
+        this.conditions.push({ field: this.currentField, op: 'lte', value });
+        this.currentField = undefined;
+        return this;
+    }
+    orderBy(field, direction = 'asc') {
+        this.orderField = field;
+        this.orderDirection = direction;
+        return this;
+    }
+    limit(n) {
+        this.limitCount = n;
+        return this;
+    }
+    offset(n) {
+        this.offsetCount = n;
+        return this;
+    }
+    useIndex(indexName) {
+        this.indexName = indexName;
+        return this;
+    }
+    range(start, end) {
+        this.rangeStart = start;
+        this.rangeEnd = end;
+        return this;
+    }
+    execute() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const tx = this.db.transaction(this.storeName, 'readonly');
+                let store = tx.objectStore(this.storeName);
+                let request;
+                let results = [];
+                if (this.indexName) {
+                    if (!store.indexNames.contains(this.indexName)) {
+                        reject(new Error(`Index '${this.indexName}' does not exist on ${this.storeName}`));
+                        return;
+                    }
+                    const index = store.index(this.indexName);
+                    let keyRange;
+                    if (this.rangeStart !== undefined && this.rangeEnd !== undefined) {
+                        keyRange = IDBKeyRange.bound(this.rangeStart, this.rangeEnd);
+                    }
+                    else if (this.rangeStart !== undefined) {
+                        keyRange = IDBKeyRange.lowerBound(this.rangeStart);
+                    }
+                    else if (this.rangeEnd !== undefined) {
+                        keyRange = IDBKeyRange.upperBound(this.rangeEnd);
+                    }
+                    request = index.openCursor(keyRange);
+                }
+                else {
+                    request = store.openCursor();
+                }
+                request.onsuccess = () => {
+                    const cursor = request.result;
+                    if (cursor) {
+                        let match = true;
+                        const value = cursor.value;
+                        for (const cond of this.conditions) {
+                            const val = value[cond.field];
+                            switch (cond.op) {
+                                case 'equals':
+                                    match = match && val === cond.value;
+                                    break;
+                                case 'gt':
+                                    match = match && val > cond.value;
+                                    break;
+                                case 'gte':
+                                    match = match && val >= cond.value;
+                                    break;
+                                case 'lt':
+                                    match = match && val < cond.value;
+                                    break;
+                                case 'lte':
+                                    match = match && val <= cond.value;
+                                    break;
+                            }
+                        }
+                        if (match)
+                            results.push(value);
+                        cursor.continue();
+                    }
+                    else {
+                        if (this.orderField) {
+                            results.sort((a, b) => {
+                                const va = a[this.orderField];
+                                const vb = b[this.orderField];
+                                if (va < vb)
+                                    return this.orderDirection === 'asc' ? -1 : 1;
+                                if (va > vb)
+                                    return this.orderDirection === 'asc' ? 1 : -1;
+                                return 0;
+                            });
+                        }
+                        if (this.offsetCount !== undefined)
+                            results = results.slice(this.offsetCount);
+                        if (this.limitCount !== undefined)
+                            results = results.slice(0, this.limitCount);
+                        resolve(results);
+                    }
+                };
+                request.onerror = () => reject(request.error);
+            });
+        });
+    }
+}
+class KeyGenerators {
+    static uuid() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+            const r = Math.random() * 16 | 0;
+            const v = c === 'x' ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        });
+    }
+    static timestamp() {
+        return Date.now();
+    }
+    static random() {
+        return Math.random().toString(36).substring(2, 15);
+    }
+}
+exports.KeyGenerators = KeyGenerators;
+function KeyPath(options) {
     return (target, propertyKey) => {
         const constructor = target.constructor;
-        Reflect.defineMetadata("keypath", [propertyKey], constructor);
+        const existingKeypaths = Reflect.getMetadata("individual_keypaths", constructor) || [];
+        existingKeypaths.push(propertyKey);
+        Reflect.defineMetadata("individual_keypaths", existingKeypaths, constructor);
+        const metadata = {
+            fields: propertyKey,
+            options: options
+        };
+        Reflect.defineMetadata("keypath", metadata, constructor);
     };
 }
 exports.KeyPath = KeyPath;
-function DataClass() {
+function CompositeKeyPath(fields, options) {
+    return (target) => {
+        const metadata = {
+            fields: fields,
+            options: options
+        };
+        Reflect.defineMetadata("keypath", metadata, target);
+    };
+}
+exports.CompositeKeyPath = CompositeKeyPath;
+function Index() {
+    return (target, propertyKey) => {
+        const constructor = target.constructor;
+        const existing = Reflect.getMetadata("indexes", constructor) || [];
+        Reflect.defineMetadata("indexes", [...existing, propertyKey], constructor);
+    };
+}
+exports.Index = Index;
+function DataClass(options = {}) {
     return (target) => {
-        if (!Reflect.getMetadata("keypath", target)) {
+        const keyPathMetadata = Reflect.getMetadata("keypath", target);
+        if (!keyPathMetadata) {
             throw new Error(`No keypath field defined for the class ${target.name}.`);
         }
-        const keyPathFields = Reflect.getMetadata("keypath", target) || [];
-        if (keyPathFields.length > 1) {
+        const individualKeypaths = Reflect.getMetadata("individual_keypaths", target) || [];
+        if (individualKeypaths.length > 1) {
             throw new Error(`Only one keypath field can be defined for the class ${target.name}.`);
         }
+        const version = options.version || 1;
         Reflect.defineMetadata("dataclass", true, target);
+        Reflect.defineMetadata("version", version, target);
     };
 }
 exports.DataClass = DataClass;
 class Database {
     constructor(dbName, classes) {
         this.db = null;
+        this.entityRepositories = new Map();
         this.dbName = dbName;
         if (!classes.every(cls => Reflect.getMetadata("dataclass", cls))) {
             throw new Error("All classes should be decorated with @DataClass.");
         }
         this.classes = classes;
+        this.dbVersion = this.calculateDatabaseVersion();
+    }
+    calculateDatabaseVersion() {
+        const versions = this.classes.map(cls => Reflect.getMetadata("version", cls) || 1);
+        return Math.max(...versions);
     }
     static build(dbName, classes) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             const instance = new Database(dbName, classes);
             yield instance.initDB();
+            instance.generateEntityRepositories();
             return instance;
         });
     }
     initDB() {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve, reject) => {
-                const request = indexedDB.open(this.dbName, 1);
-                request.onupgradeneeded = () => {
+                const request = indexedDB.open(this.dbName, this.dbVersion);
+                request.onupgradeneeded = (event) => {
                     const db = request.result;
+                    const oldVersion = event.oldVersion;
+                    const newVersion = event.newVersion || this.dbVersion;
+                    console.debug(`Database upgrade from version ${oldVersion} to ${newVersion}`);
                     this.classes.forEach((cls) => {
-                        const keyPathFields = Reflect.getMetadata("keypath", cls) || [];
-                        const storeName = cls.name.toLowerCase() + "s";
-                        if (!db.objectStoreNames.contains(storeName)) {
-                            db.createObjectStore(storeName, { keyPath: keyPathFields[0] });
+                        var _a;
+                        const keyPathMetadata = Reflect.getMetadata("keypath", cls);
+                        const indexFields = Reflect.getMetadata("indexes", cls) || [];
+                        const classVersion = Reflect.getMetadata("version", cls) || 1;
+                        const storeName = cls.name.toLowerCase();
+                        if (classVersion > oldVersion) {
+                            if (!db.objectStoreNames.contains(storeName)) {
+                                console.debug(`Creating object store: ${storeName} (version ${classVersion})`);
+                                const storeOptions = {};
+                                if (keyPathMetadata) {
+                                    storeOptions.keyPath = keyPathMetadata.fields;
+                                    if ((_a = keyPathMetadata.options) === null || _a === void 0 ? void 0 : _a.autoIncrement) {
+                                        storeOptions.autoIncrement = true;
+                                    }
+                                }
+                                const store = db.createObjectStore(storeName, storeOptions);
+                                indexFields.forEach((indexField) => {
+                                    if (!store.indexNames.contains(indexField)) {
+                                        store.createIndex(indexField, indexField, { unique: false });
+                                    }
+                                });
+                            }
+                            else {
+                                console.debug(`Updating object store: ${storeName} (version ${classVersion})`);
+                                const transaction = request.transaction;
+                                if (transaction) {
+                                    const store = transaction.objectStore(storeName);
+                                    indexFields.forEach((indexField) => {
+                                        if (!store.indexNames.contains(indexField)) {
+                                            console.debug(`Adding index: ${indexField} to ${storeName}`);
+                                            store.createIndex(indexField, indexField, { unique: false });
+                                        }
+                                    });
+                                }
+                            }
                         }
                     });
                 };
                 request.onsuccess = () => {
                     this.db = request.result;
-                    console.log(`Database initialized with object stores for: ${this.classes.map(cls => cls.name).join(", ")}`);
+                    console.debug(`Database initialized (version ${this.dbVersion}) with object stores for: ${this.classes.map(cls => `${cls.name}(v${Reflect.getMetadata("version", cls) || 1})`).join(", ")}`);
                     resolve();
                 };
                 request.onerror = () => {
@@ -64,118 +302,253 @@ class Database {
             });
         });
     }
-    getObjectStore(className, mode) {
-        if (!this.db) {
-            throw new Error("Database not initialized.");
-        }
-        const storeName = className.toLowerCase() + "s";
-        const transaction = this.db.transaction(storeName, mode);
-        return transaction.objectStore(storeName);
-    }
-    create(cls, item) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                try {
-                    const store = this.getObjectStore(cls.name, "readwrite");
-                    const request = store.add(item);
-                    request.onsuccess = () => {
-                        console.log(`Item added to ${cls.name}:`, item);
-                        resolve();
-                    };
-                    request.onerror = () => {
-                        console.error(`Error adding item to ${cls.name}:`, request.error);
-                        reject(request.error);
-                    };
-                }
-                catch (error) {
-                    reject(error);
-                }
+    generateEntityRepositories() {
+        this.classes.forEach(cls => {
+            const entityName = cls.name;
+            const repository = this.createEntityRepository(cls);
+            this.entityRepositories.set(entityName, repository);
+            Object.defineProperty(this, entityName, {
+                value: repository,
+                writable: false,
+                enumerable: true,
+                configurable: false
             });
         });
     }
-    read(cls, key) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                try {
-                    const store = this.getObjectStore(cls.name, "readonly");
-                    const request = store.get(key);
-                    request.onsuccess = () => {
-                        console.log(`Item read from ${cls.name}:`, request.result);
-                        resolve(request.result);
-                    };
-                    request.onerror = () => {
-                        console.error(`Error reading item from ${cls.name}:`, request.error);
-                        reject(request.error);
-                    };
-                }
-                catch (error) {
-                    reject(error);
+    createEntityRepository(cls) {
+        const self = this;
+        const generateKey = (item) => {
+            var _a;
+            const keyPathMetadata = Reflect.getMetadata("keypath", cls);
+            if (!((_a = keyPathMetadata === null || keyPathMetadata === void 0 ? void 0 : keyPathMetadata.options) === null || _a === void 0 ? void 0 : _a.generator))
+                return undefined;
+            const generator = keyPathMetadata.options.generator;
+            if (typeof generator === 'function') {
+                return generator(item);
+            }
+            switch (generator) {
+                case 'uuid':
+                    return KeyGenerators.uuid();
+                case 'timestamp':
+                    return KeyGenerators.timestamp();
+                case 'random':
+                    return KeyGenerators.random();
+                default:
+                    return undefined;
+            }
+        };
+        const extractKey = (item) => {
+            const keyPathMetadata = Reflect.getMetadata("keypath", cls);
+            if (!keyPathMetadata)
+                return undefined;
+            const fields = keyPathMetadata.fields;
+            if (Array.isArray(fields)) {
+                return fields.map(field => item[field]);
+            }
+            else {
+                return item[fields];
+            }
+        };
+        const setKey = (item, key) => {
+            const keyPathMetadata = Reflect.getMetadata("keypath", cls);
+            if (!keyPathMetadata)
+                return;
+            const fields = keyPathMetadata.fields;
+            if (typeof fields === 'string') {
+                item[fields] = key;
+            }
+        };
+        return {
+            query() {
+                if (!self.db)
+                    throw new Error('Database not initialized.');
+                const storeName = cls.name.toLowerCase();
+                return new QueryBuilder(self.db, storeName);
+            },
+            create: (item) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const keyPathMetadata = Reflect.getMetadata("keypath", cls);
+                if (((_a = keyPathMetadata === null || keyPathMetadata === void 0 ? void 0 : keyPathMetadata.options) === null || _a === void 0 ? void 0 : _a.generator) && !keyPathMetadata.options.autoIncrement) {
+                    const currentKey = extractKey(item);
+                    if (currentKey === undefined || currentKey === null || currentKey === '') {
+                        const generatedKey = generateKey(item);
+                        if (generatedKey !== undefined) {
+                            setKey(item, generatedKey);
+                        }
+                    }
                 }
-            });
-        });
-    }
-    update(cls, item) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                try {
-                    const store = this.getObjectStore(cls.name, "readwrite");
+                return this.performOperation(cls.name, 'readwrite', (store) => {
+                    const request = store.add(item);
+                    return new Promise((resolve, reject) => {
+                        request.onsuccess = () => {
+                            console.debug(`Item added to ${cls.name}:`, item);
+                            resolve();
+                        };
+                        request.onerror = () => reject(request.error);
+                    });
+                });
+            }),
+            read: (key) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                return this.performOperation(cls.name, 'readonly', (store) => {
+                    const request = store.get(key);
+                    return new Promise((resolve, reject) => {
+                        request.onsuccess = () => {
+                            console.debug(`Item read from ${cls.name}:`, request.result);
+                            resolve(request.result);
+                        };
+                        request.onerror = () => reject(request.error);
+                    });
+                });
+            }),
+            update: (item) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                return this.performOperation(cls.name, 'readwrite', (store) => {
                     const request = store.put(item);
-                    request.onsuccess = () => {
-                        console.log(`Item updated in ${cls.name}:`, item);
-                        resolve();
-                    };
-                    request.onerror = () => {
-                        console.error(`Error updating item in ${cls.name}:`, request.error);
-                        reject(request.error);
-                    };
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
-        });
+                    return new Promise((resolve, reject) => {
+                        request.onsuccess = () => {
+                            console.debug(`Item updated in ${cls.name}:`, item);
+                            resolve();
+                        };
+                        request.onerror = () => reject(request.error);
+                    });
+                });
+            }),
+            delete: (key) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                return this.performOperation(cls.name, 'readwrite', (store) => {
+                    const request = store.delete(key);
+                    return new Promise((resolve, reject) => {
+                        request.onsuccess = () => {
+                            console.debug(`Item deleted from ${cls.name}:`, key);
+                            resolve();
+                        };
+                        request.onerror = () => reject(request.error);
+                    });
+                });
+            }),
+            list: () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                return this.performOperation(cls.name, 'readonly', (store) => {
+                    const request = store.getAll();
+                    return new Promise((resolve, reject) => {
+                        request.onsuccess = () => {
+                            console.debug(`All items from ${cls.name}:`, request.result);
+                            resolve(request.result);
+                        };
+                        request.onerror = () => reject(request.error);
+                    });
+                });
+            }),
+            listPaginated: (page, pageSize) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                return this.performOperation(cls.name, 'readonly', (store) => {
+                    const request = store.getAll();
+                    return new Promise((resolve, reject) => {
+                        request.onsuccess = () => {
+                            const items = request.result;
+                            const paginatedItems = items.slice((page - 1) * pageSize, page * pageSize);
+                            console.debug(`Paginated items from ${cls.name}:`, paginatedItems);
+                            resolve(paginatedItems);
+                        };
+                        request.onerror = () => reject(request.error);
+                    });
+                });
+            }),
+            findByIndex: (indexName, value) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                return this.performOperation(cls.name, 'readonly', (store) => {
+                    if (!store.indexNames.contains(indexName)) {
+                        throw new Error(`Index '${indexName}' does not exist on ${cls.name}`);
+                    }
+                    const index = store.index(indexName);
+                    const request = index.getAll(value);
+                    return new Promise((resolve, reject) => {
+                        request.onsuccess = () => {
+                            console.debug(`Items found by index ${indexName} with value ${value}:`, request.result);
+                            resolve(request.result);
+                        };
+                        request.onerror = () => reject(request.error);
+                    });
+                });
+            }),
+            findOneByIndex: (indexName, value) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                return this.performOperation(cls.name, 'readonly', (store) => {
+                    if (!store.indexNames.contains(indexName)) {
+                        throw new Error(`Index '${indexName}' does not exist on ${cls.name}`);
+                    }
+                    const index = store.index(indexName);
+                    const request = index.get(value);
+                    return new Promise((resolve, reject) => {
+                        request.onsuccess = () => {
+                            console.debug(`Item found by index ${indexName} with value ${value}:`, request.result);
+                            resolve(request.result);
+                        };
+                        request.onerror = () => reject(request.error);
+                    });
+                });
+            }),
+            count: () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                return this.performOperation(cls.name, 'readonly', (store) => {
+                    const request = store.count();
+                    return new Promise((resolve, reject) => {
+                        request.onsuccess = () => {
+                            console.debug(`Count for ${cls.name}:`, request.result);
+                            resolve(request.result);
+                        };
+                        request.onerror = () => reject(request.error);
+                    });
+                });
+            }),
+            exists: (key) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                return this.performOperation(cls.name, 'readonly', (store) => {
+                    const request = store.count(key);
+                    return new Promise((resolve, reject) => {
+                        request.onsuccess = () => {
+                            const exists = request.result > 0;
+                            console.debug(`Exists check for ${cls.name} with key ${key}:`, exists);
+                            resolve(exists);
+                        };
+                        request.onerror = () => reject(request.error);
+                    });
+                });
+            }),
+            clear: () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                return this.performOperation(cls.name, 'readwrite', (store) => {
+                    const request = store.clear();
+                    return new Promise((resolve, reject) => {
+                        request.onsuccess = () => {
+                            console.debug(`Cleared all items from ${cls.name}`);
+                            resolve();
+                        };
+                        request.onerror = () => reject(request.error);
+                    });
+                });
+            })
+        };
     }
-    delete(cls, key) {
+    performOperation(className, mode, operation) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                try {
-                    const store = this.getObjectStore(cls.name, "readwrite");
-                    const request = store.delete(key);
-                    request.onsuccess = () => {
-                        console.log(`Item deleted from ${cls.name}:`, key);
-                        resolve();
-                    };
-                    request.onerror = () => {
-                        console.error(`Error deleting item from ${cls.name}:`, request.error);
-                        reject(request.error);
-                    };
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
+            if (!this.db) {
+                throw new Error("Database not initialized.");
+            }
+            const storeName = className.toLowerCase();
+            const transaction = this.db.transaction(storeName, mode);
+            const store = transaction.objectStore(storeName);
+            return operation(store);
         });
     }
-    list(cls) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                try {
-                    const store = this.getObjectStore(cls.name, "readonly");
-                    const request = store.getAll();
-                    request.onsuccess = () => {
-                        console.log(`All items from ${cls.name}:`, request.result);
-                        resolve(request.result);
-                    };
-                    request.onerror = () => {
-                        console.error(`Error listing items from ${cls.name}:`, request.error);
-                        reject(request.error);
-                    };
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
+    getAvailableEntities() {
+        return Array.from(this.entityRepositories.keys());
+    }
+    getDatabaseVersion() {
+        return this.dbVersion;
+    }
+    getEntityVersions() {
+        const versions = new Map();
+        this.classes.forEach(cls => {
+            const version = Reflect.getMetadata("version", cls) || 1;
+            versions.set(cls.name, version);
         });
+        return versions;
+    }
+    getEntityVersion(entityName) {
+        const cls = this.classes.find(c => c.name === entityName);
+        return cls ? (Reflect.getMetadata("version", cls) || 1) : undefined;
     }
 }
 exports.Database = Database;