1import { getOpenDB, getDeleteDB } from './idb-loader.js'; 2/** 3 * Allows for managing multiple instances of the IndexedDbManager, one for each database name. 4 */ 5var instanceManager = {}; 6/** 7 * Creates a new instance of the IndexedDbManager for the specified database name. 8 */ 9export function createInstance(databaseName) { 10 instanceManager[databaseName] = new IndexedDbManager(); 11} 12export function openDatabase(database) { 13 ensureDatabaseInstance(database.name); 14 return instanceManager[database.name].open(database); 15} 16export function deleteDatabase(databaseName) { 17 ensureDatabaseInstance(databaseName); 18 instanceManager[databaseName].deleteDatabase(); 19} 20export function closeDatabase(databaseName) { 21 ensureDatabaseInstance(databaseName); 22 instanceManager[databaseName].close(); 23} 24export function getDbSchema(databaseName) { 25 ensureDatabaseInstance(databaseName); 26 return instanceManager[databaseName].getDbSchema(); 27} 28export function count(databaseName, storeName, key) { 29 ensureDatabaseInstance(databaseName); 30 return instanceManager[databaseName].count(storeName, key); 31} 32export function countByKeyRange(databaseName, storeName, lower, upper, lowerOpen, upperOpen) { 33 ensureDatabaseInstance(databaseName); 34 return instanceManager[databaseName].countByKeyRange(storeName, lower, upper, lowerOpen, upperOpen); 35} 36export function get(databaseName, storeName, key) { 37 ensureDatabaseInstance(databaseName); 38 return instanceManager[databaseName].get(storeName, key); 39} 40export function getAll(databaseName, storeName, key, count) { 41 ensureDatabaseInstance(databaseName); 42 return instanceManager[databaseName].getAll(storeName, key, count); 43} 44export function getAllByKeyRange(databaseName, storeName, lower, upper, lowerOpen, upperOpen, count) { 45 ensureDatabaseInstance(databaseName); 46 return instanceManager[databaseName].getAllByKeyRange(storeName, lower, upper, lowerOpen, upperOpen, count); 47} 48export function getAllByArrayKey(databaseName, storeName, key) { 49 ensureDatabaseInstance(databaseName); 50 return instanceManager[databaseName].getAllByArrayKey(storeName, key); 51} 52export function getKey(databaseName, storeName, key) { 53 ensureDatabaseInstance(databaseName); 54 return instanceManager[databaseName].getKey(storeName, key); 55} 56export function getAllKeys(databaseName, storeName, key, count) { 57 ensureDatabaseInstance(databaseName); 58 return instanceManager[databaseName].getAllKeys(storeName, key, count); 59} 60export function getAllKeysByKeyRange(databaseName, storeName, lower, upper, lowerOpen, upperOpen, count) { 61 ensureDatabaseInstance(databaseName); 62 return instanceManager[databaseName].getAllKeysByKeyRange(storeName, lower, upper, lowerOpen, upperOpen, count); 63} 64export function getAllKeysByArrayKey(databaseName, storeName, key) { 65 ensureDatabaseInstance(databaseName); 66 return instanceManager[databaseName].getAllKeysByArrayKey(storeName, key); 67} 68export function query(databaseName, storeName, key, filter, count = 0, skip = 0) { 69 ensureDatabaseInstance(databaseName); 70 return instanceManager[databaseName].query(storeName, key, filter, count, skip); 71} 72export function countFromIndex(databaseName, storeName, indexName, key) { 73 ensureDatabaseInstance(databaseName); 74 return instanceManager[databaseName].countFromIndex(storeName, indexName, key); 75} 76export function countFromIndexByKeyRange(databaseName, storeName, indexName, lower, upper, lowerOpen, upperOpen) { 77 ensureDatabaseInstance(databaseName); 78 return instanceManager[databaseName].countFromIndexByKeyRange(storeName, indexName, lower, upper, lowerOpen, upperOpen); 79} 80export function getFromIndex(databaseName, storeName, indexName, key) { 81 ensureDatabaseInstance(databaseName); 82 return instanceManager[databaseName].getFromIndex(storeName, indexName, key); 83} 84export function getAllFromIndex(databaseName, storeName, indexName, key, count) { 85 ensureDatabaseInstance(databaseName); 86 return instanceManager[databaseName].getAllFromIndex(storeName, indexName, key, count); 87} 88export function getAllFromIndexByKeyRange(databaseName, storeName, indexName, lower, upper, lowerOpen, upperOpen, count) { 89 ensureDatabaseInstance(databaseName); 90 return instanceManager[databaseName].getAllFromIndexByKeyRange(storeName, indexName, lower, upper, lowerOpen, upperOpen, count); 91} 92export function getAllFromIndexByArrayKey(databaseName, storeName, indexName, key) { 93 ensureDatabaseInstance(databaseName); 94 return instanceManager[databaseName].getAllFromIndexByArrayKey(storeName, indexName, key); 95} 96export function getKeyFromIndex(databaseName, storeName, indexName, key) { 97 ensureDatabaseInstance(databaseName); 98 return instanceManager[databaseName].getKeyFromIndex(storeName, indexName, key); 99} 100export function getAllKeysFromIndex(databaseName, storeName, indexName, key, count) { 101 ensureDatabaseInstance(databaseName); 102 return instanceManager[databaseName].getAllKeysFromIndex(storeName, indexName, key, count); 103} 104export function getAllKeysFromIndexByKeyRange(databaseName, storeName, indexName, lower, upper, lowerOpen, upperOpen, count) { 105 ensureDatabaseInstance(databaseName); 106 return instanceManager[databaseName].getAllKeysFromIndexByKeyRange(storeName, indexName, lower, upper, lowerOpen, upperOpen, count); 107} 108export function getAllKeysFromIndexByArrayKey(databaseName, storeName, indexName, key) { 109 ensureDatabaseInstance(databaseName); 110 return instanceManager[databaseName].getAllKeysFromIndexByArrayKey(storeName, indexName, key); 111} 112export function queryFromIndex(databaseName, storeName, indexName, key, filter, count = 0, skip = 0) { 113 ensureDatabaseInstance(databaseName); 114 return instanceManager[databaseName].queryFromIndex(storeName, indexName, key, filter, count, skip); 115} 116export function add(databaseName, storeName, data, key) { 117 ensureDatabaseInstance(databaseName); 118 return instanceManager[databaseName].add(storeName, data, key); 119} 120export function put(databaseName, storeName, data, key) { 121 ensureDatabaseInstance(databaseName); 122 return instanceManager[databaseName].put(storeName, data, key); 123} 124export function deleteRecord(databaseName, storeName, id) { 125 ensureDatabaseInstance(databaseName); 126 return instanceManager[databaseName].delete(storeName, id); 127} 128export function batchAdd(databaseName, storeName, data) { 129 ensureDatabaseInstance(databaseName); 130 return instanceManager[databaseName].batchAdd(storeName, data); 131} 132export function batchPut(databaseName, storeName, data) { 133 ensureDatabaseInstance(databaseName); 134 return instanceManager[databaseName].batchPut(storeName, data); 135} 136export function batchDelete(databaseName, storeName, ids) { 137 ensureDatabaseInstance(databaseName); 138 return instanceManager[databaseName].batchDelete(storeName, ids); 139} 140export function clearStore(databaseName, storeName) { 141 ensureDatabaseInstance(databaseName);
142 return instanceManager[databaseName].clearStore(storeName); 143} 144/** 145 * Gets the schema for the specified database. 146 */ 147function ensureDatabaseInstance(databaseName) { 148 if (!instanceManager[databaseName]) { 149 createInstance(databaseName); 150 } 151} 152/** 153 * Manages a particular instance of an IndexedDb database. 154 */ 155export class IndexedDbManager { 156 constructor() { 157 this.dbInstance = undefined; 158 this.databaseName = ""; 159 this.open = async (database) => { 160 var upgradeError = ""; 161 try { 162 if (!this.dbInstance || this.dbInstance.version < database.version) { 163 if (this.dbInstance) { 164 this.dbInstance.close(); 165 this.dbInstance = undefined; 166 } 167 const openDB = await getOpenDB(); 168 this.dbInstance = await openDB(database.name, database.version, { 169 upgrade(db, oldVersion, newVersion, transaction) { 170 try { 171 IndexedDbManager.upgradeDatabase(db, oldVersion, newVersion, database); 172 } 173 catch (error) { 174 upgradeError = error.toString(); 175 throw (error); 176 } 177 }, 178 }); 179 } 180 return true; 181 } 182 catch (error) { 183 throw error.toString() + ' ' + upgradeError; 184 } 185 return false; 186 }; 187 this.close = () => { 188 try { 189 this.dbInstance?.close(); 190 this.dbInstance = undefined; 191 } 192 catch (error) { 193 throw error.toString(); 194 } 195 }; 196 this.deleteDatabase = async () => { 197 try { 198 this.close(); 199 const deleteDB = await getDeleteDB(); 200 await deleteDB(this.databaseName); 201 } 202 catch (error) { 203 throw `Database ${this.databaseName}, ${error.toString()}`; 204 } 205 }; 206 this.getDbSchema = async () => { 207 try { 208 if (!this.dbInstance) 209 throw IndexedDbManager.E_DB_CLOSED; 210 const dbInstance = this.dbInstance; 211 const dbInfo = { 212 name: dbInstance.name, 213 version: dbInstance.version, 214 objectStores: [] 215 }; 216 for (let s = 0; s < dbInstance.objectStoreNames.length; s++) { 217 let dbStore = dbInstance.transaction(dbInstance.objectStoreNames[s], 'readonly').store; 218 let objectStore = { 219 name: dbStore.name, 220 keyPath: Array.isArray(dbStore.keyPath) ? dbStore.keyPath.join(',') : dbStore.keyPath, 221 autoIncrement: dbStore.autoIncrement, 222 indexes: [] 223 }; 224 for (let i = 0; i < dbStore.indexNames.length; i++) { 225 const dbIndex = dbStore.index(dbStore.indexNames[i]); 226 let index = { 227 name: dbIndex.name, 228 keyPath: Array.isArray(dbIndex.keyPath) ? dbIndex.keyPath.join(',') : dbIndex.keyPath, 229 multiEntry: dbIndex.multiEntry, 230 unique: dbIndex.unique 231 }; 232 objectStore.indexes.push(index); 233 } 234 dbInfo.objectStores.push(objectStore); 235 } 236 return dbInfo; 237 } 238 catch (error) { 239 throw `Database ${this.databaseName}, ${error.toString()}`; 240 } 241 }; 242 // IDBObjectStore 243 this.count = async (storeName, key) => { 244 try { 245 if (!this.dbInstance) 246 throw IndexedDbManager.E_DB_CLOSED; 247 const tx = this.dbInstance.transaction(storeName, 'readonly'); 248 let result = await tx.store.count(key ?? undefined); 249 await tx.done; 250 return result; 251 } 252 catch (error) { 253 throw `Store ${storeName}, ${error.toString()}`; 254 } 255 }; 256 this.countByKeyRange = async (storeName, lower, upper, lowerOpen, upperOpen) => { 257 try {
258 return await this.count(storeName, IDBKeyRange.bound(lower, upper, lowerOpen, upperOpen)); 259 } 260 catch (error) { 261 throw `Store ${storeName}, ${error.toString()}`; 262 } 263 }; 264 this.get = async (storeName, key) => { 265 try { 266 if (!this.dbInstance) 267 throw IndexedDbManager.E_DB_CLOSED; 268 const tx = this.dbInstance.transaction(storeName, 'readonly'); 269 let result = await tx.store.get(key); 270 await tx.done; 271 return result; 272 } 273 catch (error) { 274 throw `Store ${storeName}, ${error.toString()}`; 275 } 276 }; 277 this.getAll = async (storeName, key, count) => { 278 try { 279 if (!this.dbInstance) 280 throw IndexedDbManager.E_DB_CLOSED; 281 const tx = this.dbInstance.transaction(storeName, 'readonly'); 282 let results = await tx.store.getAll(key ?? undefined, count ?? undefined); 283 await tx.done; 284 return results; 285 } 286 catch (error) { 287 throw `Store ${storeName}, ${error.toString()}`; 288 } 289 }; 290 this.getAllByKeyRange = async (storeName, lower, upper, lowerOpen, upperOpen, count) => { 291 try { 292 if (!this.dbInstance) 293 throw IndexedDbManager.E_DB_CLOSED;
294 return await this.getAll(storeName, IDBKeyRange.bound(lower, upper, lowerOpen, upperOpen), count); 295 } 296 catch (error) { 297 throw `Store ${storeName}, ${error.toString()}`; 298 } 299 }; 300 this.getAllByArrayKey = async (storeName, key) => { 301 try { 302 if (!this.dbInstance) 303 throw IndexedDbManager.E_DB_CLOSED; 304 const tx = this.dbInstance.transaction(storeName, 'readonly'); 305 let results = []; 306 for (let index = 0; index < key.length; index++) { 307 const element = key[index]; 308 results = results.concat(await tx.store.getAll(element)); 309 } 310 await tx.done; 311 return results; 312 } 313 catch (error) { 314 throw `Store ${storeName}, ${error.toString()}`; 315 } 316 }; 317 this.getKey = async (storeName, key) => { 318 try { 319 if (!this.dbInstance) 320 throw IndexedDbManager.E_DB_CLOSED; 321 const tx = this.dbInstance.transaction(storeName, 'readonly'); 322 let result = await tx.store.getKey(key); 323 await tx.done; 324 return result; 325 } 326 catch (error) { 327 throw `Store ${storeName}, ${error.toString()}`; 328 } 329 }; 330 this.getAllKeys = async (storeName, key, count) => { 331 try { 332 if (!this.dbInstance) 333 throw IndexedDbManager.E_DB_CLOSED; 334 const tx = this.dbInstance.transaction(storeName, 'readonly'); 335 let results = await tx.store.getAllKeys(key ?? undefined, count ?? undefined); 336 await tx.done; 337 return results; 338 } 339 catch (error) { 340 throw `Store ${storeName}, ${error.toString()}`; 341 } 342 }; 343 this.getAllKeysByKeyRange = async (storeName, lower, upper, lowerOpen, upperOpen, count) => { 344 try { 345 if (!this.dbInstance) 346 throw IndexedDbManager.E_DB_CLOSED;
347 return await this.getAllKeys(storeName, IDBKeyRange.bound(lower, upper, lowerOpen, upperOpen), count); 348 } 349 catch (error) { 350 throw `Store ${storeName}, ${error.toString()}`; 351 } 352 }; 353 this.getAllKeysByArrayKey = async (storeName, key) => { 354 try { 355 if (!this.dbInstance) 356 throw IndexedDbManager.E_DB_CLOSED; 357 const tx = this.dbInstance.transaction(storeName, 'readonly'); 358 let results = []; 359 for (let index = 0; index < key.length; index++) { 360 const element = key[index]; 361 results = results.concat(await tx.store.getAllKeys(element)); 362 } 363 await tx.done; 364 return results; 365 } 366 catch (error) { 367 throw `Store ${storeName}, ${error.toString()}`; 368 } 369 }; 370 this.query = async (storeName, key, filter, count = 0, skip = 0) => { 371 try { 372 if (!this.dbInstance) 373 throw IndexedDbManager.E_DB_CLOSED; 374 try { 375 var func = new Function('obj', filter); 376 } 377 catch (error) { 378 throw `${error.toString()} in filter { ${filter} }`; 379 } 380 var row = 0; 381 var errorMessage = ""; 382 let results = []; 383 const tx = this.dbInstance.transaction(storeName, 'readonly'); 384 let cursor = await tx.store.openCursor(key ?? undefined); 385 while (cursor) { 386 if (!cursor) { 387 return; 388 } 389 try { 390 var out = func(cursor.value); 391 if (out) { 392 row++; 393 if (row > skip) { 394 results.push(out); 395 } 396 } 397 } 398 catch (error) { 399 errorMessage = `obj: ${JSON.stringify(cursor.value)}\nfilter: ${filter}\nerror: ${error.toString()}`; 400 break; 401 } 402 if (count > 0 && results.length >= count) { 403 break; 404 } 405 cursor = await cursor.continue(); 406 } 407 await tx.done; 408 if (errorMessage) { 409 throw errorMessage; 410 } 411 return results; 412 } 413 catch (error) { 414 throw `Store ${storeName} ${error.toString()}`; 415 } 416 }; 417 // IDBIndex functions 418 this.countFromIndex = async (storeName, indexName, key) => { 419 try { 420 if (!this.dbInstance) 421 throw IndexedDbManager.E_DB_CLOSED; 422 const tx = this.dbInstance.transaction(storeName, 'readonly'); 423 let result = await tx.store.index(indexName).count(key ?? undefined); 424 await tx.done; 425 return result; 426 } 427 catch (error) { 428 throw `Store ${storeName}, Index ${indexName}, ${error.toString()}`; 429 } 430 }; 431 this.countFromIndexByKeyRange = async (storeName, indexName, lower, upper, lowerOpen, upperOpen) => { 432 try { 433 return await this.countFromIndex(storeName, indexName, IDBKeyRange.bound(lower, upper, lowerOpen, upperOpen)); 434 } 435 catch (error) { 436 throw `Store ${storeName}, Index ${indexName}, ${error.toString()}`; 437 } 438 }; 439 this.getFromIndex = async (storeName, indexName, key) => { 440 try { 441 if (!this.dbInstance) 442 throw IndexedDbManager.E_DB_CLOSED; 443 const tx = this.dbInstance.transaction(storeName, 'readonly'); 444 const results = await tx.store.index(indexName).get(key); 445 await tx.done; 446 return results; 447 } 448 catch (error) { 449 throw `Store ${storeName}, Index ${indexName}, ${error.toString()}`; 450 } 451 }; 452 this.getAllFromIndex = async (storeName, indexName, key, count) => { 453 try { 454 if (!this.dbInstance) 455 throw IndexedDbManager.E_DB_CLOSED; 456 const tx = this.dbInstance.transaction(storeName, 'readonly'); 457 const results = await tx.store.index(indexName).getAll(key ?? undefined, c
457ount ?? undefined); 458 await tx.done; 459 return results; 460 } 461 catch (error) { 462 throw `Store ${storeName}, Index ${indexName}, ${error.toString()}`; 463 } 464 }; 465 this.getAllFromIndexByKeyRange = async (storeName, indexName, lower, upper, lowerOpen, upperOpen, count) => { 466 try { 467 if (!this.dbInstance) 468 throw IndexedDbManager.E_DB_CLOSED; 469 return await this.getAllFromIndex(storeName, indexName, IDBKeyRange.bound(lower, upper, lowerOpen, upperOpen), count); 470 } 471 catch (error) { 472 throw `Store ${storeName}, Index ${indexName}, ${error.toString()}`; 473 } 474 }; 475 this.getAllFromIndexByArrayKey = async (storeName, indexName, key) => { 476 try { 477 if (!this.dbInstance) 478 throw IndexedDbManager.E_DB_CLOSED; 479 const tx = this.dbInstance.transaction(storeName, 'readonly'); 480 const dx = tx.store.index(indexName); 481 let results = []; 482 for (let index = 0; index < key.length; index++) { 483 const element = key[index]; 484 results = results.concat(await dx.getAll(element)); 485 } 486 await tx.done; 487 return results; 488 } 489 catch (error) { 490 throw `Store ${storeName}, Index ${indexName}, ${error.toString()}`; 491 } 492 }; 493 this.getKeyFromIndex = async (storeName, indexName, key) => { 494 try { 495 if (!this.dbInstance) 496 throw IndexedDbManager.E_DB_CLOSED; 497 const tx = this.dbInstance.transaction(storeName, 'readonly'); 498 const results = await tx.store.index(indexName).getKey(key); 499 await tx.done; 500 return results; 501 } 502 catch (error) { 503 throw `Store ${storeName}, Index ${indexName}, ${error.toString()}`; 504 } 505 }; 506 this.getAllKeysFromIndex = async (storeName, indexName, key, count) => { 507 try { 508 if (!this.dbInstance) 509 throw IndexedDbManager.E_DB_CLOSED; 510 const tx = this.dbInstance.transaction(storeName, 'readonly'); 511 const results = await tx.store.index(indexName).getAllKeys(key ?? undefined, count ?? undefined); 512 await tx.done; 513 return results; 514 } 515 catch (error) { 516 throw `Store ${storeName}, Index ${indexName}, ${error.toString()}`; 517 } 518 }; 519 this.getAllKeysFromIndexByKeyRange = async (storeName, indexName, lower, upper, lowerOpen, upperOpen, count) => { 520 try { 521 if (!this.dbInstance) 522 throw IndexedDbManager.E_DB_CLOSED; 523 return await this.getAllKeysFromIndex(storeName, indexName, IDBKeyRange.bound(lower, upper, lowerOpen, upperOpen), count); 524 } 525 catch (error) { 526 throw `Store ${storeName}, Index ${indexName}, ${error.toString()}`; 527 } 528 }; 529 this.getAllKeysFromIndexByArrayKey = async (storeName, indexName, key) => { 530 try { 531 if (!this.dbInstance) 532 throw IndexedDbManager.E_DB_CLOSED; 533 const tx = this.dbInstance.transaction(storeName, 'readonly'); 534 const dx = tx.store.index(indexName); 535 let results = []; 536 for (let index = 0; index < key.length; index++) { 537 const element = key[index]; 538 results = results.concat(await dx.getAllKeys(element)); 539 } 540 await tx.done; 541 return results; 542 } 543 catch (error) { 544 throw `Store ${storeName}, Index ${indexName}, ${error.toString()}`; 545 } 546 }; 547 this.queryFromIndex = async (storeName, indexName, key, filter, count = 0, skip = 0) => { 548 try { 549 if (!this.dbInstance) 550 throw IndexedDbManager.E_DB_CLOSED; 551 try { 552 var func = new Function('obj', filter); 553 } 554 catch (error) { 555 throw `${error.toString()} in filter { ${filter} }`; 556 } 557 var row = 0; 558 var errorMessage = ""; 559 let results = []; 560 const tx = this.dbInstance.transaction(storeName, 'readonly'); 561 let cursor = await tx.store.index(indexName).openCursor(key ?? undefined); 562 while (cursor) { 563 if (!cursor) { 564 return; 565 } 566 try { 567 var out = func(cursor.value); 568 if (out) { 569 row++; 570 if (row > skip) { 571 results.push(out); 572 } 573 } 574 } 575 catch (error) { 576 errorMessage = `obj: ${JSON.stringify(cursor.value)}\nfilter: ${filter}\nerror: ${error.toString()}`; 577 break; 578 } 579 if (count > 0 && results.length >= count) { 580 break; 581 } 582 cursor = await cursor.continue(); 583 } 584 await tx.done; 585 if (errorMessage) { 586 throw errorMessage; 587 } 588 return results; 589 } 590 catch (error) { 591 throw `Store ${storeName}, Index ${indexName}, ${error.toString()}`; 592 } 593 }; 594 this.add = async (storeName, data, key) => { 595 try { 596 if (!this.dbInstance) 597 throw IndexedDbManager.E_DB_CLOSED; 598 const tx = this.dbInstance.transaction(storeName, 'readwrite'); 599 // @ts-ignore - Type mismatch between readwrite and readonly store types 600 data = this.checkForKeyPath(tx.store, data); 601 const result = await tx.store.add(data, key ?? undefined); 602 await tx.done; 603 return result; 604 } 605 catch (error) { 606 throw `Store ${storeName}, ${error.toString()}`; 607 } 608 }; 609 this.put = async (storeName, data, key) => { 610 try { 611 if (!this.dbInstance) 612 throw IndexedDbManager.E_DB_CLOSED; 613 const tx = this.dbInstance.transaction(storeName, 'readwrite'); 614 const result = await tx.store.put(data, key ?? undefined); 615 await tx.done; 616 return result; 617 } 618 catch (error) { 619 throw `Store ${storeName}, ${error.toString()}`; 620 } 621 }; 622 this.delete = async (storeName, id) => { 623 try { 624 if (!this.dbInstance) 625 throw IndexedDbManager.E_DB_CLOSED; 626 const tx = this.dbInstance.transaction(storeName, 'readwrite'); 627 await tx.store.delete(id); 628 await tx.done; 629 } 630 catch (error) { 631 throw `Store ${storeName}, ${error.toString()}`; 632 } 633 }; 634 this.batchAdd = async (storeName, data) => { 635 try { 636 if (!this.dbInstance) 637 throw IndexedDbManager.E_DB_CLOSED; 638 const tx = this.dbInstance.transaction(storeName, 'readwrite'); 639 let result = []; 640 data.forEach(async (element) => { 641 // @ts-ignore - Type mismatch between readwrite and readonly store types 642 let item = this.checkForKeyPath(tx.store, element); 643 result.push(await tx.store.add(item)); 644 }); 645 await tx.done; 646 return result; 647 } 648 catch (error) { 649 throw `Store ${storeName}, ${error.toString()}`; 650 } 651 }; 652 this.batchPut = async (storeName, data) => { 653 try { 654 if (!this.dbInstance) 655 throw IndexedDbManager.E_DB_CLOSED; 656 const tx = this.dbInstance.transaction(storeName, 'readwrite'); 657 let result = []; 658 data.forEach(async (element) => { 659 result.push(await tx.store.put(element)); 660 }); 661 await tx.done; 662 return result; 663 } 664 catch (error) { 665 throw `Store ${storeName}, ${error.toString()}`; 666 } 667 }; 668 this.batchDelete = async (storeName, ids) => { 669 try { 670 if (!this.dbInstance) 671 throw IndexedDbManager.E_DB_CLOSED; 672 const tx = this.dbInstance.transaction(storeName, 'readwrite'); 673 ids.forEach(async (element) => { 674 await tx.store.delete(element); 675 }); 676 await tx.done; 677 } 678 catch (error) { 679 throw `Store ${storeName}, ${error.toString()}`; 680 } 681 }; 682 this.clearStore = async (storeName) => { 683 try { 684 if (!this.dbInstance) 685 throw IndexedDbManager.E_DB_CLOSED; 686 const tx = this.dbInstance.transaction(storeName, 'readwrite'); 687 await tx.store.clear(); 688 await tx.done; 689 } 690 catch (error) { 691 throw `Store ${storeName}, ${error.toString()}`; 692 } 693 }; 694 } 695 checkForKeyPath(objectStore, data) { 696 if (!objectStore.autoIncrement || !objectStore.keyPath) { 697 return data; 698 } 699 if (typeof objectStore.keyPath !== 'string') { 700 return data; 701 }
702 const keyPath = objectStore.keyPath; 703 if (!data[keyPath]) { 704 delete data[keyPath]; 705 } 706 return data; 707 } 708 static upgradeDatabase(upgradeDB, oldVersion, newVersion, dbDatabase) { 709 if (newVersion && newVersion > oldVersion) { 710 if (dbDatabase.objectStores) { 711 for (var store of dbDatabase.objectStores) { 712 if (!upgradeDB.objectStoreNames.contains(store.name)) { 713 this.addNewStore(upgradeDB, store); 714 } 715 } 716 } 717 } 718 } 719 static getKeyPath(keyPath) { 720 if (keyPath) { 721 var multiKeyPath = keyPath.split(','); 722 return multiKeyPath.length > 1 ? multiKeyPath : keyPath; 723 } 724 else { 725 return undefined; 726 } 727 } 728 static addNewStore(upgradeDB, store) { 729 try { 730 const newStore = upgradeDB.createObjectStore(store.name, { 731 keyPath: this.getKeyPath(store.keyPath), 732 autoIncrement: store.autoIncrement 733 }); 734 for (var index of store.indexes) { 735 try { 736 newStore.createIndex(index.name, this.getKeyPath(index.keyPath) ?? index.name, { 737 multiEntry: index.multiEntry, 738 unique: index.unique 739 }); 740 } 741 catch (error) { 742 throw `index ${index.name}, ${error.toString()}`; 743 } 744 } 745 } 746 catch (error) { 747 throw `store ${store.name}, ${error.toString()}`; 748 } 749 } 750} 751IndexedDbManager.E_DB_CLOSED = "Database is closed"; 752//# sourceMappingURL=CloudNimble.BlazorEssentials.IndexedDb.js.map
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.