IndexedDB模式管理：动态ObjectStore的替代方案

class LocalStorageAsync {
  #database;
  #logicalStoreName; // 用于区分逻辑分区的名称
  static #DB_NAME = 'LocalStorageAsyncDB'; // 数据库名称
  static #PHYSICAL_OBJECT_STORE = 'key_value_data'; // 唯一的物理对象存储名称

  /**
   * 构造函数，初始化IndexedDB连接
   * @param {string} logicalStoreName 逻辑存储的名称，例如 'default', 'foo'
   */
  constructor(logicalStoreName = 'default') {
    this.#logicalStoreName = logicalStoreName;
    // 使用固定的数据库版本号，只有当数据库首次创建或需要结构性升级时才改变
    const openRequest = indexedDB.open(LocalStorageAsync.#DB_NAME, 1); 

    this.#database = new Promise((resolve, reject) => {
      openRequest.onupgradeneeded = (event) => {
        const db = event.target.result;
        // 仅在onupgradeneeded中创建物理对象存储
        if (!db.objectStoreNames.contains(LocalStorageAsync.#PHYSICAL_OBJECT_STORE)) {
          // 使用keyPath，这里我们将组合键作为主键
          db.createObjectStore(LocalStorageAsync.#PHYSICAL_OBJECT_STORE, { keyPath: 'fullKey' });
          // 如果需要按逻辑存储名称查询，可以添加索引
          // db.createIndex('by_logicalStoreName', 'logicalStoreName', { unique: false });
        }
      };

      openRequest.onsuccess = (event) => {
        resolve(event.target.result);
      };

      openRequest.onerror = (event) => {
        console.error("IndexedDB open error:", event.target.errorCode, event.target.error);
        reject(new Error("Failed to open IndexedDB."));
      };
    });
  }

  /**
   * 获取一个事务和对象存储实例
   * @param {IDBTransactionMode} mode 事务模式 ('readonly' 或 'readwrite')
   * @returns {Promise<IDBObjectStore>}
   */
  async #getTransactionStore(mode) {
    const db = await this.#database;
    const transaction = db.transaction(LocalStorageAsync.#PHYSICAL_OBJECT_STORE, mode);
    transaction.onerror = (event) => {
      console.error("Transaction error:", event.target.errorCode, event.target.error);
    };
    return transaction.objectStore(LocalStorageAsync.#PHYSICAL_OBJECT_STORE);
  }

  /**
   * 生成用于存储的唯一键
   * @param {string} key 用户提供的键
   * @returns {string} 包含逻辑存储名称前缀的完整键
   */
  #generateFullKey(key) {
    return `${this.#logicalStoreName}__${key}`;
  }

  /**
   * 从指定的逻辑存储中获取值
   * @param {string} key 要获取的键
   * @returns {Promise<string|null>} 对应的值，如果不存在则为null
   */
  async getItem(key) {
    const store = await this.#getTransactionStore('readonly');
    const fullKey = this.#generateFullKey(key);
    const request = store.get(fullKey);

    return new Promise((resolve, reject) => {
      request.onsuccess = (event) => {
        const result = event.target.result;
        resolve(result ? result.value : null);
      };
      request.onerror = (event) => {
        console.error("Error getting item:", event.target.errorCode, event.target.error);
        reject(event.target.error);
      };
    });
  }

  /**
   * 将键值对存储到指定的逻辑存储中
   * @param {string} key 要设置的键
   * @param {string} value 要设置的值
   * @returns {Promise<void>}
   */
  async setItem(key, value) {
    const store = await this.#getTransactionStore('readwrite');
    const fullKey = this.#generateFullKey(key);
    // 存储一个包含fullKey、原始值和逻辑存储名称的对象
    const dataToStore = {
      fullKey: fullKey,
      value: value,
      logicalStoreName: this.#logicalStoreName // 存储逻辑存储名称，方便未来查询或索引
    };
    const request = store.put(dataToStore);

    return new Promise((resolve, reject) => {
      request.onsuccess = () => resolve();
      request.onerror = (event) => {
        console.error("Error setting item:", event.target.errorCode, event.target.error);
        reject(event.target.error);
      };
    });
  }

  /**
   * 从指定的逻辑存储中移除键值对
   * @param {string} key 要移除的键
   * @returns {Promise<void>}
   */
  async removeItem(key) {
    const store = await this.#getTransactionStore('readwrite');
    const fullKey = this.#generateFullKey(key);
    const request = store.delete(fullKey);

    return new Promise((resolve, reject) => {
      request.onsuccess = () => resolve();
      request.onerror = (event) => {
        console.error("Error removing item:", event.target.errorCode, event.target.error);
        reject(event.target.error);
      };
    });
  }

  /**
   * 清空指定逻辑存储中的所有数据
   * 注意：这会遍历并删除，而不是直接清空整个物理存储
   * @returns {Promise<void>}
   */
  async clear() {
    const store = await this.#getTransactionStore('readwrite');
    const request = store.openCursor();
    const keysToDelete = [];

    return new Promise((resolve, reject) => {
      request.onsuccess = (event) => {
        const cursor = event.target.result;
        if (cursor) {
          // 检查是否属于当前逻辑存储
          if (cursor.value.logicalStoreName === this.#logicalStoreName) {
            keysToDelete.push(cursor.primaryKey);
          }
          cursor.continue();
        } else {
          // 游标遍历完毕，开始删除
          if (keysToDelete.length === 0) {
            resolve();
            return;
          }

          let deleteCount = 0;
          const deleteNext = () => {
            if (deleteCount < keysToDelete.length) {
              const deleteRequest = store.delete(keysToDelete[deleteCount]);
              deleteRequest.onsuccess = () => {
                deleteCount++;
                deleteNext();
              };
              deleteRequest.onerror = (event) => {
                console.error("Error deleting item during clear:", event.target.errorCode, event.target.error);
                reject(event.target.error);
              };
            } else {
              resolve();
            }
          };
          deleteNext();
        }
      };
      request.onerror = (event) => {
        console.error("Error opening cursor for clear:", event.target.errorCode, event.target.error);
        reject(event.target.error);
      };
    });
  }
}

// 使用示例
async function runExample() {
  console.log("--- Initializing LocalStorageAsync instances ---");
  const defaultStore = new LocalStorageAsync();
  const fooStore = new LocalStorageAsync('foo');
  const barStore = new LocalStorageAsync('bar');

  console.log("\n--- Setting items ---");
  await defaultStore.setItem('user', 'Alice');
  await defaultStore.setItem('theme', 'dark');
  await fooStore.setItem('user', 'Bob');
  await fooStore.setItem('settings', 'enabled');
  await barStore.setItem('user', 'Charlie');

  console.log("\n--- Getting items ---");
  console.log("Default store - user:", await defaultStore.getItem('user')); // Expected: Alice
  console.log("Foo store - user:", await fooStore.getItem('user'));       // Expected: Bob
  console.log("Bar store - user:", await barStore.getItem('user'));       // Expected: Charlie
  console.log("Default store - theme:", await defaultStore.getItem('theme')); // Expected: dark
  console.log("Foo store - settings:", await fooStore.getItem('settings')); // Expected: enabled
  console.log("Default store - nonExistent:", await defaultStore.getItem('nonExistent')); // Expected: null

  console.log("\n--- Removing item from fooStore ---");
  await fooStore.removeItem('user');
  console.log("Foo store - user after removal:", await fooStore.getItem('user')); // Expected: null

  console.log("\n--- Clearing defaultStore ---");
  await defaultStore.clear();
  console.log("Default store - user after clear:", await defaultStore.getItem('user')); // Expected: null
  console.log("Default store - theme after clear:", await defaultStore.getItem('theme')); // Expected: null
  console.log("Foo store - settings (should remain):", await fooStore.getItem('settings')); // Expected: enabled
}

runExample().catch(e => console.error("Example failed:", e));