@atproto/repo 0.0.1 → 0.1.0

package/src/blockstore/ipld-store.ts

@@ -1,103 +0,0 @@
-import { CID } from 'multiformats/cid'
-import { BlockWriter } from '@ipld/car/writer'
-
-import * as common from '@atproto/common'
-import { check, util, valueToIpldBlock } from '@atproto/common'
-import { BlockReader } from '@ipld/car/api'
-import CidSet from '../cid-set'
-import { CarReader } from '@ipld/car/reader'
-
-export abstract class IpldStore {
-  staged: Map<string, Uint8Array>
-
-  constructor() {
-    this.staged = new Map()
-  }
-
-  abstract getSavedBytes(cid: CID): Promise<Uint8Array | null>
-  abstract hasSavedBlock(cid: CID): Promise<boolean>
-  abstract saveStaged(): Promise<void>
-  abstract destroySaved(): Promise<void>
-
-  async stageBytes(k: CID, v: Uint8Array): Promise<void> {
-    this.staged.set(k.toString(), v)
-  }
-
-  async stage(value: unknown): Promise<CID> {
-    const block = await valueToIpldBlock(value)
-    await this.stageBytes(block.cid, block.bytes)
-    return block.cid
-  }
-
-  async getBytes(cid: CID): Promise<Uint8Array> {
-    const fromStaged = this.staged.get(cid.toString())
-    if (fromStaged) return fromStaged
-    const fromBlocks = await this.getSavedBytes(cid)
-    if (fromBlocks) return fromBlocks
-    throw new Error(`Not found: ${cid.toString()}`)
-  }
-
-  async get<T>(cid: CID, schema: check.Def<T>): Promise<T> {
-    const value = await this.getUnchecked(cid)
-    try {
-      return check.assure(schema, value)
-    } catch (err) {
-      throw new Error(
-        `Did not find expected object at ${cid.toString()}: ${err}`,
-      )
-    }
-  }
-
-  async getUnchecked(cid: CID): Promise<unknown> {
-    const bytes = await this.getBytes(cid)
-    return common.ipldBytesToValue(bytes)
-  }
-
-  async has(cid: CID): Promise<boolean> {
-    return this.staged.has(cid.toString()) || this.hasSavedBlock(cid)
-  }
-
-  async isMissing(cid: CID): Promise<boolean> {
-    const has = await this.has(cid)
-    return !has
-  }
-
-  async checkMissing(cids: CidSet): Promise<CidSet> {
-    const missing = await util.asyncFilter(cids.toList(), (c) => {
-      return this.isMissing(c)
-    })
-    return new CidSet(missing)
-  }
-
-  async clearStaged(): Promise<void> {
-    this.staged.clear()
-  }
-
-  async destroy(): Promise<void> {
-    this.clearStaged()
-    await this.destroySaved()
-  }
-
-  async addToCar(car: BlockWriter, cid: CID) {
-    car.put({ cid, bytes: await this.getBytes(cid) })
-  }
-
-  async stageCar(buf: Uint8Array): Promise<CID> {
-    const car = await CarReader.fromBytes(buf)
-    const roots = await car.getRoots()
-    if (roots.length !== 1) {
-      throw new Error(`Expected one root, got ${roots.length}`)
-    }
-    const rootCid = roots[0]
-    await this.stageCarBlocks(car)
-    return rootCid
-  }
-
-  async stageCarBlocks(car: BlockReader): Promise<void> {
-    for await (const block of car.blocks()) {
-      await this.stageBytes(block.cid, block.bytes)
-    }
-  }
-}
-
-export default IpldStore

package/src/blockstore/memory-blockstore.ts

@@ -1,49 +0,0 @@
-import { CID } from 'multiformats/cid'
-import IpldStore from './ipld-store'
-
-export class MemoryBlockstore extends IpldStore {
-  blocks: Map<string, Uint8Array>
-
-  constructor() {
-    super()
-    this.blocks = new Map()
-  }
-
-  async getSavedBytes(cid: CID): Promise<Uint8Array | null> {
-    return this.blocks.get(cid.toString()) || null
-  }
-
-  async hasSavedBlock(cid: CID): Promise<boolean> {
-    return this.blocks.has(cid.toString())
-  }
-
-  async saveStaged(): Promise<void> {
-    this.staged.forEach((val, key) => {
-      this.blocks.set(key, val)
-    })
-    this.clearStaged()
-  }
-
-  async sizeInBytes(): Promise<number> {
-    let total = 0
-    for (const val of this.blocks.values()) {
-      total += val.byteLength
-    }
-    return total
-  }
-
-  async destroySaved(): Promise<void> {
-    this.blocks.clear()
-  }
-
-  // Mainly for dev purposes
-  async getContents(): Promise<Record<string, unknown>> {
-    const contents: Record<string, unknown> = {}
-    for (const key of this.blocks.keys()) {
-      contents[key] = await this.getUnchecked(CID.parse(key))
-    }
-    return contents
-  }
-}
-
-export default MemoryBlockstore

package/src/sync.ts

@@ -1,38 +0,0 @@
-import * as auth from '@atproto/auth'
-import { IpldStore } from './blockstore'
-import { DataDiff } from './mst'
-import Repo from './repo'
-import * as verify from './verify'
-
-export const loadRepoFromCar = async (
-  carBytes: Uint8Array,
-  blockstore: IpldStore,
-  verifier: auth.Verifier,
-): Promise<Repo> => {
-  const root = await blockstore.stageCar(carBytes)
-  const repo = await Repo.load(blockstore, root)
-  await verify.verifyUpdates(blockstore, null, repo.cid, verifier)
-  await blockstore.saveStaged()
-  return repo
-}
-
-export const loadDiff = async (
-  repo: Repo,
-  diffCar: Uint8Array,
-  verifier: auth.Verifier,
-): Promise<{ repo: Repo; diff: DataDiff }> => {
-  const blockstore = repo.blockstore
-  const root = await blockstore.stageCar(diffCar)
-  const diff = await verify.verifyUpdates(
-    repo.blockstore,
-    repo.cid,
-    root,
-    verifier,
-  )
-  const updatedRepo = await Repo.load(blockstore, root)
-  await blockstore.saveStaged()
-  return {
-    repo: updatedRepo,
-    diff,
-  }
-}

package/tests/sync.test.ts

@@ -1,129 +0,0 @@
-import * as auth from '@atproto/auth'
-import { TID } from '@atproto/common'
-import { Repo, RepoRoot, verifyUpdates, ucanForOperation } from '../src'
-import { MemoryBlockstore } from '../src/blockstore'
-import * as sync from '../src/sync'
-
-import * as util from './_util'
-
-describe('Sync', () => {
-  const verifier = new auth.Verifier()
-
-  let aliceBlockstore: MemoryBlockstore, bobBlockstore: MemoryBlockstore
-  let aliceRepo: Repo
-  let aliceAuth: auth.AuthStore
-  let repoData: util.RepoData
-
-  beforeAll(async () => {
-    aliceBlockstore = new MemoryBlockstore()
-    aliceAuth = await verifier.createTempAuthStore()
-    await aliceAuth.claimFull()
-    aliceRepo = await Repo.create(
-      aliceBlockstore,
-      await aliceAuth.did(),
-      aliceAuth,
-    )
-    bobBlockstore = new MemoryBlockstore()
-  })
-
-  it('syncs an empty repo', async () => {
-    const car = await aliceRepo.getFullHistory()
-    const repoBob = await sync.loadRepoFromCar(car, bobBlockstore, verifier)
-    const data = await repoBob.data.list(10)
-    expect(data.length).toBe(0)
-  })
-
-  let bobRepo: Repo
-
-  it('syncs a repo that is starting from scratch', async () => {
-    const filled = await util.fillRepo(aliceRepo, aliceAuth, 100)
-    aliceRepo = filled.repo
-    repoData = filled.data
-    await aliceRepo.getFullHistory()
-
-    const car = await aliceRepo.getFullHistory()
-    bobRepo = await sync.loadRepoFromCar(car, bobBlockstore, verifier)
-    const diff = await verifyUpdates(bobBlockstore, null, bobRepo.cid, verifier)
-    await util.checkRepo(bobRepo, repoData)
-    await util.checkRepoDiff(diff, {}, repoData)
-  })
-
-  it('syncs a repo that is behind', async () => {
-    // add more to alice's repo & have bob catch up
-    const beforeData = JSON.parse(JSON.stringify(repoData))
-    const edited = await util.editRepo(aliceRepo, repoData, aliceAuth, {
-      adds: 20,
-      updates: 20,
-      deletes: 20,
-    })
-    aliceRepo = edited.repo
-    repoData = edited.data
-    const diffCar = await aliceRepo.getDiffCar(bobRepo.cid)
-    const loaded = await sync.loadDiff(bobRepo, diffCar, verifier)
-    await util.checkRepo(loaded.repo, repoData)
-    await util.checkRepoDiff(loaded.diff, beforeData, repoData)
-  })
-
-  it('throws an error on invalid UCANs', async () => {
-    const obj = util.generateObject()
-    const cid = await aliceBlockstore.stage(obj)
-    const updatedData = await aliceRepo.data.add(
-      `com.example.test/${TID.next()}`,
-      cid,
-    )
-    // we create an unrelated token for bob & try to permission alice's repo commit with it
-    const bobAuth = await verifier.createTempAuthStore()
-    const badUcan = await bobAuth.claimFull()
-    const auth_token = await aliceBlockstore.stage(auth.encodeUcan(badUcan))
-    const dataCid = await updatedData.stage()
-    const root: RepoRoot = {
-      meta: aliceRepo.root.meta,
-      prev: aliceRepo.cid,
-      auth_token,
-      data: dataCid,
-    }
-    const rootCid = await aliceBlockstore.stage(root)
-    const commit = {
-      root: rootCid,
-      sig: await aliceAuth.sign(rootCid.bytes),
-    }
-    const commitCid = await aliceBlockstore.stage(commit)
-    const badAliceRepo = await Repo.load(aliceBlockstore, commitCid)
-    const diffCar = await badAliceRepo.getDiffCar(bobRepo.cid)
-    await expect(sync.loadDiff(bobRepo, diffCar, verifier)).rejects.toThrow()
-    // await aliceBlockstore.clearStaged()
-  })
-
-  it('throws on a bad signature', async () => {
-    const obj = util.generateObject()
-    const cid = await aliceBlockstore.stage(obj)
-    const updatedData = await aliceRepo.data.add(
-      `com.example.test/${TID.next()}`,
-      cid,
-    )
-    const authToken = await ucanForOperation(
-      aliceRepo.data,
-      updatedData,
-      aliceRepo.did,
-      aliceAuth,
-    )
-    const authCid = await aliceBlockstore.stage(authToken)
-    const dataCid = await updatedData.stage()
-    const root: RepoRoot = {
-      meta: aliceRepo.root.meta,
-      prev: aliceRepo.cid,
-      auth_token: authCid,
-      data: dataCid,
-    }
-    const rootCid = await aliceBlockstore.stage(root)
-    // we generated a bad sig by signing the data cid instead of root cid
-    const commit = {
-      root: rootCid,
-      sig: await aliceAuth.sign(dataCid.bytes),
-    }
-    const commitCid = await aliceBlockstore.stage(commit)
-    const badAliceRepo = await Repo.load(aliceBlockstore, commitCid)
-    const diffCar = await badAliceRepo.getDiffCar(bobRepo.cid)
-    await expect(sync.loadDiff(bobRepo, diffCar, verifier)).rejects.toThrow()
-  })
-})