@tanstack/db-sqlite-persistence-core 0.2.23 → 0.4.0

package/dist/cjs/sqlite-core-adapter.d.cts

@@ -1,5 +1,5 @@
 import { LoadSubsetOptions } from '@tanstack/db';
-import { PersistedIndexSpec, PersistedRowScanOptions, PersistedScannedRow, PersistedTx, PersistenceAdapter, ReplayableTxDelta, SQLiteDriver } from './persisted.cjs';
+import { HydrationPersistenceAdapter, PersistedIndexSpec, PersistedKeySetEvidence, PersistedRowScanOptions, PersistedScannedRow, PersistedTx, PersistenceAdapter, ReplayableTxDelta, SQLiteDriver } from './persisted.cjs';
 type SQLiteCoreAdapterSchemaMismatchPolicy = `sync-present-reset` | `sync-absent-error` | `reset`;
 export type SQLiteCoreAdapterOptions = {
     driver: SQLiteDriver;
@@ -33,16 +33,27 @@ export declare const DEFAULT_APPLIED_TX_PRUNE_MAX_ROWS = 1000;
 export declare const DEFAULT_APPLIED_TX_PRUNE_MAX_AGE_SECONDS: number;
 export declare class SQLiteCorePersistenceAdapter implements PersistenceAdapter {
     private readonly driver;
+    private readonly schedulingIdentitySource;
+    private scheduler;
+    private activeUnscheduledHydration;
+    private readonly hydrationAdapter;
     private readonly schemaVersion;
     private readonly schemaMismatchPolicy;
     private readonly appliedTxPruneMaxRows;
     private readonly appliedTxPruneMaxAgeSeconds;
     private readonly pullSinceReloadThreshold;
+    private readonly replacementBatchSize;
     private initialized;
     private readonly collectionTableCache;
     private readonly collectionTableLoads;
     constructor(options: SQLiteCoreAdapterOptions);
+    runInHydrationScope<T>(task: (adapter: HydrationPersistenceAdapter) => Promise<T>): Promise<T>;
+    runInRegularScope<T>(task: (adapter: HydrationPersistenceAdapter) => Promise<T>): Promise<T>;
+    isHydrationScopeScheduled(): boolean;
+    private runRegular;
+    private resolveScheduler;
     private runInTransaction;
+    private assertCurrentSchemaVersion;
     loadSubset(collectionId: string, options: LoadSubsetOptions, ctx?: {
         requiredIndexSignatures?: ReadonlyArray<string>;
     }): Promise<Array<{
@@ -50,20 +61,51 @@ export declare class SQLiteCorePersistenceAdapter implements PersistenceAdapter
         value: Record<string, unknown>;
         metadata?: unknown;
     }>>;
+    private loadSubsetUnscheduled;
+    loadResumeSnapshot(collectionId: string, ctx?: {
+        requiredIndexSignatures?: ReadonlyArray<string>;
+        includeRows?: boolean;
+    }): Promise<{
+        rows: Array<{
+            key: string | number;
+            value: Record<string, unknown>;
+            metadata?: unknown;
+        }>;
+        keySet: PersistedKeySetEvidence;
+        collectionMetadata: Array<{
+            key: string;
+            value: unknown;
+        }>;
+        latestTerm: number;
+        latestSeq: number;
+        latestRowVersion: number;
+        resetEpoch: number;
+    }>;
+    private loadResumeSnapshotUnscheduled;
     applyCommittedTx(collectionId: string, tx: PersistedTx): Promise<void>;
+    private applyCommittedTxUnscheduled;
     loadCollectionMetadata(collectionId: string): Promise<Array<{
         key: string;
         value: unknown;
     }>>;
+    private loadCollectionMetadataUnscheduled;
     scanRows(collectionId: string, options?: PersistedRowScanOptions): Promise<Array<PersistedScannedRow>>;
+    private scanRowsUnscheduled;
     ensureIndex(collectionId: string, signature: string, spec: PersistedIndexSpec): Promise<void>;
+    private ensureIndexUnscheduled;
     markIndexRemoved(collectionId: string, signature: string): Promise<void>;
+    private markIndexRemovedUnscheduled;
     getStreamPosition(collectionId: string): Promise<{
         latestTerm: number;
         latestSeq: number;
         latestRowVersion: number;
     }>;
+    private getStreamPositionUnscheduled;
+    private readLatestRowVersion;
+    private readStreamPosition;
+    private readKeySetEvidence;
     pullSince(collectionId: string, fromRowVersion: number): Promise<SQLitePullSinceResult<string | number>>;
+    private pullSinceUnscheduled;
     private loadSubsetInternal;
     private applyInMemoryWhere;
     private applyInMemoryOrderBy;
@@ -71,7 +113,9 @@ export declare class SQLiteCorePersistenceAdapter implements PersistenceAdapter
     private touchRequiredIndexes;
     private pruneAppliedTxRows;
     private ensureCollectionReady;
+    private loadCollectionRegistration;
     private ensureCollectionReadyInternal;
+    private ensureCollectionKeyEvidenceTriggers;
     private handleSchemaMismatch;
     private ensureInitialized;
 }

package/dist/cjs/sqlite-value.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const errors = require("./errors.cjs");
+const SQLITE_BIGINT_MIN = -9223372036854775808n;
+const SQLITE_BIGINT_MAX = 9223372036854775807n;
+const PERSISTED_TYPE_TAG = `__tanstack_db_persisted_type__`;
+const PERSISTED_VALUE_TAG = `value`;
+function assertSQLiteBigIntInRange(value) {
+  if (value < SQLITE_BIGINT_MIN || value > SQLITE_BIGINT_MAX) {
+    throw new errors.SQLiteBigIntOutOfRangeError(
+      value,
+      SQLITE_BIGINT_MIN,
+      SQLITE_BIGINT_MAX
+    );
+  }
+  return value;
+}
+function serializeSQLiteBigInt(value) {
+  assertSQLiteBigIntInRange(value);
+  return {
+    [PERSISTED_TYPE_TAG]: `bigint`,
+    [PERSISTED_VALUE_TAG]: value.toString()
+  };
+}
+exports.PERSISTED_TYPE_TAG = PERSISTED_TYPE_TAG;
+exports.PERSISTED_VALUE_TAG = PERSISTED_VALUE_TAG;
+exports.SQLITE_BIGINT_MAX = SQLITE_BIGINT_MAX;
+exports.SQLITE_BIGINT_MIN = SQLITE_BIGINT_MIN;
+exports.assertSQLiteBigIntInRange = assertSQLiteBigIntInRange;
+exports.serializeSQLiteBigInt = serializeSQLiteBigInt;
+//# sourceMappingURL=sqlite-value.cjs.map

package/dist/cjs/sqlite-value.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-value.cjs","sources":["../../src/sqlite-value.ts"],"sourcesContent":["import { SQLiteBigIntOutOfRangeError } from './errors'\n\nexport const SQLITE_BIGINT_MIN = -9_223_372_036_854_775_808n\nexport const SQLITE_BIGINT_MAX = 9_223_372_036_854_775_807n\nexport const PERSISTED_TYPE_TAG = `__tanstack_db_persisted_type__`\nexport const PERSISTED_VALUE_TAG = `value`\n\nexport type SerializedSQLiteBigInt = {\n  [PERSISTED_TYPE_TAG]: `bigint`\n  [PERSISTED_VALUE_TAG]: string\n}\n\nexport function assertSQLiteBigIntInRange(value: bigint): bigint {\n  if (value < SQLITE_BIGINT_MIN || value > SQLITE_BIGINT_MAX) {\n    throw new SQLiteBigIntOutOfRangeError(\n      value,\n      SQLITE_BIGINT_MIN,\n      SQLITE_BIGINT_MAX,\n    )\n  }\n  return value\n}\n\nexport function serializeSQLiteBigInt(value: bigint): SerializedSQLiteBigInt {\n  assertSQLiteBigIntInRange(value)\n  return {\n    [PERSISTED_TYPE_TAG]: `bigint`,\n    [PERSISTED_VALUE_TAG]: value.toString(),\n  }\n}\n"],"names":["SQLiteBigIntOutOfRangeError"],"mappings":";;;AAEO,MAAM,oBAAoB,CAAC;AAC3B,MAAM,oBAAoB;AAC1B,MAAM,qBAAqB;AAC3B,MAAM,sBAAsB;AAO5B,SAAS,0BAA0B,OAAuB;AAC/D,MAAI,QAAQ,qBAAqB,QAAQ,mBAAmB;AAC1D,UAAM,IAAIA,OAAAA;AAAAA,MACR;AAAA,MACA;AAAA,MACA;AAAA,IAAA;AAAA,EAEJ;AACA,SAAO;AACT;AAEO,SAAS,sBAAsB,OAAuC;AAC3E,4BAA0B,KAAK;AAC/B,SAAO;AAAA,IACL,CAAC,kBAAkB,GAAG;AAAA,IACtB,CAAC,mBAAmB,GAAG,MAAM,SAAA;AAAA,EAAS;AAE1C;;;;;;;"}

package/dist/cjs/sqlite-value.d.cts

@@ -0,0 +1,10 @@
+export declare const SQLITE_BIGINT_MIN = -9223372036854775808n;
+export declare const SQLITE_BIGINT_MAX = 9223372036854775807n;
+export declare const PERSISTED_TYPE_TAG = "__tanstack_db_persisted_type__";
+export declare const PERSISTED_VALUE_TAG = "value";
+export type SerializedSQLiteBigInt = {
+    [PERSISTED_TYPE_TAG]: `bigint`;
+    [PERSISTED_VALUE_TAG]: string;
+};
+export declare function assertSQLiteBigIntInRange(value: bigint): bigint;
+export declare function serializeSQLiteBigInt(value: bigint): SerializedSQLiteBigInt;

package/dist/esm/broadcast-coordinator.d.ts

@@ -0,0 +1,116 @@
+import { LoadSubsetOptions } from '@tanstack/db';
+import { RemoteSubsetOwner } from './remote-subset-owner.js';
+import { ApplyCommittedTxResponse, ApplyLocalMutationsResponse, HydrationPersistenceAdapter, PersistedCollectionCoordinator, PersistedIndexSpec, PersistedMutationEnvelope, PersistedTx, PersistenceAdapter, ProtocolEnvelope, PullSinceResponse } from './persisted.js';
+type CoordinatorAdapter = Pick<PersistenceAdapter, `loadSubset` | `applyCommittedTx` | `ensureIndex` | `runInRegularScope`> & {
+    pullSince?: (collectionId: string, fromRowVersion: number) => Promise<{
+        latestRowVersion: number;
+        requiresFullReload: true;
+    } | {
+        latestRowVersion: number;
+        requiresFullReload: false;
+        changedKeys: Array<string | number>;
+        deletedKeys: Array<string | number>;
+    }>;
+    getStreamPosition?: (collectionId: string) => Promise<{
+        latestTerm: number;
+        latestSeq: number;
+        latestRowVersion: number;
+    }>;
+};
+/** @internal Shared by the Browser and Electron persistence hosts. */
+export type BroadcastCollectionCoordinatorOptions = {
+    dbName: string;
+    adapter?: CoordinatorAdapter;
+    coordinatorName: string;
+};
+/** @internal Shared coordination engine for BroadcastChannel/Web Locks hosts. */
+export declare class BroadcastCollectionCoordinator implements PersistedCollectionCoordinator {
+    private readonly nodeId;
+    private readonly dbName;
+    private readonly coordinatorName;
+    private defaultAdapter;
+    private readonly collectionAdapters;
+    private readonly remoteSubsetOwners;
+    private readonly remoteSubsetIds;
+    private readonly outboundRemoteSubsetAcquisitions;
+    private readonly inboundRemoteSubsetAcquisitions;
+    private readonly releasedRemoteSubsetAcquisitionTimes;
+    private readonly channel;
+    private readonly collections;
+    private readonly pendingRPCs;
+    private readonly appliedEnvelopes;
+    private readonly inFlightEnvelopes;
+    private appliedEnvelopePruneTimer;
+    private rejectDisposed;
+    private readonly disposedPromise;
+    private disposed;
+    /** Method indirection to prevent TypeScript from narrowing `disposed` across awaits */
+    private isDisposed;
+    /** Method indirection to re-read leadership participation across awaits. */
+    private participatesInLeadership;
+    private requireAdapter;
+    constructor(options: BroadcastCollectionCoordinatorOptions);
+    /**
+     * Set or replace the persistence adapter used for leader-side RPC handling.
+     * Called by a host persistence factory to wire the internally-created adapter.
+     */
+    setAdapter(adapter: CoordinatorAdapter): void;
+    /** Register the persistence adapter that owns one collection. */
+    setAdapterForCollection(collectionId: string, adapter: CoordinatorAdapter): void;
+    registerRemoteSubsetOwner(collectionId: string, owner: RemoteSubsetOwner): () => void;
+    getNodeId(): string;
+    subscribe(collectionId: string, onMessage: (message: ProtocolEnvelope<unknown>) => void): () => void;
+    publish(_collectionId: string, message: ProtocolEnvelope<unknown>): void;
+    isLeader(collectionId: string): boolean;
+    ensureLeadership(collectionId: string): Promise<void>;
+    requestEnsureRemoteSubset(collectionId: string, options: LoadSubsetOptions): Promise<void>;
+    requestReleaseRemoteSubset(collectionId: string, options: LoadSubsetOptions): Promise<void>;
+    private acquireRemoteSubset;
+    requestEnsurePersistedIndex(collectionId: string, signature: string, spec: PersistedIndexSpec, scopedAdapter?: HydrationPersistenceAdapter, localEnsureCompleted?: boolean): Promise<void>;
+    requestApplyLocalMutations(collectionId: string, mutations: Array<PersistedMutationEnvelope>): Promise<ApplyLocalMutationsResponse>;
+    requestApplyCommittedTx(collectionId: string, tx: PersistedTx, scopedAdapter?: HydrationPersistenceAdapter): Promise<ApplyCommittedTxResponse>;
+    pullSince(collectionId: string, fromRowVersion: number, scopedAdapter?: HydrationPersistenceAdapter): Promise<PullSinceResponse>;
+    dispose(): void;
+    private getOrCreateCollectionState;
+    private ensureCollectionState;
+    private acquireLeadership;
+    private waitForInitialRoute;
+    private waitForLeadershipRoute;
+    private notifyRouteWaiters;
+    private releaseLeadership;
+    private releaseCollectionIfUnused;
+    private postRemoteSubsetRelease;
+    private cancelRemoteSubsetReplayRetry;
+    private scheduleRemoteSubsetReplayRetry;
+    private replayRemoteSubsetAcquisitions;
+    private emitHeartbeat;
+    private onChannelMessage;
+    private sendRPC;
+    private captureMutationRoute;
+    private assertMutationRouteUnchanged;
+    private sendRPCOnce;
+    private handleRPCRequest;
+    private dispatchRPCRequest;
+    private handleEnsureRemoteSubset;
+    private handleReleaseRemoteSubset;
+    private releaseRemoteSubsetAcquisition;
+    private releaseInboundRemoteSubsetAcquisitions;
+    private rebindRemoteInboundSubsetAcquisitions;
+    private rebindRemoteInboundSubsetAcquisition;
+    private bindAwaitingRemoteSubsetAcquisition;
+    private startRemoteSubsetOwnerAcquisition;
+    private handleEnsurePersistedIndex;
+    private handleApplyLocalMutations;
+    private applyLocalMutationsOnce;
+    private handleApplyCommittedTx;
+    private runDeduplicatedEnvelope;
+    private applyCommittedTxOnce;
+    private applyDurablyAtNextStreamPosition;
+    private handlePullSince;
+    private withScheduledWriterLock;
+    private withWriterLock;
+    private pruneAppliedEnvelopes;
+    private setReleasedRemoteSubsetAcquisition;
+    private pruneReleasedRemoteSubsetAcquisitions;
+}
+export {};