autobee 0.0.0 → 1.0.0

package/lib/topo.js

@@ -0,0 +1,196 @@
+const b4a = require('b4a')
+const encoding = require('./encoding.js')
+const { createNode } = require('./writers.js')
+const asserts = require('./asserts.js')
+
+const EMPTY_HEAD = { length: 0, key: null }
+
+exports.sort = sort
+
+exports.isLinking = isLinking
+exports.isLinkingAll = isLinkingAll
+
+async function sort(auto, batch) {
+  const node = batch[0]
+  const ch = auto.system.bee.createChangesStream()
+  const reorder = []
+
+  for await (const data of ch) {
+    const { ref, info } = getOplog(data)
+    const link = { key: ref.oplog.key, length: ref.oplog.length }
+
+    if (isLinking(node, link) || node.timestamp > info.timestamp) break
+    reorder.push(ref)
+  }
+
+  const inflated = await inflate(auto, reorder.reverse())
+
+  for (let i = 0; i < inflated.length; i++) {
+    const b = inflated[i]
+    const op = b.batch[0] // just use first op, they are all the same writer
+    const c = cmp(op, node)
+
+    if (c === -1) continue
+
+    const tip = new Array(inflated.length - i + 1)
+    tip[0] = batch
+    for (let j = i; j < inflated.length; j++) {
+      tip[j - i + 1] = inflated[j].batch
+    }
+
+    return {
+      undo: b.undo,
+      view: null,
+      tip
+    }
+  }
+
+  return {
+    undo: null,
+    view: null,
+    tip: [batch]
+  }
+}
+
+function cmp(a, b) {
+  const c = b4a.compare(a.key, b.key)
+
+  if (c === 0) {
+    return a.length - b.length
+  }
+
+  const t = a.timestamp - b.timestamp
+
+  if (t === 0) return c
+  return t < 0 ? -1 : 1
+}
+
+async function inflate(auto, reorder) {
+  const promises = []
+  const sessions = new Map()
+
+  for (const ref of reorder) {
+    const id = b4a.toString(ref.oplog.key, 'hex')
+
+    const local = auto.writers.localWriter
+    if (local && local.id === id) {
+      promises.push(getLocalBatch(ref.undo, local, ref.oplog.length))
+      continue
+    }
+
+    let core = sessions.get(id)
+    if (!core) {
+      core = auto.openCore(ref.oplog.key)
+      sessions.set(id, core)
+    }
+
+    promises.push(getOplogBatch(ref.undo, core, ref.oplog.length))
+  }
+
+  try {
+    return await Promise.all(promises)
+  } finally {
+    for (const core of sessions.values()) await core.close()
+  }
+}
+
+async function getOplogBatch(undo, core, length) {
+  const seq = length - 1
+  const block = await core.get(seq)
+  const oplog = encoding.decodeOplog(block)
+  const head = createNode(core, length, oplog)
+
+  const batch = []
+  const result = { undo, batch }
+
+  const remaining = []
+  const start = seq - head.batch.start
+  const end = seq + head.batch.end // skip head, we have it
+
+  for (let i = start; i < end; i++) {
+    remaining.push(core.get(i))
+  }
+
+  if (remaining.length) {
+    const blocks = await Promise.all(remaining)
+    for (let i = 0; i < blocks.length; i++) {
+      const oplog = encoding.decodeOplog(blocks[i])
+      batch.push(createNode(core, i + start + 1, oplog))
+    }
+  }
+
+  batch.push(head)
+  return result
+}
+
+async function getLocalBatch(undo, writer, length) {
+  if (length > writer.core.length) {
+    if (!writer.pending) throw new Error('No local nodes')
+
+    let i = 0
+    while (i < writer.pending.length) {
+      if (writer.pending[i].length === length) break
+      i++
+    }
+
+    const head = writer.pending[i]
+
+    const start = i - head.batch.start
+    const end = i + head.batch.end + 1 // include head
+
+    const batch = writer.pending.slice(start, end)
+    return { undo, batch }
+  }
+
+  return getOplogBatch(undo, writer.core, length)
+}
+
+function getOplog(data) {
+  const result = { ref: null, info: null }
+  for (let i = 0; i < data.batch.length; i++) {
+    const keys = data.batch[i].keys
+
+    for (let j = 0; j < keys.length; j++) {
+      const k = keys[j]
+      const prefix = k.key[0]
+
+      if (prefix === 0) {
+        result.info = encoding.decodeSystemInfo(k.value)
+        if (result.ref) return result
+      }
+
+      if (prefix === 1) {
+        // expect inlined for now
+        const value = encoding.decodeSystemWriter(k.key, k.value)
+        if (!value.isOplog) continue
+
+        result.ref = { undo: data.tail || EMPTY_HEAD, oplog: value }
+        if (result.info) return result
+      }
+    }
+  }
+
+  asserts.bail('Bad system node')
+}
+
+function isLinking(node, link) {
+  if (node.length >= link.length && b4a.equals(node.key, link.key)) {
+    return true
+  }
+
+  for (const l of node.links) {
+    if (l.length >= link.length && b4a.equals(l.key, link.key)) {
+      return true
+    }
+  }
+
+  return false
+}
+
+function isLinkingAll(node, heads) {
+  for (const h of heads) {
+    if (!isLinking(node, h)) return false
+  }
+
+  return true
+}

package/lib/triggers.js

@@ -0,0 +1,69 @@
+module.exports = class Triggers {
+  constructor() {
+    this.waiting = new Map()
+  }
+
+  add(id, length, writer) {
+    let w = this.waiting.get(id)
+
+    if (!w) {
+      w = []
+      this.waiting.set(id, w)
+    }
+
+    for (let i = 0; i < w.length; i++) {
+      const entry = w[i]
+      if (entry.writer !== writer) continue
+      entry.length = length
+      return entry
+    }
+
+    const entry = { index: w.length, id, writer, length }
+    w.push(entry)
+    return entry
+  }
+
+  remove(entry) {
+    if (!entry.writer) return
+
+    const w = this.waiting.get(entry.id)
+    if (w) this._remove(w, entry)
+  }
+
+  has(id) {
+    return this.waiting.get(id) !== undefined
+  }
+
+  get(id) {
+    return this.waiting.get(id) || null
+  }
+
+  trigger(id, length) {
+    const w = this.waiting.get(id)
+    if (!w) return
+
+    for (let i = w.length - 1; i >= 0; i--) {
+      const entry = w[i]
+      if (entry.length > length) continue
+
+      const writer = entry.writer
+      this._remove(w, entry)
+      writer.bump()
+    }
+  }
+
+  _remove(w, entry) {
+    const head = w.pop()
+
+    if (head !== entry) {
+      w[entry.index] = head
+      head.index = entry.index
+    }
+
+    entry.writer = null
+
+    if (w.length === 0) {
+      this.waiting.delete(entry.id)
+    }
+  }
+}

package/lib/updates.js

@@ -0,0 +1,31 @@
+module.exports = class UpdateChanges {
+  constructor(auto) {
+    this.auto = auto
+    this.byName = new Map()
+  }
+
+  get(key) {
+    return this.byName.get(key)
+  }
+
+  track() {
+    this.tracking = {
+      view: this.auto._workingBee,
+      system: this.auto.system.bee
+    }
+
+    for (const k in this.tracking) {
+      this.byName.set(k, { from: this.tracking[k].head(), to: null })
+    }
+  }
+
+  finalise() {
+    for (const k in this.tracking) {
+      const from = this.byName.get(k).from
+      const to = this.tracking[k].head()
+      this.byName.set(k, { to, from })
+    }
+
+    return this.byName
+  }
+}