Notes2/static/js/node_store.mjs
2024-12-18 19:12:10 +01:00

331 lines
9.1 KiB
JavaScript

import { Node } from 'node'
export const ROOT_NODE = '00000000-0000-0000-0000-000000000000'
export class NodeStore {
constructor() {//{{{
if (!('indexedDB' in window)) {
throw 'Missing IndexedDB'
}
this.db = null
}//}}}
async initializeDB() {//{{{
return new Promise((resolve, reject) => {
const req = indexedDB.open('notes', 5)
// Schema upgrades for IndexedDB.
// These can start from different points depending on updates to Notes2 since a device was online.
req.onupgradeneeded = (event) => {
let nodes
let appState
let sendQueue
const db = event.target.result
const trx = event.target.transaction
for (let i = event.oldVersion + 1; i <= event.newVersion; i++) {
console.log(`Upgrade to schema ${i}`)
// The schema transformations.
switch (i) {
case 1:
nodes = db.createObjectStore('nodes', { keyPath: 'UUID' })
nodes.createIndex('nameIndex', 'Name', { unique: false })
break
case 2:
trx.objectStore('nodes').createIndex('parentIndex', 'ParentUUID', { unique: false })
break
case 3:
appState = db.createObjectStore('app_state', { keyPath: 'key' })
break
case 4:
trx.objectStore('nodes').createIndex('modifiedIndex', 'modified', { unique: false })
break
case 5:
sendQueue = db.createObjectStore('send_queue', { keyPath: ['UUID', 'Updated'] })
sendQueue.createIndex('updated', 'Updated', { unique: false })
break
}
}
}
req.onsuccess = (event) => {
this.db = event.target.result
this.initializeRootNode()
.then(() => this.initializeClientUUID())
.then(() => resolve())
}
req.onerror = (event) => {
reject(event.target.error)
}
})
}//}}}
async initializeRootNode() {//{{{
return new Promise((resolve, reject) => {
// The root node is a magical node which displays as the first node if none is specified.
// If not already existing, it will be created.
const trx = this.db.transaction('nodes', 'readwrite')
const nodes = trx.objectStore('nodes')
const getRequest = nodes.get(ROOT_NODE)
getRequest.onsuccess = (event) => {
// Root node exists - nice!
if (event.target.result !== undefined) {
resolve(event.target.result)
return
}
const putRequest = nodes.put({
UUID: ROOT_NODE,
Name: 'Notes2',
Content: 'Hello, World!',
})
putRequest.onsuccess = (event) => {
resolve(event.target.result)
}
putRequest.onerror = (event) => {
reject(event.target.error)
}
}
getRequest.onerror = (event) => reject(event.target.error)
})
}//}}}
async initializeClientUUID() {//{{{
let clientUUID = await this.getAppState('client_uuid')
if (clientUUID !== null)
return
clientUUID = crypto.randomUUID()
return this.setAppState('client_uuid', clientUUID)
}//}}}
async getAppState(key) {//{{{
return new Promise((resolve, reject) => {
const trx = this.db.transaction('app_state', 'readonly')
const appState = trx.objectStore('app_state')
const getRequest = appState.get(key)
getRequest.onsuccess = (event) => {
if (event.target.result !== undefined) {
resolve(event.target.result)
} else {
resolve(null)
}
}
getRequest.onerror = (event) => reject(event.target.error)
})
}//}}}
async setAppState(key, value) {//{{{
return new Promise((resolve, reject) => {
try {
const t = this.db.transaction('app_state', 'readwrite')
const appState = t.objectStore('app_state')
t.onerror = (event) => {
console.log('transaction error', event.target.error)
reject(event.target.error)
}
t.oncomplete = () => {
resolve()
}
const record = { key, value }
const addReq = appState.put(record)
addReq.onerror = (event) => {
console.log('Error!', event.target.error, key, value)
}
} catch (e) {
reject(e)
}
})
}//}}}
async moveToSendQueue(nodeToMove, replaceWithNode) {//{{{
return new Promise((resolve, reject) => {
const t = this.db.transaction(['nodes', 'send_queue'], 'readwrite')
const nodeStore = t.objectStore('nodes')
const sendQueue = t.objectStore('send_queue')
t.onerror = (event) => {
console.log('transaction error', event.target.error)
reject(event.target.error)
}
t.oncomplete = () => {
resolve()
}
// Node to be moved is first stored in the new queue.
const queueReq = sendQueue.put(nodeToMove.data)
queueReq.onsuccess = () => {
// When added to the send queue, the node is either deleted
// or replaced with a new node.
console.debug(`Queueing ${nodeToMove.UUID} (${nodeToMove.get('Name')})`)
let nodeReq
if (replaceWithNode)
nodeReq = nodeStore.put(replaceWithNode.data)
else
nodeReq = nodeStore.delete(nodeToMove.UUID)
nodeReq.onsuccess = () => {
resolve()
}
nodeReq.onerror = (event) => {
console.log(`Error moving ${nodeToMove.UUID}`, event.target.error)
reject(event.target.error)
}
}
queueReq.onerror = (event) => {
console.log(`Error queueing ${nodeToMove.UUID}`, event.target.error)
reject(event.target.error)
}
})
}//}}}
async storeNode(node) {//{{{
return new Promise((resolve, reject) => {
const t = this.db.transaction('nodes', 'readwrite')
const nodeStore = t.objectStore('nodes')
t.onerror = (event) => {
console.log('transaction error', event.target.error)
reject(event.target.error)
}
t.oncomplete = () => {
resolve()
}
const nodeReq = nodeStore.put(node.data)
nodeReq.onsuccess = () => {
console.debug(`Storing ${node.UUID} (${node.get('Name')})`)
}
queueReq.onerror = (event) => {
console.log(`Error storing ${node.UUID}`, event.target.error)
reject(event.target.error)
}
})
}//}}}
async upsertNodeRecords(records) {//{{{
return new Promise((resolve, reject) => {
const t = this.db.transaction('nodes', 'readwrite')
const nodeStore = t.objectStore('nodes')
t.onerror = (event) => {
console.log('transaction error', event.target.error)
reject(event.target.error)
}
t.oncomplete = () => {
resolve()
}
// records is an object, not an array.
for (const i in records) {
const record = records[i]
let addReq
let op
if (record.Deleted) {
op = 'deleting'
addReq = nodeStore.delete(record.UUID)
} else {
op = 'upserting'
// 'modified' is a local property for tracking
// nodes needing to be synced to backend.
record.modified = 0
addReq = nodeStore.put(record)
}
addReq.onsuccess = () => {
console.debug(`${op} ${record.UUID} (${record.Name})`)
}
addReq.onerror = (event) => {
console.log(`error ${op} ${record.UUID}`, event.target.error)
reject(event.target.error)
}
}
})
}//}}}
async getTreeNodes(parent, newLevel) {//{{{
return new Promise((resolve, reject) => {
const trx = this.db.transaction('nodes', 'readonly')
const nodeStore = trx.objectStore('nodes')
const index = nodeStore.index('parentIndex')
const req = index.getAll(parent)
req.onsuccess = (event) => {
const nodes = []
for (const i in event.target.result) {
const node = new Node(event.target.result[i], newLevel)
nodes.push(node)
}
resolve(nodes)
}
req.onerror = (event) => reject(event.target.error)
})
}//}}}
async add(records) {//{{{
return new Promise((resolve, reject) => {
try {
const t = this.db.transaction('nodes', 'readwrite')
const nodeStore = t.objectStore('nodes')
t.onerror = (event) => {
console.log('transaction error', event.target.error)
reject(event.target.error)
}
t.oncomplete = () => {
console.log('OK')
}
// records is an object, not an array.
const promises = []
for (const recordIdx in records) {
const record = records[recordIdx]
const addReq = nodeStore.put(record.data)
const promise = new Promise((resolve, reject) => {
addReq.onsuccess = () => {
console.debug('OK!', record.ID, record.Name)
resolve()
}
addReq.onerror = (event) => {
console.log('Error!', event.target.error, record.ID)
reject(event.target.error)
}
})
promises.push(promise)
}
Promise.all(promises).then(() => resolve())
} catch (e) {
console.log(e)
}
})
}//}}}
async get(uuid) {//{{{
return new Promise((resolve, reject) => {
// Node is always returned from IndexedDB if existing there.
// Otherwise an attempt to get it from backend is executed.
const trx = this.db.transaction('nodes', 'readonly')
const nodeStore = trx.objectStore('nodes')
const getRequest = nodeStore.get(uuid)
getRequest.onsuccess = (event) => {
// Node not found in IndexedDB.
if (event.target.result === undefined) {
reject("No such node")
return
}
const node = new Node(event.target.result, -1)
resolve(node)
}
})
}//}}}
async nodeCount() {//{{{
return new Promise((resolve, reject) => {
const t = this.db.transaction('nodes', 'readwrite')
const nodeStore = t.objectStore('nodes')
const countReq = nodeStore.count()
countReq.onsuccess = event => {
resolve(event.target.result)
}
})
}//}}}
}
// vim: foldmethod=marker