@atproto/repo 0.0.1 → 0.2.0

package/dist/src/parse.d.ts

@@ -0,0 +1,11 @@
+import { check } from '@atproto/common';
+import { CID } from 'multiformats/cid';
+import BlockMap from './block-map';
+export declare const getAndParse: <T>(blocks: BlockMap, cid: CID, def: check.Def<T>) => Promise<{
+    obj: T;
+    bytes: Uint8Array;
+}>;
+export declare const parseObj: <T>(bytes: Uint8Array, cid: CID, def: check.Def<T>) => {
+    obj: T;
+    bytes: Uint8Array;
+};

package/dist/src/readable-repo.d.ts

@@ -0,0 +1,25 @@
+import { CID } from 'multiformats/cid';
+import { RepoRoot, Commit, DataStore, RepoMeta, RepoContents } from './types';
+import { ReadableBlockstore } from './storage';
+declare type Params = {
+    storage: ReadableBlockstore;
+    data: DataStore;
+    commit: Commit;
+    root: RepoRoot;
+    meta: RepoMeta;
+    cid: CID;
+};
+export declare class ReadableRepo {
+    storage: ReadableBlockstore;
+    data: DataStore;
+    commit: Commit;
+    root: RepoRoot;
+    meta: RepoMeta;
+    cid: CID;
+    constructor(params: Params);
+    static load(storage: ReadableBlockstore, commitCid: CID): Promise<ReadableRepo>;
+    get did(): string;
+    getRecord(collection: string, rkey: string): Promise<unknown | null>;
+    getContents(): Promise<RepoContents>;
+}
+export default ReadableRepo;

package/dist/src/repo.d.ts

@@ -0,0 +1,39 @@
+import { CID } from 'multiformats/cid';
+import { BlockWriter } from '@ipld/car/writer';
+import { RepoRoot, Commit, DataStore, RepoMeta, RecordCreateOp, RecordWriteOp } 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: RecordWriteOp[];
+};
+export declare class Repo {
+    blockstore: IpldStore;
+    data: DataStore;
+    commit: Commit;
+    root: RepoRoot;
+    meta: RepoMeta;
+    cid: CID;
+    stagedWrites: RecordWriteOp[];
+    constructor(params: Params);
+    static create(blockstore: IpldStore, did: string, authStore: auth.AuthStore, initialRecords?: RecordCreateOp[]): Promise<Repo>;
+    static load(blockstore: IpldStore, cid: CID): Promise<Repo>;
+    private updateRepo;
+    get did(): string;
+    getRecord(collection: string, rkey: string): Promise<unknown | null>;
+    stageUpdate(write: RecordWriteOp | RecordWriteOp[]): Repo;
+    createCommit(authStore: auth.AuthStore, performUpdate?: (prev: CID, curr: CID) => Promise<CID | null>): Promise<Repo>;
+    revert(count: number): Promise<Repo>;
+    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 Repo;

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

@@ -0,0 +1,22 @@
+import { Def } from '@atproto/common/src/check';
+import { CID } from 'multiformats/cid';
+export declare class MissingBlockError extends Error {
+    cid: CID;
+    def?: Def<unknown> | undefined;
+    constructor(cid: CID, def?: Def<unknown> | undefined);
+}
+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: Def<unknown>;
+    constructor(cid: CID, def: Def<unknown>);
+}

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

@@ -0,0 +1 @@
+export * from './types';

package/dist/src/storage/memory-blobstore.d.ts

@@ -0,0 +1 @@
+export declare const thing = 1;

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

@@ -0,0 +1,28 @@
+import { CID } from 'multiformats/cid';
+import { CommitData } from '../types';
+import BlockMap from '../block-map';
+import RepoStorage from './repo-storage';
+export declare class MemoryBlockstore extends RepoStorage {
+    blocks: BlockMap;
+    head: CID | null;
+    constructor(blocks?: BlockMap);
+    getHead(): Promise<CID | null>;
+    getBytes(cid: CID): Promise<Uint8Array | null>;
+    has(cid: CID): Promise<boolean>;
+    getBlocks(cids: CID[]): Promise<{
+        blocks: BlockMap;
+        missing: CID[];
+    }>;
+    putBlock(cid: CID, block: Uint8Array): Promise<void>;
+    putMany(blocks: BlockMap): Promise<void>;
+    indexCommits(commits: CommitData[]): Promise<void>;
+    updateHead(cid: CID, _prev: CID | null): Promise<void>;
+    applyCommit(commit: CommitData): Promise<void>;
+    getCommitPath(latest: CID, earliest: CID | null): Promise<CID[] | null>;
+    getBlocksForCommits(commits: CID[]): Promise<{
+        [commit: string]: BlockMap;
+    }>;
+    sizeInBytes(): Promise<number>;
+    destroy(): Promise<void>;
+}
+export default MemoryBlockstore;

package/dist/src/storage/readable-blockstore.d.ts

@@ -0,0 +1,21 @@
+import { check } from '@atproto/common';
+import { CID } from 'multiformats/cid';
+import BlockMap from '../block-map';
+export declare abstract class ReadableBlockstore {
+    abstract getBytes(cid: CID): Promise<Uint8Array | null>;
+    abstract has(cid: CID): Promise<boolean>;
+    abstract getBlocks(cids: CID[]): Promise<{
+        blocks: BlockMap;
+        missing: CID[];
+    }>;
+    attemptRead<T>(cid: CID, def: check.Def<T>): Promise<{
+        obj: T;
+        bytes: Uint8Array;
+    } | null>;
+    readObjAndBytes<T>(cid: CID, def: check.Def<T>): Promise<{
+        obj: T;
+        bytes: Uint8Array;
+    }>;
+    readObj<T>(cid: CID, def: check.Def<T>): Promise<T>;
+}
+export default ReadableBlockstore;

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

@@ -0,0 +1,18 @@
+import { CID } from 'multiformats/cid';
+import BlockMap from '../block-map';
+import { CommitBlockData, CommitData } from '../types';
+import ReadableBlockstore from './readable-blockstore';
+export declare abstract class RepoStorage extends ReadableBlockstore {
+    abstract getHead(forUpdate?: boolean): Promise<CID | null>;
+    abstract getCommitPath(latest: CID, earliest: CID | null): Promise<CID[] | null>;
+    abstract getBlocksForCommits(commits: CID[]): Promise<{
+        [commit: string]: BlockMap;
+    }>;
+    abstract putBlock(cid: CID, block: Uint8Array): Promise<void>;
+    abstract putMany(blocks: BlockMap): Promise<void>;
+    abstract updateHead(cid: CID, prev: CID | null): Promise<void>;
+    abstract indexCommits(commit: CommitData[]): Promise<void>;
+    applyCommit(commit: CommitData): Promise<void>;
+    getCommits(latest: CID, earliest: CID | null): Promise<CommitBlockData[] | null>;
+}
+export default RepoStorage;

package/dist/src/storage/sync-storage.d.ts

@@ -0,0 +1,15 @@
+import { CID } from 'multiformats/cid';
+import BlockMap from '../block-map';
+import ReadableBlockstore from './readable-blockstore';
+export declare class SyncStorage extends ReadableBlockstore {
+    staged: ReadableBlockstore;
+    saved: ReadableBlockstore;
+    constructor(staged: ReadableBlockstore, saved: ReadableBlockstore);
+    getBytes(cid: CID): Promise<Uint8Array | null>;
+    getBlocks(cids: CID[]): Promise<{
+        blocks: BlockMap;
+        missing: CID[];
+    }>;
+    has(cid: CID): Promise<boolean>;
+}
+export default SyncStorage;

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

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import stream from 'stream';
+import { CID } from 'multiformats/cid';
+export interface BlobStore {
+    putTemp(bytes: Uint8Array | stream.Readable): Promise<string>;
+    makePermanent(key: string, cid: CID): Promise<void>;
+    putPermanent(cid: CID, bytes: Uint8Array | stream.Readable): Promise<void>;
+    getBytes(cid: CID): Promise<Uint8Array>;
+    getStream(cid: CID): Promise<stream.Readable>;
+}
+export declare class BlobNotFoundError extends Error {
+}

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>;