IndexedDB：动态对象存储管理与数据分区策略

class LocalStorageAsync {
  #database: Promise<IDBDatabase>;
  #dbName = 'LocalStorageAsyncDB';

  constructor(storeName = 'default') {
    const openRequest = indexedDB.open(this.#dbName); // 首次打开或版本未变

    openRequest.onsuccess = (event) => {
      const db = event.target.result as IDBDatabase;
      if (!db.objectStoreNames.contains(storeName)) {
        // 错误：db.createObjectStore() 不能在 onsuccess 中调用
        // db.createObjectStore(storeName);
        console.error("无法在 onsuccess 中创建对象存储。");
      }
      // ... resolve promise
    };

    openRequest.onupgradeneeded = (event) => {
      const db = event.target.result as IDBDatabase;
      // 这里可以创建对象存储，但需要版本号提升
      // db.createObjectStore(storeName);
    };

    this.#database = new Promise(resolve => {
      // ...
    });
  }
  // ... getItem, setItem methods
}

interface StoredItem {
  id: string; // 唯一ID，可以是 partitionKey-key 的组合
  partition: string; // 分区键，例如 'default', 'foo'
  key: string;       // 原始的键
  value: string;     // 原始的值
}

class LocalStorageAsync {
  #database: Promise<IDBDatabase>;
  #dbName = 'LocalStorageAsyncDB';
  #fixedStoreName = 'universalDataStore'; // 固定使用的对象存储名称
  #currentPartitionKey: string; // 当前实例操作的分区键

  constructor(partitionKey = 'default') {
    this.#currentPartitionKey = partitionKey;
    const openRequest = indexedDB.open(this.#dbName, 1); // 版本号固定为1，通常只在首次创建或重大模式变更时提升

    openRequest.onupgradeneeded = (event) => {
      const db = event.target.result as IDBDatabase;
      // 检查并创建唯一的一个对象存储
      if (!db.objectStoreNames.contains(this.#fixedStoreName)) {
        const store = db.createObjectStore(this.#fixedStoreName, { keyPath: 'id' });
        // 为 'partition' 字段创建索引，以便高效地按分区查询
        store.createIndex('partitionIndex', 'partition', { unique: false });
      }
    };

    this.#database = new Promise((resolve, reject) => {
      openRequest.onsuccess = (event) => {
        resolve(event.target.result as IDBDatabase);
      };
      openRequest.onerror = (event) => {
        console.error("IndexedDB open error:", event.target.error);
        reject(event.target.error);
      };
    });
  }

  /**
   * 将键值对存储到当前分区。
   * @param key 数据的键。
   * @param value 数据的值。
   */
  async setItem(key: string, value: string): Promise<void> {
    const db = await this.#database;
    const transaction = db.transaction([this.#fixedStoreName], 'readwrite');
    const store = transaction.objectStore(this.#fixedStoreName);

    // 构建存储对象，包含分区键和唯一ID
    const dataToStore: StoredItem = {
      id: `${this.#currentPartitionKey}-${key}`, // 使用分区键和原始键组合作为唯一ID
      partition: this.#currentPartitionKey,
      key: key,
      value: value
    };

    return new Promise((resolve, reject) => {
      const request = store.put(dataToStore); // put 方法用于添加或更新数据

      request.onsuccess = () => resolve();
      request.onerror = (event) => reject(event.target.error);
    });
  }

  /**
   * 从当前分区获取指定键的值。
   * @param key 数据的键。
   * @returns 对应的值，如果不存在则为 undefined。
   */
  async getItem(key: string): Promise<string | undefined> {
    const db = await this.#database;
    const transaction = db.transaction([this.#fixedStoreName], 'readonly');
    const store = transaction.objectStore(this.#fixedStoreName);

    // 使用组合ID进行检索
    const request = store.get(`${this.#currentPartitionKey}-${key}`);

    return new Promise((resolve, reject) => {
      request.onsuccess = (event) => {
        const result = event.target.result as StoredItem | undefined;
        resolve(result ? result.value : undefined);
      };
      request.onerror = (event) => reject(event.target.error);
    });
  }

  /**
   * 获取当前分区的所有键值对。
   * 注意：此方法依赖于 'partitionIndex' 索引。
   * @returns 包含键值对的数组。
   */
  async getAllItemsInPartition(): Promise<Array<{ key: string, value: string }>> {
    const db = await this.#database;
    const transaction = db.transaction([this.#fixedStoreName], 'readonly');
    const store = transaction.objectStore(this.#fixedStoreName);
    const partitionIndex = store.index('partitionIndex'); // 使用分区索引

    const request = partitionIndex.getAll(this.#currentPartitionKey);

    return new Promise((resolve, reject) => {
      request.onsuccess = (event) => {
        const results = (event.target.result as StoredItem[]).map(item => ({ key: item.key, value: item.value }));
        resolve(results);
      };
      request.onerror = (event) => reject(event.target.error);
    });
  }
}

// 使用示例：
async function demonstrateUsage() {
  const defaultStore = new LocalStorageAsync();
  await defaultStore.setItem('user_name', 'Alice');
  await defaultStore.setItem('theme', 'dark');

  const fooStore = new LocalStorageAsync('foo');
  await fooStore.setItem('app_version', '1.2.3');
  await fooStore.setItem('last_login', new Date().toISOString());

  console.log('Default partition user_name:', await defaultStore.getItem('user_name')); // Alice
  console.log('Foo partition app_version:', await fooStore.getItem('app_version'));     // 1.2.3

  console.log('All items in default partition:', await defaultStore.getAllItemsInPartition());
  // [{ key: 'user_name', value: 'Alice' }, { key: 'theme', value: 'dark' }]

  console.log('All items in foo partition:', await fooStore.getAllItemsInPartition());
  // [{ key: 'app_version', value: '1.2.3' }, { key: 'last_login', value: '...' }]
}

demonstrateUsage();