@atproto/repo 0.1.0 → 0.2.0

package/dist/src/storage/util.d.ts

@@ -0,0 +1,17 @@
+import { check } from '@atproto/common';
+import { CID } from 'multiformats/cid';
+import BlockMap from '../block-map';
+import { ReadableBlockstore } from './types';
+export declare const readAndVerify: <T>(storage: ReadableBlockstore, cid: CID, def: check.Def<T>) => Promise<{
+    obj: T;
+    bytes: Uint8Array;
+}>;
+export declare const getAndVerify: <T>(blocks: BlockMap, cid: CID, def: check.Def<T>) => Promise<{
+    obj: T;
+    bytes: Uint8Array;
+}>;
+export declare const verifyObj: <T>(bytes: Uint8Array | null, cid: CID, def: check.Def<T>) => Promise<{
+    obj: T;
+    bytes: Uint8Array;
+}>;
+export declare const readObj: <T>(storage: ReadableBlockstore, cid: CID, schema: check.Def<T>) => Promise<T>;

package/dist/src/structure.d.ts

@@ -0,0 +1,39 @@
+import { CID } from 'multiformats/cid';
+import { BlockWriter } from '@ipld/car/lib/writer-browser';
+import { RepoRoot, Commit, CidWriteOp, DataStore, RepoMeta } from './types';
+import IpldStore from './blockstore/ipld-store';
+import * as auth from '@atproto/auth';
+declare type Params = {
+    blockstore: IpldStore;
+    data: DataStore;
+    commit: Commit;
+    root: RepoRoot;
+    meta: RepoMeta;
+    cid: CID;
+    stagedWrites: CidWriteOp[];
+};
+export declare class RepoStructure {
+    blockstore: IpldStore;
+    data: DataStore;
+    commit: Commit;
+    root: RepoRoot;
+    meta: RepoMeta;
+    cid: CID;
+    stagedWrites: CidWriteOp[];
+    constructor(params: Params);
+    static create(blockstore: IpldStore, did: string, authStore: auth.AuthStore): Promise<RepoStructure>;
+    static load(blockstore: IpldStore, cid: CID): Promise<RepoStructure>;
+    private updateRepo;
+    did(): string;
+    getRecord(collection: string, rkey: string): Promise<unknown | null>;
+    stageUpdate(write: CidWriteOp | CidWriteOp[]): RepoStructure;
+    createCommit(authStore: auth.AuthStore, performUpdate?: (prev: CID, curr: CID) => Promise<CID | null>): Promise<RepoStructure>;
+    revert(count: number): Promise<RepoStructure>;
+    getCarNoHistory(): Promise<Uint8Array>;
+    getDiffCar(to: CID | null): Promise<Uint8Array>;
+    getFullHistory(): Promise<Uint8Array>;
+    private openCar;
+    writeCheckoutToCarStream(car: BlockWriter): Promise<void>;
+    writeCommitsToCarStream(car: BlockWriter, oldestCommit: CID | null, recentCommit: CID): Promise<void>;
+}
+export default RepoStructure;

package/dist/src/sync/consumer.d.ts

@@ -0,0 +1,19 @@
+import { CID } from 'multiformats/cid';
+import { DidResolver } from '@atproto/did-resolver';
+import { RepoStorage } from '../storage';
+import Repo from '../repo';
+import * as verify from '../verify';
+import { RepoContents, WriteLog } from '../types';
+export declare const loadCheckout: (storage: RepoStorage, repoCar: Uint8Array, didResolver: DidResolver) => Promise<{
+    root: CID;
+    contents: RepoContents;
+}>;
+export declare const loadFullRepo: (storage: RepoStorage, repoCar: Uint8Array, didResolver: DidResolver) => Promise<{
+    root: CID;
+    writeLog: WriteLog;
+}>;
+export declare const loadDiff: (repo: Repo, diffCar: Uint8Array, didResolver: DidResolver) => Promise<{
+    root: CID;
+    writeLog: WriteLog;
+}>;
+export declare const persistUpdates: (storage: RepoStorage, updateStorage: RepoStorage, updates: verify.VerifiedUpdate[]) => Promise<WriteLog>;

package/dist/src/sync/index.d.ts

@@ -0,0 +1,2 @@
+export * from './consumer';
+export * from './provider';

package/dist/src/sync/producer.d.ts

@@ -0,0 +1,13 @@
+import { BlockWriter } from '@ipld/car/writer';
+import { CID } from 'multiformats/cid';
+import { RepoStorage } from '../storage';
+import { RepoRoot } from '../types';
+export declare const getCheckout: (storage: RepoStorage, cid: CID) => Promise<Uint8Array>;
+export declare const getDiff: (storage: RepoStorage, latest: CID, earliest: CID | null) => Promise<Uint8Array>;
+export declare const getFullRepo: (storage: RepoStorage, cid: CID) => Promise<Uint8Array>;
+export declare const writeCommitsToCarStream: (storage: RepoStorage, car: BlockWriter, latest: CID, earliest: CID | null) => Promise<void>;
+export declare const getRecords: (storage: RepoStorage, commit: CID, paths: {
+    collection: string;
+    rkey: string;
+}[]) => Promise<Uint8Array>;
+export declare const writeCommitAndRootToCar: (storage: RepoStorage, car: BlockWriter, cid: CID) => Promise<RepoRoot>;

package/dist/src/sync/provider.d.ts

@@ -0,0 +1,11 @@
+import { RecordPath } from '../types';
+import { BlockWriter } from '@ipld/car/writer';
+import { CID } from 'multiformats/cid';
+import { RepoStorage } from '../storage';
+import { RepoRoot } from '../types';
+export declare const getCheckout: (storage: RepoStorage, cid: CID) => Promise<Uint8Array>;
+export declare const getDiff: (storage: RepoStorage, latest: CID, earliest: CID | null) => Promise<Uint8Array>;
+export declare const getFullRepo: (storage: RepoStorage, cid: CID) => Promise<Uint8Array>;
+export declare const writeCommitsToCarStream: (storage: RepoStorage, car: BlockWriter, latest: CID, earliest: CID | null) => Promise<void>;
+export declare const getRecords: (storage: RepoStorage, commit: CID, paths: RecordPath[]) => Promise<Uint8Array>;
+export declare const writeCommitAndRootToCar: (storage: RepoStorage, car: BlockWriter, cid: CID) => Promise<RepoRoot>;

package/dist/src/types.d.ts

@@ -0,0 +1,368 @@
+import { z } from 'zod';
+import { BlockWriter } from '@ipld/car/writer';
+import { CID } from 'multiformats';
+import { DataDiff } from './mst';
+declare const repoMeta: z.ZodObject<{
+    did: z.ZodString;
+    version: z.ZodNumber;
+    datastore: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    did: string;
+    version: number;
+    datastore: string;
+}, {
+    did: string;
+    version: number;
+    datastore: string;
+}>;
+export declare type RepoMeta = z.infer<typeof repoMeta>;
+declare const repoRoot: z.ZodObject<{
+    meta: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+    prev: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
+    auth_token: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
+    data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+}, "strip", z.ZodTypeAny, {
+    data: CID;
+    meta: CID;
+    prev: CID | null;
+    auth_token: CID | null;
+}, {
+    data?: any;
+    meta?: any;
+    prev?: any;
+    auth_token?: any;
+}>;
+export declare type RepoRoot = z.infer<typeof repoRoot>;
+declare const commit: z.ZodObject<{
+    root: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+    sig: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
+}, "strip", z.ZodTypeAny, {
+    root: CID;
+    sig: Uint8Array;
+}, {
+    root?: any;
+    sig: Uint8Array;
+}>;
+export declare type Commit = z.infer<typeof commit>;
+export declare const cidCreateOp: z.ZodObject<{
+    action: z.ZodLiteral<"create">;
+    collection: z.ZodString;
+    rkey: z.ZodString;
+    cid: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+}, "strip", z.ZodTypeAny, {
+    collection: string;
+    action: "create";
+    rkey: string;
+    cid: CID;
+}, {
+    cid?: any;
+    collection: string;
+    action: "create";
+    rkey: string;
+}>;
+export declare type CidCreateOp = z.infer<typeof cidCreateOp>;
+export declare const cidUpdateOp: z.ZodObject<{
+    action: z.ZodLiteral<"update">;
+    collection: z.ZodString;
+    rkey: z.ZodString;
+    cid: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+}, "strip", z.ZodTypeAny, {
+    collection: string;
+    action: "update";
+    rkey: string;
+    cid: CID;
+}, {
+    cid?: any;
+    collection: string;
+    action: "update";
+    rkey: string;
+}>;
+export declare type CidUpdateOp = z.infer<typeof cidUpdateOp>;
+export declare const deleteOp: z.ZodObject<{
+    action: z.ZodLiteral<"delete">;
+    collection: z.ZodString;
+    rkey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    collection: string;
+    action: "delete";
+    rkey: string;
+}, {
+    collection: string;
+    action: "delete";
+    rkey: string;
+}>;
+export declare type DeleteOp = z.infer<typeof deleteOp>;
+export declare const cidWriteOp: z.ZodUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"create">;
+    collection: z.ZodString;
+    rkey: z.ZodString;
+    cid: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+}, "strip", z.ZodTypeAny, {
+    collection: string;
+    action: "create";
+    rkey: string;
+    cid: CID;
+}, {
+    cid?: any;
+    collection: string;
+    action: "create";
+    rkey: string;
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"update">;
+    collection: z.ZodString;
+    rkey: z.ZodString;
+    cid: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+}, "strip", z.ZodTypeAny, {
+    collection: string;
+    action: "update";
+    rkey: string;
+    cid: CID;
+}, {
+    cid?: any;
+    collection: string;
+    action: "update";
+    rkey: string;
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"delete">;
+    collection: z.ZodString;
+    rkey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    collection: string;
+    action: "delete";
+    rkey: string;
+}, {
+    collection: string;
+    action: "delete";
+    rkey: string;
+}>]>;
+export declare type CidWriteOp = z.infer<typeof cidWriteOp>;
+export declare const recordCreateOp: z.ZodObject<{
+    action: z.ZodLiteral<"create">;
+    collection: z.ZodString;
+    rkey: z.ZodString;
+    value: z.ZodAny;
+}, "strip", z.ZodTypeAny, {
+    value?: any;
+    collection: string;
+    action: "create";
+    rkey: string;
+}, {
+    value?: any;
+    collection: string;
+    action: "create";
+    rkey: string;
+}>;
+export declare type RecordCreateOp = z.infer<typeof recordCreateOp>;
+export declare const recordUpdateOp: z.ZodObject<{
+    action: z.ZodLiteral<"update">;
+    collection: z.ZodString;
+    rkey: z.ZodString;
+    value: z.ZodAny;
+}, "strip", z.ZodTypeAny, {
+    value?: any;
+    collection: string;
+    action: "update";
+    rkey: string;
+}, {
+    value?: any;
+    collection: string;
+    action: "update";
+    rkey: string;
+}>;
+export declare type RecordUpdateOp = z.infer<typeof recordUpdateOp>;
+export declare const recordWriteOp: z.ZodUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"create">;
+    collection: z.ZodString;
+    rkey: z.ZodString;
+    value: z.ZodAny;
+}, "strip", z.ZodTypeAny, {
+    value?: any;
+    collection: string;
+    action: "create";
+    rkey: string;
+}, {
+    value?: any;
+    collection: string;
+    action: "create";
+    rkey: string;
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"update">;
+    collection: z.ZodString;
+    rkey: z.ZodString;
+    value: z.ZodAny;
+}, "strip", z.ZodTypeAny, {
+    value?: any;
+    collection: string;
+    action: "update";
+    rkey: string;
+}, {
+    value?: any;
+    collection: string;
+    action: "update";
+    rkey: string;
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"delete">;
+    collection: z.ZodString;
+    rkey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    collection: string;
+    action: "delete";
+    rkey: string;
+}, {
+    collection: string;
+    action: "delete";
+    rkey: string;
+}>]>;
+export declare type RecordWriteOp = z.infer<typeof recordWriteOp>;
+export declare const def: {
+    repoMeta: z.ZodObject<{
+        did: z.ZodString;
+        version: z.ZodNumber;
+        datastore: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        did: string;
+        version: number;
+        datastore: string;
+    }, {
+        did: string;
+        version: number;
+        datastore: string;
+    }>;
+    repoRoot: z.ZodObject<{
+        meta: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+        prev: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
+        auth_token: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
+        data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+    }, "strip", z.ZodTypeAny, {
+        data: CID;
+        meta: CID;
+        prev: CID | null;
+        auth_token: CID | null;
+    }, {
+        data?: any;
+        meta?: any;
+        prev?: any;
+        auth_token?: any;
+    }>;
+    commit: z.ZodObject<{
+        root: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+        sig: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
+    }, "strip", z.ZodTypeAny, {
+        root: CID;
+        sig: Uint8Array;
+    }, {
+        root?: any;
+        sig: Uint8Array;
+    }>;
+    cidWriteOp: z.ZodUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"create">;
+        collection: z.ZodString;
+        rkey: z.ZodString;
+        cid: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+    }, "strip", z.ZodTypeAny, {
+        collection: string;
+        action: "create";
+        rkey: string;
+        cid: CID;
+    }, {
+        cid?: any;
+        collection: string;
+        action: "create";
+        rkey: string;
+    }>, z.ZodObject<{
+        action: z.ZodLiteral<"update">;
+        collection: z.ZodString;
+        rkey: z.ZodString;
+        cid: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+    }, "strip", z.ZodTypeAny, {
+        collection: string;
+        action: "update";
+        rkey: string;
+        cid: CID;
+    }, {
+        cid?: any;
+        collection: string;
+        action: "update";
+        rkey: string;
+    }>, z.ZodObject<{
+        action: z.ZodLiteral<"delete">;
+        collection: z.ZodString;
+        rkey: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        collection: string;
+        action: "delete";
+        rkey: string;
+    }, {
+        collection: string;
+        action: "delete";
+        rkey: string;
+    }>]>;
+    recordWriteOp: z.ZodUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"create">;
+        collection: z.ZodString;
+        rkey: z.ZodString;
+        value: z.ZodAny;
+    }, "strip", z.ZodTypeAny, {
+        value?: any;
+        collection: string;
+        action: "create";
+        rkey: string;
+    }, {
+        value?: any;
+        collection: string;
+        action: "create";
+        rkey: string;
+    }>, z.ZodObject<{
+        action: z.ZodLiteral<"update">;
+        collection: z.ZodString;
+        rkey: z.ZodString;
+        value: z.ZodAny;
+    }, "strip", z.ZodTypeAny, {
+        value?: any;
+        collection: string;
+        action: "update";
+        rkey: string;
+    }, {
+        value?: any;
+        collection: string;
+        action: "update";
+        rkey: string;
+    }>, z.ZodObject<{
+        action: z.ZodLiteral<"delete">;
+        collection: z.ZodString;
+        rkey: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        collection: string;
+        action: "delete";
+        rkey: string;
+    }, {
+        collection: string;
+        action: "delete";
+        rkey: string;
+    }>]>;
+    string: z.ZodString;
+    cid: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+    strToCid: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, CID, string>;
+    bytes: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
+    strToInt: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, number, string>;
+    strToBool: z.ZodEffects<z.ZodString, boolean, string>;
+};
+export interface CarStreamable {
+    writeToCarStream(car: BlockWriter): Promise<void>;
+}
+export declare type DataValue = {
+    key: string;
+    value: CID;
+};
+export interface DataStore {
+    add(key: string, value: CID): Promise<DataStore>;
+    update(key: string, value: CID): Promise<DataStore>;
+    delete(key: string): Promise<DataStore>;
+    get(key: string): Promise<CID | null>;
+    list(count: number, after?: string, before?: string): Promise<DataValue[]>;
+    listWithPrefix(prefix: string, count?: number): Promise<DataValue[]>;
+    diff(other: DataStore): Promise<DataDiff>;
+    stage(): Promise<CID>;
+    writeToCarStream(car: BlockWriter): Promise<void>;
+}
+export {};

package/dist/src/util.d.ts

@@ -0,0 +1,13 @@
+import { CID } from 'multiformats/cid';
+import * as auth from '@atproto/auth';
+import { DataDiff } from './mst';
+import { IpldStore } from './blockstore';
+import { DataStore, RecordWriteOp } from './types';
+export declare const ucanForOperation: (prevData: DataStore, newData: DataStore, rootDid: string, authStore: auth.AuthStore) => Promise<string>;
+export declare const getCommitPath: (blockstore: IpldStore, earliest: CID | null, latest: CID) => Promise<CID[] | null>;
+export declare const getWriteOpLog: (blockstore: IpldStore, earliest: CID | null, latest: CID) => Promise<RecordWriteOp[][]>;
+export declare const diffToWriteOps: (blockstore: IpldStore, diff: DataDiff) => Promise<RecordWriteOp[]>;
+export declare const parseRecordKey: (key: string) => {
+    collection: string;
+    rkey: string;
+};

package/dist/src/verify.d.ts

@@ -0,0 +1,5 @@
+import { CID } from 'multiformats/cid';
+import * as auth from '@atproto/auth';
+import { IpldStore } from './blockstore';
+import { DataDiff } from './mst';
+export declare const verifyUpdates: (blockstore: IpldStore, earliest: CID | null, latest: CID, verifier: auth.Verifier) => Promise<DataDiff>;

package/dist/storage/memory-blockstore.d.ts

@@ -1,5 +1,5 @@
 import { CID } from 'multiformats/cid';
-import { CommitData } from '../types';
+import { CommitData, RebaseData } from '../types';
 import BlockMap from '../block-map';
 import RepoStorage from './repo-storage';
 export declare class MemoryBlockstore extends RepoStorage {
@@ -22,6 +22,7 @@ export declare class MemoryBlockstore extends RepoStorage {
     getBlocksForCommits(commits: CID[]): Promise<{
         [commit: string]: BlockMap;
     }>;
+    applyRebase(rebase: RebaseData): Promise<void>;
     sizeInBytes(): Promise<number>;
     destroy(): Promise<void>;
 }

package/dist/storage/repo-storage.d.ts

@@ -1,6 +1,6 @@
 import { CID } from 'multiformats/cid';
 import BlockMap from '../block-map';
-import { CommitBlockData, CommitData } from '../types';
+import { CommitBlockData, CommitData, RebaseData } from '../types';
 import ReadableBlockstore from './readable-blockstore';
 export declare abstract class RepoStorage extends ReadableBlockstore {
     abstract getHead(forUpdate?: boolean): Promise<CID | null>;
@@ -12,6 +12,7 @@ export declare abstract class RepoStorage extends ReadableBlockstore {
     abstract putMany(blocks: BlockMap): Promise<void>;
     abstract updateHead(cid: CID, prev: CID | null): Promise<void>;
     abstract indexCommits(commit: CommitData[]): Promise<void>;
+    abstract applyRebase(rebase: RebaseData): Promise<void>;
     applyCommit(commit: CommitData): Promise<void>;
     getCommits(latest: CID, earliest: CID | null): Promise<CommitBlockData[] | null>;
 }

package/dist/storage/types.d.ts

@@ -9,6 +9,7 @@ export interface BlobStore {
     unquarantine(cid: CID): Promise<void>;
     getBytes(cid: CID): Promise<Uint8Array>;
     getStream(cid: CID): Promise<stream.Readable>;
+    hasStored(cid: CID): Promise<boolean>;
     delete(cid: CID): Promise<void>;
 }
 export declare class BlobNotFoundError extends Error {

package/dist/sync/consumer.d.ts

@@ -10,6 +10,7 @@ export declare const loadCheckout: (storage: RepoStorage, repoCar: Uint8Array, d
 export declare const loadFullRepo: (storage: RepoStorage, repoCar: Uint8Array, did: string, signingKey: string) => Promise<{
     root: CID;
     writeLog: WriteLog;
+    repo: Repo;
 }>;
 export declare const loadDiff: (repo: Repo, diffCar: Uint8Array, did: string, signingKey: string) => Promise<{
     root: CID;

package/dist/sync/provider.d.ts

@@ -2,8 +2,8 @@ import { RecordPath } from '../types';
 import { BlockWriter } from '@ipld/car/writer';
 import { CID } from 'multiformats/cid';
 import { RepoStorage } from '../storage';
-export declare const getCheckout: (storage: RepoStorage, commitCid: CID) => Promise<Uint8Array>;
-export declare const getDiff: (storage: RepoStorage, latest: CID, earliest: CID | null) => Promise<Uint8Array>;
-export declare const getFullRepo: (storage: RepoStorage, cid: CID) => Promise<Uint8Array>;
+export declare const getCheckout: (storage: RepoStorage, commitCid: CID) => AsyncIterable<Uint8Array>;
+export declare const getCommits: (storage: RepoStorage, latest: CID, earliest: CID | null) => AsyncIterable<Uint8Array>;
+export declare const getFullRepo: (storage: RepoStorage, cid: CID) => AsyncIterable<Uint8Array>;
 export declare const writeCommitsToCarStream: (storage: RepoStorage, car: BlockWriter, latest: CID, earliest: CID | null) => Promise<void>;
-export declare const getRecords: (storage: RepoStorage, commitCid: CID, paths: RecordPath[]) => Promise<Uint8Array>;
+export declare const getRecords: (storage: RepoStorage, commitCid: CID, paths: RecordPath[]) => AsyncIterable<Uint8Array>;