@atproto/repo 0.10.2 → 0.10.3

package/src/data-diff.ts

@@ -1,117 +0,0 @@
-import { Cid } from '@atproto/lex-data'
-import { BlockMap } from './block-map.js'
-import { CidSet } from './cid-set.js'
-import { MST, NodeEntry, mstDiff } from './mst/index.js'
-
-export class DataDiff {
-  adds: Record<string, DataAdd> = {}
-  updates: Record<string, DataUpdate> = {}
-  deletes: Record<string, DataDelete> = {}
-
-  newMstBlocks: BlockMap = new BlockMap()
-  newLeafCids: CidSet = new CidSet()
-  removedCids: CidSet = new CidSet()
-
-  static async of(curr: MST, prev: MST | null): Promise<DataDiff> {
-    return mstDiff(curr, prev)
-  }
-
-  async nodeAdd(node: NodeEntry) {
-    if (node.isLeaf()) {
-      this.leafAdd(node.key, node.value)
-    } else {
-      const data = await node.serialize()
-      this.treeAdd(data.cid, data.bytes)
-    }
-  }
-
-  async nodeDelete(node: NodeEntry) {
-    if (node.isLeaf()) {
-      const key = node.key
-      const cid = node.value
-      this.deletes[key] = { key, cid }
-      this.removedCids.add(cid)
-    } else {
-      const cid = await node.getPointer()
-      this.treeDelete(cid)
-    }
-  }
-
-  leafAdd(key: string, cid: Cid) {
-    this.adds[key] = { key, cid }
-    if (this.removedCids.has(cid)) {
-      this.removedCids.delete(cid)
-    } else {
-      this.newLeafCids.add(cid)
-    }
-  }
-
-  leafUpdate(key: string, prev: Cid, cid: Cid) {
-    if (prev.equals(cid)) return
-    this.updates[key] = { key, prev, cid }
-    this.removedCids.add(prev)
-    this.newLeafCids.add(cid)
-  }
-
-  leafDelete(key: string, cid: Cid) {
-    this.deletes[key] = { key, cid }
-    if (this.newLeafCids.has(cid)) {
-      this.newLeafCids.delete(cid)
-    } else {
-      this.removedCids.add(cid)
-    }
-  }
-
-  treeAdd(cid: Cid, bytes: Uint8Array) {
-    if (this.removedCids.has(cid)) {
-      this.removedCids.delete(cid)
-    } else {
-      this.newMstBlocks.set(cid, bytes)
-    }
-  }
-
-  treeDelete(cid: Cid) {
-    if (this.newMstBlocks.has(cid)) {
-      this.newMstBlocks.delete(cid)
-    } else {
-      this.removedCids.add(cid)
-    }
-  }
-
-  addList(): DataAdd[] {
-    return Object.values(this.adds)
-  }
-
-  updateList(): DataUpdate[] {
-    return Object.values(this.updates)
-  }
-
-  deleteList(): DataDelete[] {
-    return Object.values(this.deletes)
-  }
-
-  updatedKeys(): string[] {
-    const keys = [
-      ...Object.keys(this.adds),
-      ...Object.keys(this.updates),
-      ...Object.keys(this.deletes),
-    ]
-    return [...new Set(keys)]
-  }
-}
-
-export type DataAdd = {
-  key: string
-  cid: Cid
-}
-
-export type DataUpdate = {
-  key: string
-  prev: Cid
-  cid: Cid
-}
-
-export type DataDelete = {
-  key: string
-  cid: Cid
-}

package/src/error.ts

@@ -1,43 +0,0 @@
-import { Cid } from '@atproto/lex-data'
-
-export class MissingBlockError extends Error {
-  constructor(
-    public cid: Cid,
-    def?: string,
-  ) {
-    let msg = `block not found: ${cid.toString()}`
-    if (def) {
-      msg += `, expected type: ${def}`
-    }
-    super(msg)
-  }
-}
-
-export class MissingBlocksError extends Error {
-  constructor(
-    public context: string,
-    public cids: Cid[],
-  ) {
-    const cidStr = cids.map((c) => c.toString())
-    super(`missing ${context} blocks: ${cidStr}`)
-  }
-}
-
-export class MissingCommitBlocksError extends Error {
-  constructor(
-    public commit: Cid,
-    public cids: Cid[],
-  ) {
-    const cidStr = cids.map((c) => c.toString())
-    super(`missing blocks for commit ${commit.toString()}: ${cidStr}`)
-  }
-}
-
-export class UnexpectedObjectError extends Error {
-  constructor(
-    public cid: Cid,
-    public def: string,
-  ) {
-    super(`unexpected object at ${cid.toString()}, expected: ${def}`)
-  }
-}

package/src/index.ts

@@ -1,11 +0,0 @@
-export * from './block-map.js'
-export * from './cid-set.js'
-export * from './repo.js'
-export * from './mst/index.js'
-export * from './parse.js'
-export * from './storage/index.js'
-export * from './sync/index.js'
-export * from './types.js'
-export * from './data-diff.js'
-export * from './car.js'
-export * from './util.js'

package/src/logger.ts

@@ -1,7 +0,0 @@
-// @TODO remove dependency on @atproto/common and subsystemLogger
-import { subsystemLogger } from '@atproto/common'
-
-export const logger: ReturnType<typeof subsystemLogger> =
-  subsystemLogger('repo')
-
-export default logger

package/src/mst/diff.ts

@@ -1,114 +0,0 @@
-import { DataDiff } from '../data-diff.js'
-import { MST } from './mst.js'
-import { MstWalker } from './walker.js'
-
-export const nullDiff = async (tree: MST): Promise<DataDiff> => {
-  const diff = new DataDiff()
-  for await (const entry of tree.walk()) {
-    await diff.nodeAdd(entry)
-  }
-  return diff
-}
-
-export const mstDiff = async (
-  curr: MST,
-  prev: MST | null,
-): Promise<DataDiff> => {
-  await curr.getPointer()
-  if (prev === null) {
-    return nullDiff(curr)
-  }
-
-  await prev.getPointer()
-  const diff = new DataDiff()
-
-  const leftWalker = new MstWalker(prev)
-  const rightWalker = new MstWalker(curr)
-  while (!leftWalker.status.done || !rightWalker.status.done) {
-    // if one walker is finished, continue walking the other & logging all nodes
-    if (leftWalker.status.done && !rightWalker.status.done) {
-      await diff.nodeAdd(rightWalker.status.curr)
-      await rightWalker.advance()
-      continue
-    } else if (!leftWalker.status.done && rightWalker.status.done) {
-      await diff.nodeDelete(leftWalker.status.curr)
-      await leftWalker.advance()
-      continue
-    }
-    if (leftWalker.status.done || rightWalker.status.done) break
-    const left = leftWalker.status.curr
-    const right = rightWalker.status.curr
-    if (left === null || right === null) break
-
-    // if both pointers are leaves, record an update & advance both or record the lowest key and advance that pointer
-    if (left.isLeaf() && right.isLeaf()) {
-      if (left.key === right.key) {
-        if (!left.value.equals(right.value)) {
-          diff.leafUpdate(left.key, left.value, right.value)
-        }
-        await leftWalker.advance()
-        await rightWalker.advance()
-      } else if (left.key < right.key) {
-        diff.leafDelete(left.key, left.value)
-        await leftWalker.advance()
-      } else {
-        diff.leafAdd(right.key, right.value)
-        await rightWalker.advance()
-      }
-      continue
-    }
-
-    // next, ensure that we're on the same layer
-    // if one walker is at a higher layer than the other, we need to do one of two things
-    // if the higher walker is pointed at a tree, step into that tree to try to catch up with the lower
-    // if the higher walker is pointed at a leaf, then advance the lower walker to try to catch up the higher
-    if (leftWalker.layer() > rightWalker.layer()) {
-      if (left.isLeaf()) {
-        await diff.nodeAdd(right)
-        await rightWalker.advance()
-      } else {
-        await diff.nodeDelete(left)
-        await leftWalker.stepInto()
-      }
-      continue
-    } else if (leftWalker.layer() < rightWalker.layer()) {
-      if (right.isLeaf()) {
-        await diff.nodeDelete(left)
-        await leftWalker.advance()
-      } else {
-        await diff.nodeAdd(right)
-        await rightWalker.stepInto()
-      }
-      continue
-    }
-
-    // if we're on the same level, and both pointers are trees, do a comparison
-    // if they're the same, step over. if they're different, step in to find the subdiff
-    if (left.isTree() && right.isTree()) {
-      if (left.pointer.equals(right.pointer)) {
-        await leftWalker.stepOver()
-        await rightWalker.stepOver()
-      } else {
-        await diff.nodeAdd(right)
-        await diff.nodeDelete(left)
-        await leftWalker.stepInto()
-        await rightWalker.stepInto()
-      }
-      continue
-    }
-
-    // finally, if one pointer is a tree and the other is a leaf, simply step into the tree
-    if (left.isLeaf() && right.isTree()) {
-      await diff.nodeAdd(right)
-      await rightWalker.stepInto()
-      continue
-    } else if (left.isTree() && right.isLeaf()) {
-      await diff.nodeDelete(left)
-      await leftWalker.stepInto()
-      continue
-    }
-
-    throw new Error('Unidentifiable case in diff walk')
-  }
-  return diff
-}

package/src/mst/index.ts

@@ -1,4 +0,0 @@
-export * from './mst.js'
-export * from './diff.js'
-export * from './walker.js'
-export * as mstUtil from './util.js'