@framers/sql-storage-adapter 0.7.1 → 0.7.3

package/dist/cjs/features/backup/cloudBackup.d.ts

@@ -0,0 +1,219 @@
+/**
+ * Cloud backup utilities for S3, R2, and other object storage providers.
+ *
+ * This module provides automatic scheduled backups and restore functionality
+ * for SQL databases using S3-compatible storage (AWS S3, Cloudflare R2, MinIO, etc.).
+ *
+ * Features:
+ * - Automatic scheduled backups with configurable intervals
+ * - Gzip compression to reduce storage costs
+ * - Retention policies (automatic cleanup of old backups)
+ * - JSON and SQL export formats
+ * - Manual backup/restore on demand
+ *
+ * @example
+ * ```typescript
+ * import { S3Client } from '@aws-sdk/client-s3';
+ * import { createCloudBackupManager } from '@framers/sql-storage-adapter';
+ *
+ * const s3Client = new S3Client({ region: 'us-east-1' });
+ * const manager = createCloudBackupManager(db, s3Client, 'my-backups', {
+ *   interval: 3600000,  // 1 hour
+ *   maxBackups: 24,
+ *   options: { compression: 'gzip', format: 'json' }
+ * });
+ *
+ * manager.start();  // Auto-schedule backups
+ * await manager.backupNow();  // Manual backup
+ * await manager.restore('backups/db-2024-01-15.json.gz');
+ * ```
+ *
+ * @module cloudBackup
+ */
+import type { StorageAdapter } from '../../core/contracts/index.js';
+/** Supported backup export formats */
+export type BackupFormat = 'json' | 'sql';
+/** Supported compression algorithms */
+export type CompressionType = 'gzip' | 'none';
+/**
+ * Generic interface for cloud storage providers.
+ *
+ * Implement this interface to support custom storage backends
+ * beyond S3-compatible services.
+ */
+export interface CloudStorageProvider {
+    /**
+     * Upload data to cloud storage
+     * @param key - The storage key/path for the backup
+     * @param data - The backup data (string or Buffer)
+     */
+    upload(key: string, data: string | Buffer): Promise<void>;
+    /**
+     * Download data from cloud storage
+     * @param key - The storage key/path to download
+     * @returns The backup data
+     */
+    download(key: string): Promise<string | Buffer>;
+    /**
+     * List available backups in cloud storage
+     * @param prefix - Optional prefix to filter backups
+     * @returns Array of backup keys
+     */
+    list(prefix?: string): Promise<string[]>;
+    /**
+     * Delete a backup from cloud storage
+     * @param key - The storage key/path to delete
+     */
+    delete(key: string): Promise<void>;
+}
+/**
+ * Configuration options for backup creation
+ */
+export interface BackupOptions {
+    /** Backup format (json or sql) - default: 'json' */
+    format?: BackupFormat;
+    /** Compression type - default: 'gzip' */
+    compression?: CompressionType;
+    /** Tables to include (undefined = all tables) */
+    tables?: string[];
+    /** Prefix for backup keys - default: 'backups/' */
+    prefix?: string;
+    /** Include timestamp in backup key - default: true */
+    includeTimestamp?: boolean;
+}
+/**
+ * Configuration for automatic scheduled backups
+ */
+export interface ScheduledBackupConfig {
+    /** Backup interval in milliseconds (e.g., 3600000 = 1 hour) */
+    interval: number;
+    /** Maximum number of backups to keep (older backups auto-deleted) */
+    maxBackups?: number;
+    /** Backup creation options */
+    options?: BackupOptions;
+    /** Callback invoked on successful backup */
+    onSuccess?: (key: string) => void;
+    /** Callback invoked on backup error */
+    onError?: (error: Error) => void;
+}
+/**
+ * S3-compatible cloud storage provider.
+ *
+ * Works with AWS S3, Cloudflare R2, MinIO, and other S3-compatible services.
+ * Uses the AWS SDK v3 for S3 operations.
+ *
+ * @example
+ * ```typescript
+ * import { S3Client } from '@aws-sdk/client-s3';
+ *
+ * const s3Client = new S3Client({ region: 'us-east-1' });
+ * const provider = new S3StorageProvider(s3Client, 'my-bucket');
+ *
+ * await provider.upload('backups/test.json', JSON.stringify(data));
+ * const backups = await provider.list('backups/');
+ * ```
+ */
+export declare class S3StorageProvider implements CloudStorageProvider {
+    private client;
+    private bucket;
+    /**
+     * @param client - AWS SDK S3Client instance
+     * @param bucket - S3 bucket name
+     */
+    constructor(client: {
+        send: (command: unknown) => Promise<unknown>;
+    }, bucket: string);
+    upload(key: string, data: string | Buffer): Promise<void>;
+    download(key: string): Promise<string>;
+    list(prefix?: string): Promise<string[]>;
+    delete(key: string): Promise<void>;
+}
+/**
+ * Cloud backup manager for automatic scheduled backups.
+ */
+export declare class CloudBackupManager {
+    private adapter;
+    private storage;
+    private config;
+    private intervalId?;
+    constructor(adapter: StorageAdapter, storage: CloudStorageProvider, config: ScheduledBackupConfig);
+    /**
+     * Create a backup and upload to cloud storage.
+     */
+    backup(options?: BackupOptions): Promise<string>;
+    /**
+     * Restore from a cloud backup.
+     */
+    restore(key: string): Promise<void>;
+    /**
+     * List all backups in cloud storage.
+     */
+    listBackups(prefix?: string): Promise<string[]>;
+    /**
+     * Delete old backups exceeding maxBackups limit.
+     */
+    private cleanupOldBackups;
+    /**
+     * Start automatic scheduled backups.
+     */
+    start(): void;
+    /**
+     * Stop automatic scheduled backups.
+     */
+    stop(): void;
+    /**
+     * Perform a backup immediately (manual trigger).
+     */
+    backupNow(options?: BackupOptions): Promise<string>;
+}
+/**
+ * Create a cloud backup manager with S3-compatible storage.
+ *
+ * This is the main factory function for setting up cloud backups.
+ * It creates an S3StorageProvider and CloudBackupManager configured
+ * with your database and S3-compatible storage.
+ *
+ * @param adapter - The StorageAdapter instance to backup
+ * @param s3Client - AWS SDK S3Client (works with S3, R2, MinIO, etc.)
+ * @param bucket - The S3 bucket name
+ * @param config - Scheduled backup configuration
+ * @returns CloudBackupManager instance ready to start
+ *
+ * @example AWS S3
+ * ```typescript
+ * import { S3Client } from '@aws-sdk/client-s3';
+ * import { createCloudBackupManager } from '@framers/sql-storage-adapter';
+ *
+ * const s3 = new S3Client({ region: 'us-east-1' });
+ * const manager = createCloudBackupManager(db, s3, 'my-bucket', {
+ *   interval: 60 * 60 * 1000, // 1 hour
+ *   maxBackups: 24,
+ *   options: { compression: 'gzip' }
+ * });
+ *
+ * manager.start();
+ * ```
+ *
+ * @example Cloudflare R2
+ * ```typescript
+ * import { S3Client } from '@aws-sdk/client-s3';
+ *
+ * const r2 = new S3Client({
+ *   region: 'auto',
+ *   endpoint: `https://${accountId}.r2.cloudflarestorage.com`,
+ *   credentials: {
+ *     accessKeyId: process.env.R2_ACCESS_KEY_ID,
+ *     secretAccessKey: process.env.R2_SECRET_ACCESS_KEY,
+ *   },
+ * });
+ *
+ * const manager = createCloudBackupManager(db, r2, 'backups', {
+ *   interval: 24 * 60 * 60 * 1000, // Daily
+ *   maxBackups: 7
+ * });
+ * ```
+ */
+export declare function createCloudBackupManager(adapter: StorageAdapter, s3Client: {
+    send: (command: unknown) => Promise<unknown>;
+}, bucket: string, config: ScheduledBackupConfig): CloudBackupManager;
+//# sourceMappingURL=cloudBackup.d.ts.map

package/dist/cjs/features/backup/cloudBackup.js

@@ -0,0 +1,209 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cloudBackup_exports = {};
+__export(cloudBackup_exports, {
+  CloudBackupManager: () => CloudBackupManager,
+  S3StorageProvider: () => S3StorageProvider,
+  createCloudBackupManager: () => createCloudBackupManager
+});
+module.exports = __toCommonJS(cloudBackup_exports);
+var import_dataExport = require("../migrations/dataExport.js");
+var import_dataImport = require("../migrations/dataImport.js");
+class S3StorageProvider {
+  /**
+   * @param client - AWS SDK S3Client instance
+   * @param bucket - S3 bucket name
+   */
+  constructor(client, bucket) {
+    this.client = client;
+    this.bucket = bucket;
+  }
+  async upload(key, data) {
+    const { PutObjectCommand } = await Promise.resolve().then(() => __toESM(require("@aws-sdk/client-s3")));
+    await this.client.send(new PutObjectCommand({
+      Bucket: this.bucket,
+      Key: key,
+      Body: data
+    }));
+  }
+  async download(key) {
+    const { GetObjectCommand } = await Promise.resolve().then(() => __toESM(require("@aws-sdk/client-s3")));
+    const response = await this.client.send(new GetObjectCommand({
+      Bucket: this.bucket,
+      Key: key
+    }));
+    if (response.Body.transformToString) {
+      return await response.Body.transformToString();
+    }
+    return response.Body.toString("utf-8");
+  }
+  async list(prefix) {
+    const { ListObjectsV2Command } = await Promise.resolve().then(() => __toESM(require("@aws-sdk/client-s3")));
+    const response = await this.client.send(new ListObjectsV2Command({
+      Bucket: this.bucket,
+      Prefix: prefix
+    }));
+    return response.Contents?.map((obj) => obj.Key).filter((key) => !!key) ?? [];
+  }
+  async delete(key) {
+    const { DeleteObjectCommand } = await Promise.resolve().then(() => __toESM(require("@aws-sdk/client-s3")));
+    await this.client.send(new DeleteObjectCommand({
+      Bucket: this.bucket,
+      Key: key
+    }));
+  }
+}
+async function compress(data) {
+  const { gzip } = await Promise.resolve().then(() => __toESM(require("zlib")));
+  const { promisify } = await Promise.resolve().then(() => __toESM(require("util")));
+  const gzipAsync = promisify(gzip);
+  return await gzipAsync(Buffer.from(data));
+}
+async function decompress(data) {
+  const { gunzip } = await Promise.resolve().then(() => __toESM(require("zlib")));
+  const { promisify } = await Promise.resolve().then(() => __toESM(require("util")));
+  const gunzipAsync = promisify(gunzip);
+  const decompressed = await gunzipAsync(data);
+  return decompressed.toString("utf-8");
+}
+class CloudBackupManager {
+  constructor(adapter, storage, config) {
+    this.adapter = adapter;
+    this.storage = storage;
+    this.config = config;
+  }
+  /**
+   * Create a backup and upload to cloud storage.
+   */
+  async backup(options = {}) {
+    const format = options.format ?? this.config.options?.format ?? "json";
+    const compression = options.compression ?? this.config.options?.compression ?? "none";
+    const tables = options.tables ?? this.config.options?.tables;
+    const prefix = options.prefix ?? this.config.options?.prefix ?? "backups/";
+    const includeTimestamp = options.includeTimestamp ?? this.config.options?.includeTimestamp ?? true;
+    let data;
+    if (format === "json") {
+      data = await (0, import_dataExport.exportAsJSON)(this.adapter, { tables });
+    } else {
+      data = await (0, import_dataExport.exportAsSQL)(this.adapter, { tables });
+    }
+    let uploadData = data;
+    if (compression === "gzip") {
+      uploadData = await compress(data);
+    }
+    const timestamp = includeTimestamp ? `-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}` : "";
+    const ext = format === "json" ? "json" : "sql";
+    const compExt = compression === "gzip" ? ".gz" : "";
+    const key = `${prefix}backup${timestamp}.${ext}${compExt}`;
+    await this.storage.upload(key, uploadData);
+    if (this.config.maxBackups) {
+      await this.cleanupOldBackups(prefix);
+    }
+    return key;
+  }
+  /**
+   * Restore from a cloud backup.
+   */
+  async restore(key) {
+    const data = await this.storage.download(key);
+    let restored;
+    if (key.endsWith(".gz")) {
+      restored = await decompress(Buffer.from(data));
+    } else {
+      restored = typeof data === "string" ? data : data.toString("utf-8");
+    }
+    if (key.includes(".json")) {
+      await (0, import_dataImport.importFromJSON)(this.adapter, restored);
+    } else {
+      await (0, import_dataImport.importFromSQL)(this.adapter, restored);
+    }
+  }
+  /**
+   * List all backups in cloud storage.
+   */
+  async listBackups(prefix) {
+    const searchPrefix = prefix ?? this.config.options?.prefix ?? "backups/";
+    return await this.storage.list(searchPrefix);
+  }
+  /**
+   * Delete old backups exceeding maxBackups limit.
+   */
+  async cleanupOldBackups(prefix) {
+    if (!this.config.maxBackups)
+      return;
+    const backups = await this.storage.list(prefix);
+    if (backups.length <= this.config.maxBackups)
+      return;
+    const sorted = backups.sort();
+    const toDelete = sorted.slice(0, backups.length - this.config.maxBackups);
+    for (const key of toDelete) {
+      await this.storage.delete(key);
+    }
+  }
+  /**
+   * Start automatic scheduled backups.
+   */
+  start() {
+    if (this.intervalId) {
+      throw new Error("Scheduled backups already started");
+    }
+    this.intervalId = setInterval(async () => {
+      try {
+        const key = await this.backup();
+        this.config.onSuccess?.(key);
+      } catch (error) {
+        this.config.onError?.(error);
+      }
+    }, this.config.interval);
+  }
+  /**
+   * Stop automatic scheduled backups.
+   */
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = void 0;
+    }
+  }
+  /**
+   * Perform a backup immediately (manual trigger).
+   */
+  async backupNow(options) {
+    return await this.backup(options);
+  }
+}
+function createCloudBackupManager(adapter, s3Client, bucket, config) {
+  const storage = new S3StorageProvider(s3Client, bucket);
+  return new CloudBackupManager(adapter, storage, config);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CloudBackupManager,
+  S3StorageProvider,
+  createCloudBackupManager
+});

package/dist/cjs/features/kv/idb.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @fileoverview The part of IndexedDB the key-value store calls, typed structurally: the module compiles without the DOM
+ * library, and a page's IndexedDB satisfies these shapes.
+ * Moved unchanged from @framers/agentos src/core/storage/browser/idb.ts.
+ * @module sql-storage-adapter/kv/idb
+ */
+/** A request's outcome and its two events. */
+export interface IdbRequestLike<T> {
+    /** What the request answered, once it is done. */
+    readonly result: T;
+    /** Why the request failed, once it is done; null when it did not. */
+    readonly error: unknown;
+    /** Called when the request has succeeded. */
+    onsuccess: (() => void) | null;
+    /** Called when the request has failed. */
+    onerror: (() => void) | null;
+}
+/** A key range; only made and passed on. */
+export type IdbKeyRangeLike = object;
+/** The object store's calls the store makes. */
+export interface IdbObjectStoreLike {
+    /** Reads the value under a key. */
+    get(key: string): IdbRequestLike<unknown>;
+    /** Writes a value under a key, in place of what was there. */
+    put(value: unknown, key: string): IdbRequestLike<unknown>;
+    /** Removes one key, or every key of a range. */
+    delete(key: string | IdbKeyRangeLike): IdbRequestLike<unknown>;
+    /** Removes every key. */
+    clear(): IdbRequestLike<unknown>;
+    /** Lists the keys of a range, or every key. */
+    getAllKeys(range?: IdbKeyRangeLike): IdbRequestLike<unknown[]>;
+}
+/** A transaction and its three events. */
+export interface IdbTransactionLike {
+    /** Why the transaction was aborted; null until it is, and after a plain abort. */
+    readonly error: unknown;
+    /** One of the object stores the transaction was opened over. */
+    objectStore(name: string): IdbObjectStoreLike;
+    /** Called when everything the transaction did is kept. */
+    oncomplete: (() => void) | null;
+    /** Called when one of the transaction's requests has failed, before the transaction is aborted for it. */
+    onerror: (() => void) | null;
+    /** Called when the transaction is aborted and nothing it did is kept. */
+    onabort: (() => void) | null;
+}
+/** An open database. */
+export interface IdbDatabaseLike {
+    /** The names of the database's object stores. */
+    readonly objectStoreNames: {
+        contains(name: string): boolean;
+    };
+    /** Makes an object store with out-of-line keys; only inside an upgrade. */
+    createObjectStore(name: string): unknown;
+    /** Opens a transaction over one object store. */
+    transaction(storeName: string, mode: 'readonly' | 'readwrite'): IdbTransactionLike;
+    /** Closes the connection once its transactions are done. */
+    close(): void;
+}
+/** The request `open` answers. */
+export interface IdbOpenRequestLike extends IdbRequestLike<IdbDatabaseLike> {
+    /** The upgrade's transaction while `onupgradeneeded` runs; null outside it. */
+    readonly transaction: {
+        abort(): void;
+    } | null;
+    /** Called when the database is new or older than the version asked for, inside the upgrade. */
+    onupgradeneeded: (() => void) | null;
+    /** Called when an upgrade waits for another connection to close. */
+    onblocked: (() => void) | null;
+}
+/** The page's `indexedDB` and `IDBKeyRange`, or an error when the page has none. */
+export declare function idb(): {
+    factory: {
+        open(name: string, version?: number): IdbOpenRequestLike;
+    };
+    keyRange: {
+        bound(lower: string, upper: string): IdbKeyRangeLike;
+    };
+};
+//# sourceMappingURL=idb.d.ts.map

package/dist/cjs/features/kv/idb.js

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var idb_exports = {};
+__export(idb_exports, {
+  idb: () => idb
+});
+module.exports = __toCommonJS(idb_exports);
+function idb() {
+  const scope = globalThis;
+  if (!scope.indexedDB || !scope.IDBKeyRange)
+    throw new Error("IndexedDB is not available here.");
+  return { factory: scope.indexedDB, keyRange: scope.IDBKeyRange };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  idb
+});

package/dist/cjs/features/kv/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview The key-value module, `@framers/sql-storage-adapter/kv`: one `KeyValueStore` contract and its
+ * stores. `openIndexedDbStore` keeps values in one IndexedDB object store, moved unchanged from @framers/agentos, so a
+ * page's keys stay where they are; `createSqlKeyValueStore` keeps them in a SQL table on any adapter; the memory store
+ * keeps them for the page alone.
+ *
+ * The module imports no adapter, so a page that loads it for its key-value store loads neither sql.js nor pg.
+ * @module sql-storage-adapter/kv
+ */
+export { MemoryKeyValueStore, namespaced, type KeyValueStore } from './keyValueStore.js';
+export { IndexedDbKeyValueStore, openIndexedDbStore, type IndexedDbStoreOptions } from './indexedDbKeyValueStore.js';
+export { idb, type IdbDatabaseLike, type IdbKeyRangeLike, type IdbObjectStoreLike, type IdbOpenRequestLike, type IdbRequestLike, type IdbTransactionLike, } from './idb.js';
+export { createSqlKeyValueStore, type SqlKeyValueStoreOptions } from './sqlKeyValueStore.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/features/kv/index.js

@@ -0,0 +1,40 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var kv_exports = {};
+__export(kv_exports, {
+  IndexedDbKeyValueStore: () => import_indexedDbKeyValueStore.IndexedDbKeyValueStore,
+  MemoryKeyValueStore: () => import_keyValueStore.MemoryKeyValueStore,
+  createSqlKeyValueStore: () => import_sqlKeyValueStore.createSqlKeyValueStore,
+  idb: () => import_idb.idb,
+  namespaced: () => import_keyValueStore.namespaced,
+  openIndexedDbStore: () => import_indexedDbKeyValueStore.openIndexedDbStore
+});
+module.exports = __toCommonJS(kv_exports);
+var import_keyValueStore = require("./keyValueStore.js");
+var import_indexedDbKeyValueStore = require("./indexedDbKeyValueStore.js");
+var import_idb = require("./idb.js");
+var import_sqlKeyValueStore = require("./sqlKeyValueStore.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IndexedDbKeyValueStore,
+  MemoryKeyValueStore,
+  createSqlKeyValueStore,
+  idb,
+  namespaced,
+  openIndexedDbStore
+});

package/dist/cjs/features/kv/indexedDbKeyValueStore.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @fileoverview The key-value store over one IndexedDB object store with out-of-line keys. It opens a database at
+ * the version given (1 by default) and creates the object store only when the open upgrades the database (a new one,
+ * or one below that version), so a database another page made at that version is read in place. A browser that
+ * refuses IndexedDB gets the memory store.
+ * Moved unchanged from @framers/agentos src/core/storage/browser/IndexedDbKeyValueStore.ts: the same database,
+ * object store, version and keys.
+ * @module sql-storage-adapter/kv/indexedDbKeyValueStore
+ */
+import { type IdbDatabaseLike } from './idb.js';
+import { type KeyValueStore } from './keyValueStore.js';
+/** Where the store lives. */
+export interface IndexedDbStoreOptions {
+    /** The database's name. */
+    dbName: string;
+    /** The object store's name. It is made, with out-of-line keys, only when the open upgrades the database. */
+    storeName: string;
+    /**
+     * The version the database is opened at. A database that exists at this version is opened as it is, even when it
+     * lacks the object store, and every call of the store then rejects; one below it is upgraded, and gains the object
+     * store when it lacks it; one above it is refused by the browser.
+     * @default 1
+     */
+    version?: number;
+}
+/**
+ * The store over IndexedDB. Each call is one transaction over the object store: its promise is fulfilled when that
+ * transaction completes, and rejected with the reason when its request fails or the transaction is aborted.
+ *
+ * `keys` and `deletePrefix` read the keys between `prefix` and `prefix` followed by U+FFFF, so they miss a key that
+ * holds U+FFFF right after the prefix and goes on: keep keys to characters below it.
+ *
+ * The connection stays open until `close`: when another tab opens the database at a newer version, its upgrade waits
+ * for this tab to close the store or go. A connection the browser closes (the database deleted, the site's storage
+ * cleared) is not opened again, and every call then rejects.
+ */
+export declare class IndexedDbKeyValueStore implements KeyValueStore {
+    private readonly db;
+    private readonly storeName;
+    /** Always false: the values are in the browser's database. */
+    readonly memoryOnly = false;
+    /**
+     * @param db - An open database that holds the object store.
+     * @param storeName - The object store's name.
+     */
+    constructor(db: IdbDatabaseLike, storeName: string);
+    private run;
+    private static range;
+    /** The value held under `key`, or undefined when there is none. */
+    get<T = unknown>(key: string): Promise<T | undefined>;
+    /** Holds a structured clone of `value` under `key`. */
+    set(key: string, value: unknown): Promise<void>;
+    /** Removes `key`. */
+    delete(key: string): Promise<void>;
+    /**
+     * Every key that begins with `prefix`, in order. With an empty prefix, every key of the object store, a key that is
+     * not a string (a number, a date or an array another page wrote) given as `String` writes it.
+     */
+    keys(prefix: string): Promise<string[]>;
+    /** Removes every key that begins with `prefix`; with an empty prefix, everything the object store holds. */
+    deletePrefix(prefix: string): Promise<void>;
+    /** Closes the database connection. */
+    close(): void;
+}
+/**
+ * Opens the store, or the memory store when the browser refuses IndexedDB: a page with no `indexedDB`, an `open`
+ * that throws or fails (a database above `version` among them), or an upgrade that waits on another tab. The
+ * answer's `memoryOnly` says which it is; the memory store's `close` does nothing.
+ *
+ * An upgrade that waited on another tab still has its turn once that tab closes the database. It is aborted then,
+ * so the database stays as it was and the connection it opened is closed: nothing is left open behind the memory
+ * store.
+ */
+export declare function openIndexedDbStore(options: IndexedDbStoreOptions): Promise<KeyValueStore & {
+    close(): void;
+}>;
+//# sourceMappingURL=indexedDbKeyValueStore.d.ts.map