@minnowdb/core 0.2.1 → 0.4.0

package/dist/storage/memory.d.ts

@@ -1,5 +1,4 @@
-import { type BeginTransactionInput, type BeginTransactionResult, type CommitTransactionInput, type CompactionJobRecord, type CompactionJobRecordUpdate, type CreateGarbageCollectionJobInput, type BlockStore, type CatalogProbe, type TriggerRecord, type BlockWrite, type FtsCandidates, type FtsColumnIndexRecord, type FtsPosting, type GarbageCollectionJobRecord, type GarbageCollectionStepResult, type LeaseRecord, type Manifest, type ManifestSummary, type PublishManifestInput, type QueryCatalogState, type RowIdRange, type RunGarbageCollectionStepInput, type SegmentRecord, type StageTransactionArtifactsInput, type StoragePage, type TableColumnRecord, type TableRecord, type TempOwnerRecord, type TempRunPage, type TransactionRecord, type TransactionRecordUpdate, type WriteTransactionInput } from "./types.js";
-import type { DatabaseSnapshot, SnapshotLoadProgress } from "./snapshot.js";
+import { type BeginSnapshotFrameExportInput, type SnapshotFrameExportSession, type ReadSnapshotExportFrameInput, type BeginSnapshotFrameImportInput, type SnapshotFrameImportSession, type RenewSnapshotFrameImportInput, type AppendSnapshotImportFramesInput, type FinishSnapshotFrameImportInput, type SnapshotFrame, type BeginTransactionInput, type BeginTransactionResult, type AbortTransactionIfExpiredInput, type CommitTransactionInput, type CloseSnapshotExportInput, type CompactionJobRecord, type CompactionJobRecordUpdate, type CreateGarbageCollectionJobInput, type UpdateGarbageCollectionPlanningInput, type DropTableColumnInput, type DropTableInput, type BlockStore, type AdoptAbortedSegmentInput, type CatalogProbe, type QueryCatalogState, type CatalogMutationOptions, type CancelSnapshotImportInput, type FtsCandidates, type FtsPostingQuery, type FtsPosting, type BeginPostingBuildInput, type RenewPostingBuildInput, type AppendPostingBuildChunkInput, type FinishPostingBuildInput, type AbortPostingBuildInput, type GarbageCollectionJobRecord, type GarbageCollectionStepResult, type LeaseRecord, type MoveLeaseInput, type Manifest, type ManifestSummary, type RowIdRange, type RollbackTransactionArtifactsInput, type RenewLeaseInput, type RenewTempOwnerInput, type RenewTransactionInput, type RunGarbageCollectionStepInput, type SegmentRecord, type InterruptedSnapshotImport, type InterruptedSnapshotImportAbortResult, type StageTransactionArtifactsInput, type StoragePage, type StorageStats, type TableRecord, type TableRecordUpdate, type TempOwnerRecord, type TempRunPage, type TransactionRecord, type TransactionRecordUpdate, type WriteTransactionInput, type BeginUniqueKeyBuildInput, type RenewUniqueKeyBuildInput, type AppendUniqueKeyBuildChunkInput, type FinishUniqueKeyBuildInput, type AbortUniqueKeyBuildInput, type UniqueKeyBuildRecord } from "./types.js";
 /**
  * The in-process store: record semantics live in `RecordCore` (shared with the OPFS store),
  * block and temp-page bytes live in Maps here, and atomicity comes from running every mutating
@@ -8,12 +7,10 @@ import type { DatabaseSnapshot, SnapshotLoadProgress } from "./snapshot.js";
  */
 export declare class MemoryBlockStore implements BlockStore {
     #private;
-    addBlock(id: string, bytes: Uint8Array): Promise<void>;
-    addBlocks(blocks: readonly BlockWrite[]): Promise<void>;
     getBlock(id: string): Promise<Uint8Array | undefined>;
     getBlocks(ids: readonly string[]): Promise<Array<Uint8Array | undefined>>;
-    removeBlock(id: string): Promise<void>;
-    listBlockIds(): Promise<string[]>;
+    readManifestBlock(version: number | null, id: string): Promise<Uint8Array | undefined>;
+    hasManifestBlocks(version: number | null, ids: readonly string[]): Promise<boolean[]>;
     putTempRunPage(page: TempRunPage): Promise<void>;
     putTempRunPages(pages: readonly TempRunPage[]): Promise<void>;
     getTempRunPage(ownerId: string, runId: string, pageIndex: number): Promise<Uint8Array | undefined>;
@@ -21,104 +18,114 @@ export declare class MemoryBlockStore implements BlockStore {
     removeTempOwner(ownerId: string): Promise<void>;
     createTempOwner(record: TempOwnerRecord): Promise<void>;
     getTempOwner(ownerId: string): Promise<TempOwnerRecord | undefined>;
-    renewTempOwner(ownerId: string, expectedRevision: number, expiresAt: string): Promise<TempOwnerRecord>;
+    renewTempOwner(input: RenewTempOwnerInput): Promise<TempOwnerRecord>;
     removeTempOwnerIfExpired(ownerId: string, expiresAtCutoff: string): Promise<boolean>;
     listTempOwnerIdsPage(afterOwnerId: string | null, limit: number): Promise<StoragePage<string, string>>;
-    addTable(record: TableRecord): Promise<void>;
+    listExpiredTempOwnerPage(expiresAtCutoff: string, afterCursor: string | null, limit: number): Promise<StoragePage<string, string>>;
+    addTable(record: TableRecord, options?: CatalogMutationOptions): Promise<void>;
     getTable(id: string): Promise<TableRecord | undefined>;
-    updateTable(id: string, expectedRevision: number, update: {
-        columns?: TableColumnRecord[];
-        ftsColumns?: Record<string, FtsColumnIndexRecord> | null;
-        triggers?: TriggerRecord[] | null;
-    }): Promise<TableRecord>;
-    removeTable(id: string, expectedRevision: number): Promise<void>;
+    updateTable(id: string, expectedRevision: number, update: TableRecordUpdate): Promise<TableRecord>;
+    removeTable(id: string, expectedRevision: number, options?: CatalogMutationOptions): Promise<void>;
+    dropTable(input: DropTableInput): Promise<ManifestSummary>;
+    dropTableColumn(input: DropTableColumnInput): Promise<ManifestSummary>;
     writeFtsBase(tableId: string, columnId: string, input: {
         coversVersion: number;
         chunks: FtsPosting[][];
         totalTokens: number;
     }): Promise<void>;
-    readFtsCandidates(tableId: string, columnId: string, terms: ReadonlyArray<{
-        term: string;
-        prefix: boolean;
-    }>, upToVersion: number): Promise<FtsCandidates & {
+    removeFtsColumn(tableId: string, columnId: string): Promise<void>;
+    beginFtsBaseBuild(input: BeginPostingBuildInput): Promise<void>;
+    renewFtsBaseBuild(input: RenewPostingBuildInput): Promise<void>;
+    writeFtsBaseBuildChunk(input: AppendPostingBuildChunkInput): Promise<void>;
+    finishFtsBaseBuild(input: FinishPostingBuildInput): Promise<void>;
+    abortFtsBaseBuild(input: AbortPostingBuildInput): Promise<void>;
+    readFtsCandidates(tableId: string, columnId: string, terms: readonly FtsPostingQuery[], upToVersion: number, maxRowIds?: number): Promise<FtsCandidates & {
         deltaChunkCount: number;
         totalTokens: number;
         coversVersion: number;
+        hasBase: boolean;
+    }>;
+    readFtsPostings(tableId: string, columnId: string, upToVersion: number, maxRowIds?: number, maxRetainedBytes?: number): Promise<{
+        postings: FtsPosting[];
+        overflow: boolean;
+        deltaChunkCount: number;
+        coversVersion: number;
+        hasBase: boolean;
     }>;
     getTableByName(name: string): Promise<TableRecord | undefined>;
     listTables(): Promise<TableRecord[]>;
-    addSegment(record: SegmentRecord): Promise<void>;
     getSegment(id: string): Promise<SegmentRecord | undefined>;
-    listSegments(tableId?: string): Promise<SegmentRecord[]>;
-    removeSegment(id: string): Promise<void>;
+    listSegmentPage(afterId: string | null, limit: number): Promise<StoragePage<SegmentRecord, string>>;
+    listTableSegmentPage(tableId: string, afterId: string | null, limit: number): Promise<StoragePage<SegmentRecord, string>>;
+    removeAbortedSegment(id: string, expectedTransactionId: string): Promise<boolean>;
+    adoptAbortedSegment(input: AdoptAbortedSegmentInput): Promise<TransactionRecord>;
     reserveRowIds(tableId: string, count: number): Promise<RowIdRange>;
     reserveAutoIncrement(tableId: string, columnId: string, count: number, atLeast?: bigint): Promise<RowIdRange>;
     getExistingUniqueKeys(tableId: string, keyTokens: readonly string[]): Promise<string[]>;
+    beginUniqueKeyBuild(input: BeginUniqueKeyBuildInput): Promise<UniqueKeyBuildRecord>;
+    getUniqueKeyBuild(buildId: string): Promise<UniqueKeyBuildRecord | undefined>;
+    renewUniqueKeyBuild(input: RenewUniqueKeyBuildInput): Promise<UniqueKeyBuildRecord>;
+    appendUniqueKeyBuildChunk(input: AppendUniqueKeyBuildChunkInput): Promise<UniqueKeyBuildRecord>;
+    finishUniqueKeyBuild(input: FinishUniqueKeyBuildInput): Promise<TableRecord>;
+    abortUniqueKeyBuild(input: AbortUniqueKeyBuildInput): Promise<boolean>;
     getCurrentManifestVersion(): Promise<number | null>;
     getCatalogProbe(): Promise<CatalogProbe>;
-    /**
-     * Composed over this store's own methods rather than delegated to the core, so a subclass
-     * that instruments `getTransactions` or `listSegments` observes these internal reads too —
-     * the engine's read-count tests rely on that.
-     */
-    getQueryCatalogState(tableNames: readonly string[]): Promise<QueryCatalogState>;
+    getQueryCatalogState(names: readonly string[]): Promise<QueryCatalogState>;
     getCurrentManifest(): Promise<Manifest | undefined>;
     getManifest(version: number): Promise<Manifest | undefined>;
-    listManifests(): Promise<Manifest[]>;
-    listManifestPage(afterVersion: number | null, limit: number): Promise<StoragePage<Manifest, number>>;
-    publishManifest(input: PublishManifestInput): Promise<Manifest>;
+    listManifestBlockPage(input: Parameters<BlockStore["listManifestBlockPage"]>[0]): Promise<import("./types.js").ManifestBlockPage>;
+    listRetiredManifestBlockPage(input: Parameters<BlockStore["listRetiredManifestBlockPage"]>[0]): Promise<import("./types.js").ManifestBlockPage>;
+    listManifestPage(afterVersion: number | null, limit: number): Promise<StoragePage<ManifestSummary, number>>;
     beginTransaction(input: BeginTransactionInput): Promise<BeginTransactionResult>;
     createTransaction(record: TransactionRecord): Promise<void>;
     getTransaction(id: string): Promise<TransactionRecord | undefined>;
     getTransactions(ids: readonly string[]): Promise<Array<TransactionRecord | undefined>>;
-    listTransactions(): Promise<TransactionRecord[]>;
     listTransactionPage(afterId: string | null, limit: number): Promise<StoragePage<TransactionRecord, string>>;
     updateTransaction(id: string, expectedRevision: number, update: TransactionRecordUpdate): Promise<TransactionRecord>;
+    renewTransaction(input: RenewTransactionInput): Promise<boolean>;
+    abortTransactionIfExpired(input: AbortTransactionIfExpiredInput): Promise<TransactionRecord | undefined>;
     stageTransactionArtifacts(input: StageTransactionArtifactsInput): Promise<TransactionRecord>;
+    rollbackTransactionArtifacts(input: RollbackTransactionArtifactsInput): Promise<TransactionRecord>;
     commitTransaction(input: CommitTransactionInput): Promise<ManifestSummary>;
     writeTransaction(input: WriteTransactionInput): Promise<ManifestSummary>;
     createLease(record: LeaseRecord): Promise<void>;
     getLease(id: string): Promise<LeaseRecord | undefined>;
     listLeases(): Promise<LeaseRecord[]>;
-    renewLease(id: string, expectedRevision: number, expiresAt: string): Promise<LeaseRecord>;
-    moveLease(id: string, expectedRevision: number, manifestVersion: number | null, expiresAt: string): Promise<LeaseRecord>;
+    listExpiredLeasePage(expiresAtCutoff: string, afterCursor: string | null, limit: number): Promise<StoragePage<LeaseRecord, string>>;
+    renewLease(input: RenewLeaseInput): Promise<LeaseRecord>;
+    moveLease(input: MoveLeaseInput): Promise<LeaseRecord>;
     removeLeaseIfExpired(id: string, expectedRevision: number, expiresAtCutoff: string): Promise<boolean>;
-    removeLease(id: string): Promise<void>;
+    removeLease(input: {
+        id: string;
+        ownerId: string;
+    }): Promise<boolean>;
     createCompactionJob(record: CompactionJobRecord): Promise<void>;
     getCompactionJob(id: string): Promise<CompactionJobRecord | undefined>;
     listCompactionJobs(tableId?: string): Promise<CompactionJobRecord[]>;
     listCompactionJobPage(afterId: string | null, limit: number): Promise<StoragePage<CompactionJobRecord, string>>;
     updateCompactionJob(id: string, expectedRevision: number, update: CompactionJobRecordUpdate): Promise<CompactionJobRecord>;
     cancelCompactionJob(id: string, expectedRevision: number, cancelledAt: string): Promise<CompactionJobRecord>;
-    removeCompactionJob(id: string): Promise<void>;
+    removeCompactionJob(id: string): Promise<boolean>;
     createGarbageCollectionJob(input: CreateGarbageCollectionJobInput): Promise<GarbageCollectionJobRecord>;
+    updateGarbageCollectionPlanning(input: UpdateGarbageCollectionPlanningInput): Promise<GarbageCollectionJobRecord>;
     getGarbageCollectionJob(id: string): Promise<GarbageCollectionJobRecord | undefined>;
     listGarbageCollectionJobs(): Promise<GarbageCollectionJobRecord[]>;
+    listGarbageCollectionJobPage(afterId: string | null, limit: number): Promise<StoragePage<GarbageCollectionJobRecord, string>>;
     runGarbageCollectionStep(input: RunGarbageCollectionStepInput): Promise<GarbageCollectionStepResult>;
-    removePrunedManifestRecords(): Promise<number>;
+    removePrunedManifestRecords(maxItems: number): Promise<number>;
     removeGarbageCollectionJob(id: string): Promise<void>;
-    /**
-     * Copies the current version out as a portable snapshot. Runs on the commit queue, so it sees
-     * one consistent version rather than a commit in progress. What the snapshot carries and
-     * drops is `RecordCore.exportSnapshot`'s contract.
-     */
-    exportSnapshot(): Promise<DatabaseSnapshot>;
-    /**
-     * Loads a snapshot into this store, which must be empty — the same contract as the IndexedDB
-     * store, so a caller holding a `BlockStore` can restore into either without asking which it
-     * has. The load runs on the commit queue, so it cannot interleave with a commit.
-     *
-     * Progress is reported for parity with the IndexedDB store rather than because it is needed:
-     * an in-memory load is a handful of map writes with no transaction to break it into, so it
-     * reports the start and then the end.
-     */
-    importSnapshot(snapshot: DatabaseSnapshot, options?: {
-        onProgress?: (progress: SnapshotLoadProgress) => void;
-    }): Promise<void>;
-    /** Builds a store holding exactly what the snapshot captured. */
-    static fromSnapshot(snapshot: DatabaseSnapshot): MemoryBlockStore;
+    beginSnapshotFrameExport(input: BeginSnapshotFrameExportInput): Promise<SnapshotFrameExportSession>;
+    readSnapshotExportFrame(input: ReadSnapshotExportFrameInput): Promise<SnapshotFrame | undefined>;
+    closeSnapshotFrameExport(input: CloseSnapshotExportInput): Promise<boolean>;
+    beginSnapshotFrameImport(input: BeginSnapshotFrameImportInput): Promise<SnapshotFrameImportSession>;
+    renewSnapshotFrameImport(input: RenewSnapshotFrameImportInput): Promise<SnapshotFrameImportSession>;
+    appendSnapshotImportFrames(input: AppendSnapshotImportFramesInput): Promise<SnapshotFrameImportSession>;
+    finishSnapshotFrameImport(input: FinishSnapshotFrameImportInput): Promise<void>;
+    cancelSnapshotFrameImport(input: CancelSnapshotImportInput): Promise<InterruptedSnapshotImportAbortResult>;
+    inspectInterruptedImport(): Promise<InterruptedSnapshotImport | null>;
+    abortInterruptedImport(identity: string): Promise<InterruptedSnapshotImportAbortResult>;
     /** Block and spill bytes held; the record maps are negligible beside them. */
     getLogicalStorageBytes(): Promise<number>;
+    getStorageStats(): Promise<StorageStats>;
     close(): void;
 }
-//# sourceMappingURL=memory.d.ts.map