123 lines
3.7 KiB
JavaScript
123 lines
3.7 KiB
JavaScript
import {
|
|
toReversePaddedBigInt
|
|
} from './utils'
|
|
import {
|
|
getDatabase,
|
|
dbPromise,
|
|
deleteDatabase,
|
|
} from './databaseLifecycle'
|
|
|
|
import {
|
|
META_STORE,
|
|
TIMELINE_STORE,
|
|
STATUSES_STORE, ACCOUNTS_STORE
|
|
} from './constants'
|
|
|
|
import QuickLRU from 'quick-lru'
|
|
|
|
const statusesCache = new QuickLRU({maxSize: 100})
|
|
|
|
if (process.browser && process.env.NODE_ENV !== 'production') {
|
|
window.cacheStats = {
|
|
cache: statusesCache,
|
|
cacheHits: 0,
|
|
cacheMisses: 0
|
|
}
|
|
}
|
|
|
|
export async function getTimeline(instanceName, timeline, maxId = null, limit = 20) {
|
|
const db = await getDatabase(instanceName, timeline)
|
|
return await dbPromise(db, [TIMELINE_STORE, STATUSES_STORE], 'readonly', (stores, callback) => {
|
|
let [ timelineStore, statusesStore ] = stores
|
|
|
|
let negBigInt = maxId && toReversePaddedBigInt(maxId)
|
|
let start = negBigInt ? (timeline + '\u0000' + negBigInt) : (timeline + '\u0000')
|
|
let end = timeline + '\u0000\uffff'
|
|
let query = IDBKeyRange.bound(start, end, false, false)
|
|
|
|
timelineStore.getAll(query, limit).onsuccess = e => {
|
|
let timelineResults = e.target.result
|
|
let res = new Array(timelineResults.length)
|
|
timelineResults.forEach((timelineResult, i) => {
|
|
statusesStore.get(timelineResult.statusId).onsuccess = e => {
|
|
res[i] = e.target.result
|
|
}
|
|
})
|
|
callback(res)
|
|
}
|
|
})
|
|
}
|
|
|
|
export async function insertStatuses(instanceName, timeline, statuses) {
|
|
for (let status of statuses) {
|
|
statusesCache.set(status.id, status)
|
|
}
|
|
const db = await getDatabase(instanceName, timeline)
|
|
await dbPromise(db, [TIMELINE_STORE, STATUSES_STORE, ACCOUNTS_STORE], 'readwrite', (stores) => {
|
|
let [ timelineStore, statusesStore, accountsStore ] = stores
|
|
for (let status of statuses) {
|
|
statusesStore.put(status)
|
|
// reverse chronological order, prefixed by timeline
|
|
timelineStore.put({
|
|
id: (timeline + '\u0000' + toReversePaddedBigInt(status.id)),
|
|
statusId: status.id
|
|
})
|
|
accountsStore.put(status.account)
|
|
if (status.reblog) {
|
|
accountsStore.put(status.reblog.account)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
export async function getInstanceVerifyCredentials(instanceName) {
|
|
const db = await getDatabase(instanceName)
|
|
return await dbPromise(db, META_STORE, 'readonly', (store, callback) => {
|
|
store.get('verifyCredentials').onsuccess = (e) => {
|
|
callback(e.target.result && e.target.result.value)
|
|
}
|
|
})
|
|
}
|
|
|
|
export async function setInstanceVerifyCredentials(instanceName, verifyCredentials) {
|
|
const db = await getDatabase(instanceName)
|
|
return await dbPromise(db, META_STORE, 'readwrite', (store) => {
|
|
store.put({
|
|
key: 'verifyCredentials',
|
|
value: verifyCredentials
|
|
})
|
|
})
|
|
}
|
|
|
|
export async function getAccount(instanceName, accountId) {
|
|
const db = await getDatabase(instanceName)
|
|
return await dbPromise(db, ACCOUNTS_STORE, 'readonly', (store, callback) => {
|
|
store.get(accountId).onsuccess = (e) => {
|
|
callback(e.target.result && e.target.result)
|
|
}
|
|
})
|
|
}
|
|
|
|
export async function clearDatabaseForInstance(instanceName) {
|
|
await deleteDatabase(instanceName)
|
|
}
|
|
|
|
export async function getStatus(instanceName, statusId) {
|
|
if (statusesCache.has(statusId)) {
|
|
if (process.browser && process.env.NODE_ENV !== 'production') {
|
|
window.cacheStats.cacheHits++
|
|
}
|
|
return statusesCache.get(statusId)
|
|
}
|
|
const db = await getDatabase(instanceName)
|
|
let result = await dbPromise(db, STATUSES_STORE, 'readonly', (store, callback) => {
|
|
store.get(statusId).onsuccess = (e) => {
|
|
callback(e.target.result && e.target.result)
|
|
}
|
|
})
|
|
statusesCache.set(statusId, result)
|
|
if (process.browser && process.env.NODE_ENV !== 'production') {
|
|
window.cacheStats.cacheMisses++
|
|
}
|
|
return result
|
|
} |