AI-native design editor. Open-source Figma alternative.
import type { DBSchema, IDBPDatabase } from 'idb'
import { credentialKey, validateCredentialValue } from '@/app/settings/credentials/reference'
import type {
CredentialRef,
CredentialStatus,
CredentialStore,
CredentialStoreAvailability
} from '@/app/settings/credentials/types'
import { CredentialStoreError } from '@/app/settings/credentials/types'
import {
APP_DATABASE_NAMES,
connectAppDatabase,
defineAppDatabase,
type AppDatabase
} from '@/app/storage/idb'
const credentialDatabase = defineAppDatabase<CredentialDatabase>({
name: APP_DATABASE_NAMES.credentials,
version: 1,
callbacks: {
upgrade(database) {
if (!database.objectStoreNames.contains('credentials')) {
database.createObjectStore('credentials')
}
if (!database.objectStoreNames.contains('metadata')) {
database.createObjectStore('metadata')
}
}
}
})
const MASTER_KEY_ID = 'master-key'
const IV_LENGTH = 12
interface EncryptedCredential {
iv: ArrayBuffer
ciphertext: ArrayBuffer
}
function ownedBuffer(bytes: Uint8Array): ArrayBuffer {
const owned = new Uint8Array(bytes.byteLength)
owned.set(bytes)
return owned.buffer
}
interface CredentialDatabase extends DBSchema {
credentials: {
key: string
value: EncryptedCredential
}
metadata: {
key: string
value: CryptoKey
}
}
export class BrowserCredentialStore implements CredentialStore {
readonly backend = 'browser' as const
readonly #database: AppDatabase<CredentialDatabase>
#masterKeyPromise?: Promise<CryptoKey>
constructor() {
this.#database = connectAppDatabase(credentialDatabase)
}
async availability(): Promise<CredentialStoreAvailability> {
try {
await this.#database.open()
return 'available'
} catch {
return 'unavailable'
}
}
async status(reference: CredentialRef): Promise<CredentialStatus> {
return (await this.read(reference)) === null ? 'missing' : 'configured'
}
async read(reference: CredentialRef): Promise<string | null> {
const key = credentialKey(reference)
try {
const database = await this.#database.open()
const record = await database.get('credentials', key)
if (!record) return null
const masterKey = await this.#masterKey(database)
const plaintext = await crypto.subtle.decrypt(
{ name: 'AES-GCM', iv: record.iv, additionalData: this.#additionalData(key) },
masterKey,
record.ciphertext
)
return new TextDecoder().decode(plaintext)
} catch (error) {
throw this.#normalizeError(error)
}
}
async write(reference: CredentialRef, value: string): Promise<void> {
validateCredentialValue(value)
const key = credentialKey(reference)
try {
const database = await this.#database.open()
const masterKey = await this.#masterKey(database)
const iv = ownedBuffer(crypto.getRandomValues(new Uint8Array(IV_LENGTH)))
const ciphertext = await crypto.subtle.encrypt(
{ name: 'AES-GCM', iv, additionalData: this.#additionalData(key) },
masterKey,
ownedBuffer(new TextEncoder().encode(value))
)
await database.put('credentials', { iv, ciphertext }, key)
} catch (error) {
throw this.#normalizeError(error)
}
}
async remove(reference: CredentialRef): Promise<void> {
try {
const database = await this.#database.open()
await database.delete('credentials', credentialKey(reference))
} catch (error) {
throw this.#normalizeError(error)
}
}
#masterKey(database: IDBPDatabase<CredentialDatabase>): Promise<CryptoKey> {
this.#masterKeyPromise ??= this.#loadOrCreateMasterKey(database)
return this.#masterKeyPromise
}
async #loadOrCreateMasterKey(database: IDBPDatabase<CredentialDatabase>): Promise<CryptoKey> {
const existing = await database.get('metadata', MASTER_KEY_ID)
if (existing) return existing
const generated = await crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, false, [
'encrypt',
'decrypt'
])
await database.put('metadata', generated, MASTER_KEY_ID)
return generated
}
#additionalData(key: string): ArrayBuffer {
return ownedBuffer(new TextEncoder().encode(key))
}
#normalizeError(error: unknown): CredentialStoreError {
if (error instanceof CredentialStoreError) return error
return new CredentialStoreError('failed', 'Browser credential operation failed')
}
}