@pisell/core 1.0.33 → 1.0.35

package/lib/indexDB/index.js

@@ -33,35 +33,23 @@ __export(indexDB_exports, {
 });
 module.exports = __toCommonJS(indexDB_exports);
 var import_dayjs = __toESM(require("dayjs"));
-var IndexDBManager = class _IndexDBManager {
-  /**
-   * 检查环境是否支持 IndexedDB
-   * @returns {boolean} 是否支持 IndexedDB
-   * @private
-   */
-  static isSupported() {
-    return window && "indexedDB" in window;
-  }
-  db = null;
-  dbName;
-  version;
-  stores;
-  useIndexDB;
-  app;
-  // 内存存储：每个 store 使用一个 Map，key 为主键，value 为数据
-  memoryStorage = /* @__PURE__ */ new Map();
-  // 操作超时时间（毫秒）
-  timeout = 5e3;
+var import_dexie = __toESM(require("dexie"));
+var IndexDBManager = class {
   /**
    * 创建 IndexDBManager 实例
    * @param {DBOptions} options - 数据库配置选项
    */
   constructor(app, options) {
+    this.db = null;
+    // 内存存储：每个 store 使用一个 Map，key 为主键，value 为数据
+    this.memoryStorage = /* @__PURE__ */ new Map();
+    // 操作超时时间（毫秒）
+    this.timeout = 5e3;
     this.app = app;
     this.dbName = options.dbName;
     this.version = options.version;
     this.stores = options.stores;
-    this.useIndexDB = _IndexDBManager.isSupported();
+    this.useIndexDB = IndexDBManager.isSupported();
     this.timeout = options.timeout ?? 5e3;
     if (!this.useIndexDB) {
       this.stores.forEach((store) => {
@@ -69,6 +57,14 @@ var IndexDBManager = class _IndexDBManager {
       });
     }
   }
+  /**
+   * 检查环境是否支持 IndexedDB
+   * @returns {boolean} 是否支持 IndexedDB
+   * @private
+   */
+  static isSupported() {
+    return typeof window !== "undefined" && "indexedDB" in window;
+  }
   /**
    * 超时包装器 - 为 Promise 添加超时控制
    * @param {Promise<T>} promise - 需要包装的 Promise
@@ -77,23 +73,36 @@ var IndexDBManager = class _IndexDBManager {
    * @private
    */
   withTimeout(promise, operation) {
+    let timeoutId = null;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        const error = new Error(`操作超时: ${operation} 在 ${this.timeout}ms 内未完成`);
+        this.app.logger.addLog({
+          type: "error",
+          title: "[ IndexDB ] TIMEOUT",
+          metadata: {
+            msg: `操作超时: ${operation}`,
+            timeout: this.timeout,
+            operation
+          }
+        });
+        reject(error);
+      }, this.timeout);
+    });
     return Promise.race([
-      promise,
-      new Promise((_, reject) => {
-        setTimeout(() => {
-          const error = new Error(`操作超时: ${operation} 在 ${this.timeout}ms 内未完成`);
-          this.app.logger.addLog({
-            type: "error",
-            title: "[ IndexDB ] TIMEOUT",
-            metadata: {
-              msg: `操作超时: ${operation}`,
-              timeout: this.timeout,
-              operation
-            }
-          });
-          reject(error);
-        }, this.timeout);
-      })
+      promise.then(
+        (result) => {
+          if (timeoutId)
+            clearTimeout(timeoutId);
+          return result;
+        },
+        (error) => {
+          if (timeoutId)
+            clearTimeout(timeoutId);
+          throw error;
+        }
+      ),
+      timeoutPromise
     ]);
   }
   /**
@@ -106,58 +115,52 @@ var IndexDBManager = class _IndexDBManager {
       return true;
     }
     return this.withTimeout(
-      new Promise((resolve, reject) => {
-        const request = indexedDB.open(this.dbName, this.version);
-        request.onerror = (event) => {
-          var _a, _b;
-          this.app.logger.addLog({
-            type: "error",
-            title: "[ IndexDB ] ERROR",
-            metadata: { msg: "DB request error", data: event, message: (_b = (_a = event == null ? void 0 : event.target) == null ? void 0 : _a.error) == null ? void 0 : _b.message }
-          });
-        };
-        request.onsuccess = (event) => {
-          this.db = event.target.result;
-          resolve(true);
-        };
-        request.onblocked = () => {
-          this.app.logger.addLog({
-            type: "error",
-            title: "[ IndexDB ] blocked",
-            metadata: { msg: "DB blocked" }
+      (async () => {
+        try {
+          this.db = new import_dexie.default(this.dbName);
+          const schema = {};
+          this.stores.forEach((store) => {
+            var _a;
+            const indexes = ((_a = store.indexes) == null ? void 0 : _a.map((index) => {
+              var _a2, _b;
+              let indexStr = index.name;
+              if ((_a2 = index.options) == null ? void 0 : _a2.unique) {
+                indexStr = `&${indexStr}`;
+              }
+              if ((_b = index.options) == null ? void 0 : _b.multiEntry) {
+                indexStr = `*${indexStr}`;
+              }
+              return indexStr;
+            })) || [];
+            const primaryKey = store.keyPath;
+            schema[store.name] = [primaryKey, ...indexes].join(",");
           });
-        };
-        request.onupgradeneeded = (event) => {
-        };
-        request.onupgradeneeded = (event) => {
-          const db = event.target.result;
-          db.onerror = (event2) => {
-            var _a, _b;
+          this.db.version(this.version).stores(schema);
+          await this.db.open();
+          this.db.on("blocked", () => {
             this.app.logger.addLog({
               type: "error",
-              title: "[ IndexDB ] ERROR",
-              metadata: { msg: "DB error", data: event2, message: (_b = (_a = event2 == null ? void 0 : event2.target) == null ? void 0 : _a.error) == null ? void 0 : _b.message }
+              title: "[ IndexDB ] blocked",
+              metadata: { msg: "DB blocked" }
             });
-          };
-          db.onclose = (event2) => {
-            var _a, _b;
+          });
+          this.db.on("close", () => {
             this.app.logger.addLog({
               type: "error",
               title: "[ IndexDB ] CLOSE",
-              metadata: { msg: "DB close", data: event2, message: (_b = (_a = event2 == null ? void 0 : event2.target) == null ? void 0 : _a.error) == null ? void 0 : _b.message }
+              metadata: { msg: "DB close" }
             });
-          };
-          this.stores.forEach((store) => {
-            var _a;
-            if (!db.objectStoreNames.contains(store.name)) {
-              const objectStore = db.createObjectStore(store.name, { keyPath: store.keyPath });
-              (_a = store.indexes) == null ? void 0 : _a.forEach((index) => {
-                objectStore.createIndex(index.name, index.keyPath, index.options);
-              });
-            }
           });
-        };
-      }),
+          return true;
+        } catch (error) {
+          this.app.logger.addLog({
+            type: "error",
+            title: "[ IndexDB ] ERROR",
+            metadata: { msg: "DB request error", message: error.message }
+          });
+          throw error;
+        }
+      })(),
       "connect"
     );
   }
@@ -201,7 +204,7 @@ var IndexDBManager = class _IndexDBManager {
       });
     }
     return this.withTimeout(
-      new Promise((resolve, reject) => {
+      (async () => {
         if (!this.db) {
           if (log) {
             this.app.logger.addLog({
@@ -210,64 +213,35 @@ var IndexDBManager = class _IndexDBManager {
               metadata: { msg: "添加数据前 数据库未连接", data }
             });
           }
-          reject(new Error("数据库未连接"));
-          return;
+          throw new Error("数据库未连接");
         }
-        const transaction = this.db.transaction(storeName, "readwrite");
-        const store = transaction.objectStore(storeName);
-        const request = store.add(data);
-        request.onsuccess = () => {
+        try {
+          await this.db.table(storeName).add(data);
           if (log) {
             this.app.logger.addLog({
               type: "info",
               title: uuid,
               metadata: { msg: "添加数据成功" }
             });
-          }
-          return resolve(data);
-        };
-        request.onerror = () => {
-          if (log) {
-            this.app.logger.addLog({
-              type: "error",
-              title: uuid,
-              metadata: { msg: "添加数据失败" }
-            });
-          }
-          return reject(new Error("添加数据失败"));
-        };
-        transaction.oncomplete = () => {
-          console.log("✅ 添加事务完成");
-          if (log) {
+            console.log("✅ 添加事务完成");
             this.app.logger.addLog({
               type: "info",
               title: uuid,
               metadata: { msg: "事务完成" }
             });
           }
-          return;
-        };
-        transaction.onerror = (e) => {
+          return data;
+        } catch (error) {
           if (log) {
             this.app.logger.addLog({
               type: "error",
               title: uuid,
-              metadata: { msg: "事务错误" }
+              metadata: { msg: "添加数据失败", error: error.message }
             });
           }
-          return reject(transaction.error ?? new Error("事务错误"));
-        };
-        transaction.onabort = (e) => {
-          if (log) {
-            this.app.logger.addLog({
-              type: "error",
-              title: uuid,
-              metadata: { msg: "事务被中止" }
-            });
-          }
-          return reject(new Error("事务被中止"));
-        };
-      }),
+          throw new Error("添加数据失败");
+        }
+      })(),
       `add(${storeName})`
     );
   }
@@ -283,17 +257,17 @@ var IndexDBManager = class _IndexDBManager {
       return memStore.has(key);
     }
     return this.withTimeout(
-      new Promise((resolve, reject) => {
+      (async () => {
         if (!this.db) {
-          reject(new Error("数据库未连接"));
-          return;
+          throw new Error("数据库未连接");
         }
-        const transaction = this.db.transaction(storeName, "readonly");
-        const store = transaction.objectStore(storeName);
-        const request = store.count(key);
-        request.onsuccess = () => resolve(request.result > 0);
-        request.onerror = () => reject(new Error("检查数据存在性失败"));
-      }),
+        try {
+          const result = await this.db.table(storeName).get(key);
+          return result !== void 0;
+        } catch (error) {
+          throw new Error("检查数据存在性失败");
+        }
+      })(),
       `exists(${storeName})`
     );
   }
@@ -319,7 +293,7 @@ var IndexDBManager = class _IndexDBManager {
       return memStore.get(key) ?? null;
     }
     return this.withTimeout(
-      new Promise((resolve, reject) => {
+      (async () => {
         if (!this.db) {
           if (log) {
             this.app.logger.addLog({
@@ -328,69 +302,34 @@ var IndexDBManager = class _IndexDBManager {
               metadata: { msg: "数据库未连接" }
             });
           }
-          reject(new Error("数据库未连接"));
-          return;
+          throw new Error("数据库未连接");
         }
-        let resolved = false;
         try {
-          const transaction = this.db.transaction(storeName, "readonly");
-          const store = transaction.objectStore(storeName);
-          const request = store.get(key);
-          request.onsuccess = () => {
-            resolved = true;
-            if (log) {
-              this.app.logger.addLog({
-                type: "info",
-                title: uuid,
-                metadata: { msg: "获取成功" }
-              });
-            }
-            resolve(request.result ?? null);
-          };
-          request.onerror = () => {
-            resolved = true;
-            if (log) {
-              this.app.logger.addLog({
-                type: "error",
-                title: uuid,
-                metadata: { msg: "获取失败" }
-              });
-            }
-            reject(request.error ?? new Error("获取数据失败"));
-          };
-          transaction.onabort = () => {
-            if (log) {
-              this.app.logger.addLog({
-                type: "info",
-                title: uuid,
-                metadata: { msg: "事务被中止" }
-              });
-            }
-            if (!resolved) reject(new Error("事务被中止"));
-          };
-          transaction.onerror = (event) => {
-            if (log) {
-              this.app.logger.addLog({
-                type: "error",
-                title: uuid,
-                metadata: { msg: `事务错误: ${event.target.error}` }
-              });
-            }
-            if (!resolved) reject(new Error(`事务错误: ${event.target.error}`));
-          };
-          transaction.oncomplete = () => {
-            if (log) {
-              this.app.logger.addLog({
-                type: "info",
-                title: uuid,
-                metadata: { msg: "事务完成" }
-              });
-            }
-          };
-        } catch (e) {
-          reject(e);
+          const result = await this.db.table(storeName).get(key);
+          if (log) {
+            this.app.logger.addLog({
+              type: "info",
+              title: uuid,
+              metadata: { msg: "获取成功" }
+            });
+            this.app.logger.addLog({
+              type: "info",
+              title: uuid,
+              metadata: { msg: "事务完成" }
+            });
+          }
+          return result ?? null;
+        } catch (error) {
+          if (log) {
+            this.app.logger.addLog({
+              type: "error",
+              title: uuid,
+              metadata: { msg: "获取失败", error: error.message }
+            });
+          }
+          throw new Error("获取数据失败");
         }
-      }),
+      })(),
       `get(${storeName})`
     );
   }
@@ -420,7 +359,7 @@ var IndexDBManager = class _IndexDBManager {
       });
     }
     return this.withTimeout(
-      new Promise((resolve, reject) => {
+      (async () => {
         if (!this.db) {
           if (log) {
             this.app.logger.addLog({
@@ -429,67 +368,35 @@ var IndexDBManager = class _IndexDBManager {
               metadata: { msg: "数据库未连接" }
             });
           }
-          reject(new Error("数据库未连接"));
-          return;
+          throw new Error("数据库未连接");
         }
         try {
-          const transaction = this.db.transaction(storeName, "readwrite");
-          const store = transaction.objectStore(storeName);
-          const request = store.put(data);
-          request.onsuccess = () => {
-            if (log) {
-              this.app.logger.addLog({
-                type: "info",
-                title: uuid,
-                metadata: { msg: "数据更新完成" }
-              });
-            }
-            return resolve(data);
-          };
-          request.onerror = () => {
-            if (log) {
-              this.app.logger.addLog({
-                type: "error",
-                title: uuid,
-                metadata: { msg: "数据更新失败" }
-              });
-            }
-            return reject(request.error ?? new Error("更新数据失败"));
-          };
-          transaction.oncomplete = () => {
-            if (log) {
-              this.app.logger.addLog({
-                type: "info",
-                title: uuid,
-                metadata: { msg: "事务完成" }
-              });
-            }
-            return console.log("✅ 事务完成");
-          };
-          transaction.onabort = (e) => {
-            if (log) {
-              this.app.logger.addLog({
-                type: "error",
-                title: uuid,
-                metadata: { msg: "事务被中止" }
-              });
-            }
-            return reject(new Error("事务被中止"));
-          };
-          transaction.onerror = (e) => {
-            if (log) {
-              this.app.logger.addLog({
-                type: "error",
-                title: uuid,
-                metadata: { msg: "事务错误" }
-              });
-            }
-            return reject(transaction.error ?? new Error("事务错误"));
-          };
-        } catch (e) {
-          reject(e);
+          await this.db.table(storeName).put(data);
+          if (log) {
+            this.app.logger.addLog({
+              type: "info",
+              title: uuid,
+              metadata: { msg: "数据更新完成" }
+            });
+            console.log("✅ 事务完成");
+            this.app.logger.addLog({
+              type: "info",
+              title: uuid,
+              metadata: { msg: "事务完成" }
+            });
+          }
+          return data;
+        } catch (error) {
+          if (log) {
+            this.app.logger.addLog({
+              type: "error",
+              title: uuid,
+              metadata: { msg: "数据更新失败", error: error.message }
+            });
+          }
+          throw new Error("更新数据失败");
         }
-      }),
+      })(),
       `update(${storeName})`
     );
   }
@@ -505,17 +412,17 @@ var IndexDBManager = class _IndexDBManager {
       return memStore.delete(key);
     }
     return this.withTimeout(
-      new Promise((resolve, reject) => {
+      (async () => {
         if (!this.db) {
-          reject(new Error("数据库未连接"));
-          return;
+          throw new Error("数据库未连接");
         }
-        const transaction = this.db.transaction(storeName, "readwrite");
-        const store = transaction.objectStore(storeName);
-        const request = store.delete(key);
-        request.onsuccess = () => resolve(true);
-        request.onerror = () => reject(new Error("删除数据失败"));
-      }),
+        try {
+          await this.db.table(storeName).delete(key);
+          return true;
+        } catch (error) {
+          throw new Error("删除数据失败");
+        }
+      })(),
       `delete(${storeName})`
     );
   }
@@ -533,22 +440,22 @@ var IndexDBManager = class _IndexDBManager {
       const allData = await this.getAll(storeName);
       const storeConfig = this.stores.find((s) => s.name === storeName);
       const index = (_a = storeConfig == null ? void 0 : storeConfig.indexes) == null ? void 0 : _a.find((i) => i.name === indexName);
-      if (!index) return null;
+      if (!index)
+        return null;
       return allData.find((item) => item[index.keyPath] === indexValue) || null;
     }
     return this.withTimeout(
-      new Promise((resolve, reject) => {
+      (async () => {
         if (!this.db) {
-          reject(new Error("数据库未连接"));
-          return;
+          throw new Error("数据库未连接");
+        }
+        try {
+          const result = await this.db.table(storeName).where(indexName).equals(indexValue).first();
+          return result || null;
+        } catch (error) {
+          throw new Error("通过索引获取数据失败");
         }
-        const transaction = this.db.transaction(storeName, "readonly");
-        const store = transaction.objectStore(storeName);
-        const index = store.index(indexName);
-        const request = index.get(indexValue);
-        request.onsuccess = () => resolve(request.result || null);
-        request.onerror = () => reject(new Error("通过索引获取数据失败"));
-      }),
+      })(),
       `getByIndex(${storeName}, ${indexName})`
     );
   }
@@ -565,22 +472,22 @@ var IndexDBManager = class _IndexDBManager {
       const allData = await this.getAll(storeName);
       const storeConfig = this.stores.find((s) => s.name === storeName);
       const index = (_a = storeConfig == null ? void 0 : storeConfig.indexes) == null ? void 0 : _a.find((i) => i.name === indexName);
-      if (!index) return false;
+      if (!index)
+        return false;
       return allData.some((item) => item[index.keyPath] === indexValue);
     }
     return this.withTimeout(
-      new Promise((resolve, reject) => {
+      (async () => {
         if (!this.db) {
-          reject(new Error("数据库未连接"));
-          return;
+          throw new Error("数据库未连接");
+        }
+        try {
+          const count = await this.db.table(storeName).where(indexName).equals(indexValue).count();
+          return count > 0;
+        } catch (error) {
+          throw new Error("通过索引检查数据存在性失败");
         }
-        const transaction = this.db.transaction(storeName, "readonly");
-        const store = transaction.objectStore(storeName);
-        const index = store.index(indexName);
-        const request = index.count(indexValue);
-        request.onsuccess = () => resolve(request.result > 0);
-        request.onerror = () => reject(new Error("通过索引检查数据存在性失败"));
-      }),
+      })(),
       `existsByIndex(${storeName}, ${indexName})`
     );
   }
@@ -598,22 +505,22 @@ var IndexDBManager = class _IndexDBManager {
       const allData = await this.getAll(storeName);
       const storeConfig = this.stores.find((s) => s.name === storeName);
       const index = (_a = storeConfig == null ? void 0 : storeConfig.indexes) == null ? void 0 : _a.find((i) => i.name === indexName);
-      if (!index) return [];
+      if (!index)
+        return [];
       return allData.filter((item) => item[index.keyPath] === indexValue);
     }
     return this.withTimeout(
-      new Promise((resolve, reject) => {
+      (async () => {
         if (!this.db) {
-          reject(new Error("数据库未连接"));
-          return;
+          throw new Error("数据库未连接");
         }
-        const transaction = this.db.transaction(storeName, "readonly");
-        const store = transaction.objectStore(storeName);
-        const index = store.index(indexName);
-        const request = index.getAll(indexValue);
-        request.onsuccess = () => resolve(request.result);
-        request.onerror = () => reject(new Error("通过索引获取多条数据失败"));
-      }),
+        try {
+          const results = await this.db.table(storeName).where(indexName).equals(indexValue).toArray();
+          return results;
+        } catch (error) {
+          throw new Error("通过索引获取多条数据失败");
+        }
+      })(),
       `getAllByIndex(${storeName}, ${indexName})`
     );
   }
@@ -628,17 +535,17 @@ var IndexDBManager = class _IndexDBManager {
       return allData.length;
     }
     return this.withTimeout(
-      new Promise((resolve, reject) => {
+      (async () => {
         if (!this.db) {
-          reject(new Error("数据库未连接"));
-          return;
+          throw new Error("数据库未连接");
+        }
+        try {
+          const count = await this.db.table(storeName).count();
+          return count;
+        } catch (error) {
+          throw new Error("统计数据数量失败");
         }
-        const transaction = this.db.transaction(storeName, "readonly");
-        const store = transaction.objectStore(storeName);
-        const request = store.count();
-        request.onsuccess = () => resolve(request.result);
-        request.onerror = () => reject(new Error("统计数据数量失败"));
-      }),
+      })(),
       `count(${storeName})`
     );
   }
@@ -655,18 +562,17 @@ var IndexDBManager = class _IndexDBManager {
       return matchingData.length;
     }
     return this.withTimeout(
-      new Promise((resolve, reject) => {
+      (async () => {
         if (!this.db) {
-          reject(new Error("数据库未连接"));
-          return;
+          throw new Error("数据库未连接");
         }
-        const transaction = this.db.transaction(storeName, "readonly");
-        const store = transaction.objectStore(storeName);
-        const index = store.index(indexName);
-        const request = index.count(indexValue);
-        request.onsuccess = () => resolve(request.result);
-        request.onerror = () => reject(new Error("通过索引统计数据数量失败"));
-      }),
+        try {
+          const count = await this.db.table(storeName).where(indexName).equals(indexValue).count();
+          return count;
+        } catch (error) {
+          throw new Error("通过索引统计数据数量失败");
+        }
+      })(),
       `countByIndex(${storeName}, ${indexName})`
     );
   }
@@ -682,17 +588,17 @@ var IndexDBManager = class _IndexDBManager {
       return Array.from(memStore.values());
     }
     return this.withTimeout(
-      new Promise((resolve, reject) => {
+      (async () => {
         if (!this.db) {
-          reject(new Error("数据库未连接"));
-          return;
+          throw new Error("数据库未连接");
+        }
+        try {
+          const results = await this.db.table(storeName).toArray();
+          return results;
+        } catch (error) {
+          throw new Error("获取所有数据失败");
         }
-        const transaction = this.db.transaction(storeName, "readonly");
-        const store = transaction.objectStore(storeName);
-        const request = store.getAll();
-        request.onsuccess = () => resolve(request.result);
-        request.onerror = () => reject(new Error("获取所有数据失败"));
-      }),
+      })(),
       `getAll(${storeName})`
     );
   }
@@ -708,17 +614,17 @@ var IndexDBManager = class _IndexDBManager {
       return true;
     }
     return this.withTimeout(
-      new Promise((resolve, reject) => {
+      (async () => {
         if (!this.db) {
-          reject(new Error("数据库未连接"));
-          return;
+          throw new Error("数据库未连接");
+        }
+        try {
+          await this.db.table(storeName).clear();
+          return true;
+        } catch (error) {
+          throw new Error("清空数据失败");
         }
-        const transaction = this.db.transaction(storeName, "readwrite");
-        const store = transaction.objectStore(storeName);
-        const request = store.clear();
-        request.onsuccess = () => resolve(true);
-        request.onerror = () => reject(new Error("清空数据失败"));
-      }),
+      })(),
       `clear(${storeName})`
     );
   }