@atproto/repo 0.2.0 → 0.3.0

package/dist/src/mst/mst.d.ts

@@ -1,106 +0,0 @@
-import z from 'zod';
-import { CID } from 'multiformats';
-import IpldStore from '../blockstore/ipld-store';
-import { DataDiff } from './diff';
-import { DataStore } from '../types';
-import { BlockWriter } from '@ipld/car/api';
-export declare const nodeDataDef: z.ZodObject<{
-    l: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
-    e: z.ZodArray<z.ZodObject<{
-        p: z.ZodNumber;
-        k: z.ZodString;
-        v: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
-        t: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
-    }, "strip", z.ZodTypeAny, {
-        t: CID | null;
-        p: number;
-        k: string;
-        v: CID;
-    }, {
-        t?: any;
-        v?: any;
-        p: number;
-        k: string;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    l: CID | null;
-    e: {
-        t: CID | null;
-        p: number;
-        k: string;
-        v: CID;
-    }[];
-}, {
-    l?: any;
-    e: {
-        t?: any;
-        v?: any;
-        p: number;
-        k: string;
-    }[];
-}>;
-export declare type NodeData = z.infer<typeof nodeDataDef>;
-export declare type NodeEntry = MST | Leaf;
-export declare type Fanout = 2 | 8 | 16 | 32 | 64;
-export declare type MstOpts = {
-    layer: number;
-    fanout: Fanout;
-};
-export declare class MST implements DataStore {
-    blockstore: IpldStore;
-    fanout: Fanout;
-    entries: NodeEntry[] | null;
-    layer: number | null;
-    pointer: CID;
-    outdatedPointer: boolean;
-    constructor(blockstore: IpldStore, fanout: Fanout, pointer: CID, entries: NodeEntry[] | null, layer: number | null);
-    static create(blockstore: IpldStore, entries?: NodeEntry[], opts?: Partial<MstOpts>): Promise<MST>;
-    static fromData(blockstore: IpldStore, data: NodeData, opts?: Partial<MstOpts>): Promise<MST>;
-    static load(blockstore: IpldStore, cid: CID, opts?: Partial<MstOpts>): MST;
-    newTree(entries: NodeEntry[]): Promise<MST>;
-    getEntries(): Promise<NodeEntry[]>;
-    getPointer(): Promise<CID>;
-    getLayer(): Promise<number>;
-    attemptGetLayer(): Promise<number | null>;
-    stage(): Promise<CID>;
-    stageRecurse(trimTop?: boolean): Promise<CID>;
-    add(key: string, value: CID, knownZeros?: number): Promise<MST>;
-    get(key: string): Promise<CID | null>;
-    update(key: string, value: CID): Promise<MST>;
-    delete(key: string): Promise<MST>;
-    diff(other: MST): Promise<DataDiff>;
-    updateEntry(index: number, entry: NodeEntry): Promise<MST>;
-    removeEntry(index: number): Promise<MST>;
-    append(entry: NodeEntry): Promise<MST>;
-    prepend(entry: NodeEntry): Promise<MST>;
-    atIndex(index: number): Promise<NodeEntry | null>;
-    slice(start?: number | undefined, end?: number | undefined): Promise<NodeEntry[]>;
-    spliceIn(entry: NodeEntry, index: number): Promise<MST>;
-    replaceWithSplit(index: number, left: MST | null, leaf: Leaf, right: MST | null): Promise<MST>;
-    splitAround(key: string): Promise<[MST | null, MST | null]>;
-    appendMerge(toMerge: MST): Promise<MST>;
-    createChild(): Promise<MST>;
-    createParent(): Promise<MST>;
-    findGtOrEqualLeafIndex(key: string): Promise<number>;
-    walkLeavesFrom(key: string): AsyncIterable<Leaf>;
-    list(count: number, after?: string, before?: string): Promise<Leaf[]>;
-    listWithPrefix(prefix: string, count?: number): Promise<Leaf[]>;
-    walk(): AsyncIterable<NodeEntry>;
-    paths(): Promise<NodeEntry[][]>;
-    allNodes(): Promise<NodeEntry[]>;
-    leaves(): Promise<Leaf[]>;
-    leafCount(): Promise<number>;
-    writeToCarStream(car: BlockWriter): Promise<void>;
-    isTree(): this is MST;
-    isLeaf(): this is Leaf;
-    equals(other: NodeEntry): Promise<boolean>;
-}
-export declare class Leaf {
-    key: string;
-    value: CID;
-    constructor(key: string, value: CID);
-    isTree(): this is MST;
-    isLeaf(): this is Leaf;
-    equals(entry: NodeEntry): boolean;
-}
-export default MST;

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

@@ -1,9 +0,0 @@
-import { CID } from 'multiformats';
-import IpldStore from '../blockstore/ipld-store';
-import { NodeEntry, NodeData, MstOpts, Fanout } from './mst';
-export declare const leadingZerosOnHash: (key: string, fanout: Fanout) => Promise<number>;
-export declare const layerForEntries: (entries: NodeEntry[], fanout: Fanout) => Promise<number | null>;
-export declare const deserializeNodeData: (blockstore: IpldStore, data: NodeData, opts?: Partial<MstOpts>) => Promise<NodeEntry[]>;
-export declare const serializeNodeData: (entries: NodeEntry[]) => NodeData;
-export declare const countPrefixLen: (a: string, b: string) => number;
-export declare const cidForEntries: (entries: NodeEntry[]) => Promise<CID>;

package/dist/src/mst/walker.d.ts

@@ -1,22 +0,0 @@
-import { MST, NodeEntry } from './mst';
-declare type WalkerStatusDone = {
-    done: true;
-};
-declare type WalkerStatusProgress = {
-    done: false;
-    curr: NodeEntry;
-    walking: MST | null;
-    index: number;
-};
-declare type WalkerStatus = WalkerStatusDone | WalkerStatusProgress;
-export declare class MstWalker {
-    root: MST;
-    stack: WalkerStatus[];
-    status: WalkerStatus;
-    constructor(root: MST);
-    layer(): number;
-    stepOver(): Promise<void>;
-    stepInto(): Promise<void>;
-    advance(): Promise<void>;
-}
-export default MstWalker;

package/dist/src/parse.d.ts

@@ -1,11 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

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

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

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

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

@@ -1,28 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,12 +0,0 @@
-/// <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

@@ -1,17 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

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

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

@@ -1,13 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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/sync.d.ts

@@ -1,9 +0,0 @@
-import * as auth from '@atproto/auth';
-import { IpldStore } from './blockstore';
-import { DataDiff } from './mst';
-import Repo from './repo';
-export declare const loadRepoFromCar: (carBytes: Uint8Array, blockstore: IpldStore, verifier: auth.Verifier) => Promise<Repo>;
-export declare const loadDiff: (repo: Repo, diffCar: Uint8Array, verifier: auth.Verifier) => Promise<{
-    repo: Repo;
-    diff: DataDiff;
-}>;