Skip to content
Source
Sign inSign up
TanStack/db
Open History to see the last commit

IndexedDBAdapter.ts

166 lines4.7 KB

1import { BaseStorageAdapter } from './StorageAdapter'
2​
3export class IndexedDBAdapter extends BaseStorageAdapter {
4 private dbName: string
5 private storeName: string
6 private db: IDBDatabase | null = null
7​
8 constructor(dbName = `offline-transactions`, storeName = `transactions`) {
9 super()
10 this.dbName = dbName
11 this.storeName = storeName
12 }
13​
14 /**
15 * Probe IndexedDB availability by attempting to open a test database.
16 * This catches private mode and other restrictions that block IndexedDB.
17 */
18 static async probe(): Promise<{ available: boolean; error?: Error }> {
19 // Check if IndexedDB exists
20 if (typeof indexedDB === `undefined`) {
21 return {
22 available: false,
23 error: new Error(`IndexedDB is not available in this environment`),
24 }
25 }
26​
27 // Try to actually open a test database to verify it works
28 try {
29 const testDbName = `__offline-tx-probe__`
30 const request = indexedDB.open(testDbName, 1)
31​
32 return new Promise((resolve) => {
33 request.onerror = () => {
34 const error = request.error || new Error(`IndexedDB open failed`)
35 resolve({ available: false, error })
36 }
37​
38 request.onsuccess = () => {
39 // Clean up test database
40 const db = request.result
41 db.close()
42 indexedDB.deleteDatabase(testDbName)
43 resolve({ available: true })
44 }
45​
46 request.onblocked = () => {
47 resolve({
48 available: false,
49 error: new Error(`IndexedDB is blocked`),
50 })
51 }
52 })
53 } catch (error) {
54 return {
55 available: false,
56 error: error instanceof Error ? error : new Error(String(error)),
57 }
58 }
59 }
60​
61 private async openDB(): Promise<IDBDatabase> {
62 if (this.db) {
63 return this.db
64 }
65​
66 return new Promise((resolve, reject) => {
67 const request = indexedDB.open(this.dbName, 1)
68​
69 request.onerror = () => reject(request.error)
70 request.onsuccess = () => {
71 this.db = request.result
72 resolve(this.db)
73 }
74​
75 request.onupgradeneeded = (event) => {
76 const db = (event.target as IDBOpenDBRequest).result
77 if (!db.objectStoreNames.contains(this.storeName)) {
78 db.createObjectStore(this.storeName)
79 }
80 }
81 })
82 }
83​
84 private async getStore(
85 mode: IDBTransactionMode = `readonly`,
86 ): Promise<IDBObjectStore> {
87 const db = await this.openDB()
88 const transaction = db.transaction([this.storeName], mode)
89 return transaction.objectStore(this.storeName)
90 }
91​
92 async get(key: string): Promise<string | null> {
93 try {
94 const store = await this.getStore(`readonly`)
95 return new Promise((resolve, reject) => {
96 const request = store.get(key)
97 request.onerror = () => reject(request.error)
98 request.onsuccess = () => resolve(request.result ?? null)
99 })
100 } catch (error) {
101 console.warn(`IndexedDB get failed:`, error)
102 return null
103 }
104 }
105​
106 async set(key: string, value: string): Promise<void> {
107 try {
108 const store = await this.getStore(`readwrite`)
109 return new Promise((resolve, reject) => {
110 const request = store.put(value, key)
111 request.onerror = () => reject(request.error)
112 request.onsuccess = () => resolve()
113 })
114 } catch (error) {
115 if (
116 error instanceof DOMException &&
117 error.name === `QuotaExceededError`
118 ) {
119 throw new Error(
120 `Storage quota exceeded. Consider clearing old transactions.`,
121 )
122 }
123 throw error
124 }
125 }
126​
127 async delete(key: string): Promise<void> {
128 try {
129 const store = await this.getStore(`readwrite`)
130 return new Promise((resolve, reject) => {
131 const request = store.delete(key)
132 request.onerror = () => reject(request.error)
133 request.onsuccess = () => resolve()
134 })
135 } catch (error) {
136 console.warn(`IndexedDB delete failed:`, error)
137 }
138 }
139​
140 async keys(): Promise<Array<string>> {
141 try {
142 const store = await this.getStore(`readonly`)
143 return new Promise((resolve, reject) => {
144 const request = store.getAllKeys()
145 request.onerror = () => reject(request.error)
146 request.onsuccess = () => resolve(request.result as Array<string>)
147 })
148 } catch (error) {
149 console.warn(`IndexedDB keys failed:`, error)
150 return []
151 }
152 }
153​
154 async clear(): Promise<void> {
155 try {
156 const store = await this.getStore(`readwrite`)
157 return new Promise((resolve, reject) => {
158 const request = store.clear()
159 request.onerror = () => reject(request.error)
160 request.onsuccess = () => resolve()
161 })
162 } catch (error) {
163 console.warn(`IndexedDB clear failed:`, error)
164 }
165 }