@atproto/repo 0.0.1 → 0.2.0

package/bench/mst.bench.ts

@@ -24,14 +24,14 @@ describe('MST Benchmarks', () => {
   const size = 500000
 
   beforeAll(async () => {
-    mapping = await util.generateBulkTidMapping(size)
+    mapping = await util.generateBulkDataKeys(size)
     shuffled = util.shuffle(Object.entries(mapping))
   })
 
   // const fanouts: Fanout[] = [8, 16, 32]
   const fanouts: Fanout[] = [16, 32]
   it('benchmarks various fanouts', async () => {
-    let benches: BenchmarkData[] = []
+    const benches: BenchmarkData[] = []
     for (const fanout of fanouts) {
       const blockstore = new MemoryBlockstore()
       let mst = await MST.create(blockstore, [], { fanout })
@@ -44,11 +44,11 @@ describe('MST Benchmarks', () => {
 
       const doneAdding = Date.now()
 
-      const root = await mst.save()
+      const root = await util.saveMst(blockstore, mst)
 
       const doneSaving = Date.now()
 
-      let reloaded = await MST.load(blockstore, root, { fanout })
+      const reloaded = await MST.load(blockstore, root, { fanout })
       const widthTracker = new NodeWidths()
       for await (const entry of reloaded.walk()) {
         await widthTracker.trackEntry(entry)
@@ -64,6 +64,9 @@ describe('MST Benchmarks', () => {
         for (const entry of path) {
           if (entry.isTree()) {
             const bytes = await blockstore.getBytes(entry.pointer)
+            if (!bytes) {
+              throw new Error(`Bytes not found: ${entry.pointer}`)
+            }
             proofSize += bytes.byteLength
           }
         }

package/bench/repo.bench.ts

@@ -1,37 +1,46 @@
-import * as auth from '@atproto/auth'
-import { MemoryBlockstore, Repo } from '../src'
+import { TID } from '@atproto/common'
+import * as crypto from '@atproto/crypto'
+import { Secp256k1Keypair } from '@atproto/crypto'
+import { MemoryBlockstore, Repo, WriteOpAction } from '../src'
 import * as util from '../tests/_util'
 
 describe('Repo Benchmarks', () => {
-  const verifier = new auth.Verifier()
   const size = 10000
 
   let blockstore: MemoryBlockstore
-  let authStore: auth.AuthStore
+  let keypair: crypto.Keypair
   let repo: Repo
 
   beforeAll(async () => {
     blockstore = new MemoryBlockstore()
-    authStore = await verifier.createTempAuthStore()
-    await authStore.claimFull()
-    repo = await Repo.create(blockstore, await authStore.did(), authStore)
+    keypair = await Secp256k1Keypair.create()
+    repo = await Repo.create(blockstore, await keypair.did(), keypair)
   })
 
   it('calculates size', async () => {
-    const posts = repo.getCollection('app.bsky.post')
     for (let i = 0; i < size; i++) {
       if (i % 500 === 0) {
         console.log(i)
       }
-      await posts.createRecord({
-        $type: 'app.bsky.post',
-        text: util.randomStr(150),
-        reply: {
-          root: 'at://did:plc:1234abdefeoi23/app.bsky.post/12345678912345',
-          parent: 'at://did:plc:1234abdefeoi23/app.bsky.post/12345678912345',
+
+      await repo.applyCommit(
+        {
+          action: WriteOpAction.Create,
+          collection: 'app.bsky.post',
+          rkey: TID.nextStr(),
+          value: {
+            $type: 'app.bsky.post',
+            text: util.randomStr(150),
+            reply: {
+              root: 'at://did:plc:1234abdefeoi23/app.bsky.post/12345678912345',
+              parent:
+                'at://did:plc:1234abdefeoi23/app.bsky.post/12345678912345',
+            },
+            createdAt: new Date().toISOString(),
+          },
         },
-        createdAt: new Date().toISOString(),
-      })
+        keypair,
+      )
     }
 
     console.log('SIZE: ', await blockstore.sizeInBytes())

package/dist/block-map.d.ts

@@ -0,0 +1,27 @@
+import { LexValue } from '@atproto/lexicon';
+import { CID } from 'multiformats/cid';
+export declare class BlockMap {
+    private map;
+    add(value: LexValue): Promise<CID>;
+    set(cid: CID, bytes: Uint8Array): void;
+    get(cid: CID): Uint8Array | undefined;
+    delete(cid: CID): void;
+    getMany(cids: CID[]): {
+        blocks: BlockMap;
+        missing: CID[];
+    };
+    has(cid: CID): boolean;
+    clear(): void;
+    forEach(cb: (bytes: Uint8Array, cid: CID) => void): void;
+    entries(): Entry[];
+    cids(): CID[];
+    addMap(toAdd: BlockMap): void;
+    get size(): number;
+    get byteSize(): number;
+    equals(other: BlockMap): boolean;
+}
+declare type Entry = {
+    cid: CID;
+    bytes: Uint8Array;
+};
+export default BlockMap;

package/dist/data-diff.d.ts

@@ -0,0 +1,36 @@
+import { CID } from 'multiformats';
+import CidSet from './cid-set';
+import { MST } from './mst';
+export declare class DataDiff {
+    adds: Record<string, DataAdd>;
+    updates: Record<string, DataUpdate>;
+    deletes: Record<string, DataDelete>;
+    newCids: CidSet;
+    removedCids: CidSet;
+    static of(curr: MST, prev: MST | null): Promise<DataDiff>;
+    recordAdd(key: string, cid: CID): void;
+    recordUpdate(key: string, prev: CID, cid: CID): void;
+    recordDelete(key: string, cid: CID): void;
+    recordNewCid(cid: CID): void;
+    recordRemovedCid(cid: CID): void;
+    addDiff(diff: DataDiff): void;
+    addList(): DataAdd[];
+    updateList(): DataUpdate[];
+    deleteList(): DataDelete[];
+    newCidList(): CID[];
+    updatedKeys(): string[];
+}
+export declare type DataAdd = {
+    key: string;
+    cid: CID;
+};
+export declare type DataUpdate = {
+    key: string;
+    prev: CID;
+    cid: CID;
+};
+export declare type DataDelete = {
+    key: string;
+    cid: CID;
+};
+export default DataDiff;

package/dist/error.d.ts

@@ -0,0 +1,20 @@
+import { CID } from 'multiformats/cid';
+export declare class MissingBlockError extends Error {
+    cid: CID;
+    constructor(cid: CID, def?: string);
+}
+export declare class MissingBlocksError extends Error {
+    context: string;
+    cids: CID[];
+    constructor(context: string, cids: CID[]);
+}
+export declare class MissingCommitBlocksError extends Error {
+    commit: CID;
+    cids: CID[];
+    constructor(commit: CID, cids: CID[]);
+}
+export declare class UnexpectedObjectError extends Error {
+    cid: CID;
+    def: string;
+    constructor(cid: CID, def: string);
+}

package/dist/index.d.ts

@@ -1,7 +1,10 @@
-export * from './blockstore';
+export * from './block-map';
+export * from './cid-set';
 export * from './repo';
 export * from './mst';
 export * from './storage';
+export * from './sync';
 export * from './types';
 export * from './verify';
+export * from './data-diff';
 export * from './util';