@tanstack/db-sqlite-persistence-core 0.1.6 → 0.1.8

package/src/persisted.ts

@@ -199,7 +199,7 @@ export type ReplayableTxDelta<
 }
 
 export type PersistedScannedRow<
-  T extends object,
+  T extends object = Record<string, unknown>,
   TKey extends string | number = string | number,
 > = {
   key: TKey
@@ -212,7 +212,7 @@ export type PersistedRowScanOptions = {
 }
 
 export type PersistedTx<
-  T extends object,
+  T extends object = Record<string, unknown>,
   TKey extends string | number = string | number,
 > = {
   txId: string
@@ -241,26 +241,26 @@ export type PersistedTx<
   collectionMetadataMutations?: Array<PersistedCollectionMetadataMutation>
 }
 
-export interface PersistenceAdapter<
-  T extends object,
-  TKey extends string | number = string | number,
-> {
+export interface PersistenceAdapter {
   loadSubset: (
     collectionId: string,
     options: LoadSubsetOptions,
     ctx?: { requiredIndexSignatures?: ReadonlyArray<string> },
-  ) => Promise<Array<{ key: TKey; value: T; metadata?: unknown }>>
-  applyCommittedTx: (
-    collectionId: string,
-    tx: PersistedTx<T, TKey>,
-  ) => Promise<void>
+  ) => Promise<
+    Array<{
+      key: string | number
+      value: Record<string, unknown>
+      metadata?: unknown
+    }>
+  >
+  applyCommittedTx: (collectionId: string, tx: PersistedTx) => Promise<void>
   loadCollectionMetadata?: (
     collectionId: string,
   ) => Promise<Array<{ key: string; value: unknown }>>
   scanRows?: (
     collectionId: string,
     options?: PersistedRowScanOptions,
-  ) => Promise<Array<PersistedScannedRow<T, TKey>>>
+  ) => Promise<Array<PersistedScannedRow>>
   ensureIndex: (
     collectionId: string,
     signature: string,
@@ -317,26 +317,20 @@ export interface PersistedCollectionCoordinator {
   ) => Promise<PullSinceResponse>
 }
 
-export interface PersistedCollectionPersistence<
-  T extends object,
-  TKey extends string | number = string | number,
-> {
-  adapter: PersistenceAdapter<T, TKey>
+export interface PersistedCollectionPersistence {
+  adapter: PersistenceAdapter
   coordinator?: PersistedCollectionCoordinator
   resolvePersistenceForCollection?: (options: {
     collectionId: string
     mode: PersistedCollectionMode
     schemaVersion?: number
-  }) => PersistedCollectionPersistence<T, TKey>
+  }) => PersistedCollectionPersistence
   resolvePersistenceForMode?: (
     mode: PersistedCollectionMode,
-  ) => PersistedCollectionPersistence<T, TKey>
+  ) => PersistedCollectionPersistence
 }
 
-type PersistedResolvedPersistence<
-  T extends object,
-  TKey extends string | number,
-> = PersistedCollectionPersistence<T, TKey> & {
+type PersistedResolvedPersistence = PersistedCollectionPersistence & {
   coordinator: PersistedCollectionCoordinator
 }
 
@@ -360,7 +354,7 @@ export type PersistedSyncWrappedOptions<
   TUtils extends UtilsRecord = UtilsRecord,
 > = CollectionConfig<T, TKey, TSchema, TUtils> & {
   sync: SyncConfig<T, TKey>
-  persistence: PersistedCollectionPersistence<T, TKey>
+  persistence: PersistedCollectionPersistence
   schemaVersion?: number
 }
 
@@ -370,7 +364,7 @@ export type PersistedLocalOnlyOptions<
   TSchema extends StandardSchemaV1 = never,
   TUtils extends UtilsRecord = UtilsRecord,
 > = Omit<CollectionConfig<T, TKey, TSchema, TUtils>, `sync`> & {
-  persistence: PersistedCollectionPersistence<T, TKey>
+  persistence: PersistedCollectionPersistence
   schemaVersion?: number
 }
 
@@ -380,7 +374,7 @@ type PersistedSyncOptionsResult<
   TSchema extends StandardSchemaV1,
   TUtils extends UtilsRecord,
 > = CollectionConfig<T, TKey, TSchema, TUtils> & {
-  persistence: PersistedResolvedPersistence<T, TKey>
+  persistence: PersistedResolvedPersistence
 }
 
 type PersistedLocalOnlyOptionsResult<
@@ -390,7 +384,7 @@ type PersistedLocalOnlyOptionsResult<
   TUtils extends UtilsRecord,
 > = CollectionConfig<T, TKey, TSchema, TUtils & PersistedCollectionUtils> & {
   id: string
-  persistence: PersistedResolvedPersistence<T, TKey>
+  persistence: PersistedResolvedPersistence
   utils: TUtils & PersistedCollectionUtils
 }
 
@@ -415,7 +409,7 @@ const REQUIRED_COORDINATOR_METHODS: ReadonlyArray<
 
 const REQUIRED_ADAPTER_METHODS: ReadonlyArray<
   keyof Pick<
-    PersistenceAdapter<object, string | number>,
+    PersistenceAdapter,
     `loadSubset` | `applyCommittedTx` | `ensureIndex`
   >
 > = [`loadSubset`, `applyCommittedTx`, `ensureIndex`]
@@ -496,10 +490,7 @@ export function validatePersistedCollectionCoordinator(
   }
 }
 
-function validatePersistenceAdapter<
-  T extends object,
-  TKey extends string | number,
->(adapter: PersistenceAdapter<T, TKey>): void {
+function validatePersistenceAdapter(adapter: PersistenceAdapter): void {
   for (const method of REQUIRED_ADAPTER_METHODS) {
     if (typeof adapter[method] !== `function`) {
       throw new InvalidPersistenceAdapterError(method)
@@ -507,9 +498,9 @@ function validatePersistenceAdapter<
   }
 }
 
-function resolvePersistence<T extends object, TKey extends string | number>(
-  persistence: PersistedCollectionPersistence<T, TKey>,
-): PersistedResolvedPersistence<T, TKey> {
+function resolvePersistence(
+  persistence: PersistedCollectionPersistence,
+): PersistedResolvedPersistence {
   validatePersistenceAdapter(persistence.adapter)
 
   const coordinator = persistence.coordinator ?? new SingleProcessCoordinator()
@@ -521,28 +512,22 @@ function resolvePersistence<T extends object, TKey extends string | number>(
   }
 }
 
-function resolvePersistenceForMode<
-  T extends object,
-  TKey extends string | number,
->(
-  persistence: PersistedCollectionPersistence<T, TKey>,
+function resolvePersistenceForMode(
+  persistence: PersistedCollectionPersistence,
   mode: PersistedCollectionMode,
-): PersistedResolvedPersistence<T, TKey> {
+): PersistedResolvedPersistence {
   const modeSpecificPersistence = persistence.resolvePersistenceForMode?.(mode)
   return resolvePersistence(modeSpecificPersistence ?? persistence)
 }
 
-function resolvePersistenceForCollection<
-  T extends object,
-  TKey extends string | number,
->(
-  persistence: PersistedCollectionPersistence<T, TKey>,
+function resolvePersistenceForCollection(
+  persistence: PersistedCollectionPersistence,
   options: {
     collectionId: string
     mode: PersistedCollectionMode
     schemaVersion?: number
   },
-): PersistedResolvedPersistence<T, TKey> {
+): PersistedResolvedPersistence {
   const collectionSpecificPersistence =
     persistence.resolvePersistenceForCollection?.(options)
   if (collectionSpecificPersistence) {
@@ -838,7 +823,7 @@ class PersistedCollectionRuntime<
   constructor(
     private readonly mode: PersistedMode,
     private readonly collectionId: string,
-    private readonly persistence: PersistedResolvedPersistence<T, TKey>,
+    private readonly persistence: PersistedResolvedPersistence,
     private readonly syncMode: `eager` | `on-demand`,
     private readonly dbName: string,
   ) {}
@@ -1195,7 +1180,7 @@ class PersistedCollectionRuntime<
   ): Promise<Array<{ key: TKey; value: T; metadata?: unknown }>> {
     return this.persistence.adapter.loadSubset(this.collectionId, options, {
       requiredIndexSignatures: this.getRequiredIndexSignatures(),
-    })
+    }) as Promise<Array<{ key: TKey; value: T; metadata?: unknown }>>
   }
 
   private async scanPersistedRowsUnsafe(
@@ -1205,7 +1190,10 @@ class PersistedCollectionRuntime<
       return []
     }
 
-    return this.persistence.adapter.scanRows(this.collectionId, options)
+    return this.persistence.adapter.scanRows(
+      this.collectionId,
+      options,
+    ) as Promise<Array<PersistedScannedRow<T, TKey>>>
   }
 
   async scanPersistedRows(
@@ -1421,7 +1409,10 @@ class PersistedCollectionRuntime<
         requiresFullReload: transaction.truncate,
         changedRows: transaction.operations
           .filter((operation) => operation.type === `update`)
-          .map((operation) => ({ key: operation.key, value: operation.value })),
+          .map((operation) => ({
+            key: operation.key,
+            value: operation.value as Record<string, unknown>,
+          })),
         deletedKeys: transaction.operations
           .filter((operation) => operation.type === `delete`)
           .map((operation) => operation.key),
@@ -1434,7 +1425,7 @@ class PersistedCollectionRuntime<
   private createPersistedTxFromOperations(
     transaction: BufferedSyncTransaction<T, TKey>,
     streamPosition: { term: number; seq: number; rowVersion: number },
-  ): PersistedTx<T, TKey> {
+  ): PersistedTx {
     return {
       txId: crypto.randomUUID(),
       term: streamPosition.term,
@@ -1444,22 +1435,26 @@ class PersistedCollectionRuntime<
       mutations: transaction.operations.map((operation) =>
         operation.type === `update`
           ? {
-              type: `update`,
+              type: `update` as const,
               key: operation.key,
-              value: operation.value,
+              value: operation.value as Record<string, unknown>,
             }
           : {
-              type: `delete`,
+              type: `delete` as const,
               key: operation.key,
-              value: operation.value,
+              value: operation.value as Record<string, unknown>,
             },
       ),
       rowMetadataMutations: Array.from(
         transaction.rowMetadataWrites.entries(),
       ).map(([key, metadataWrite]) =>
         metadataWrite.type === `delete`
-          ? { type: `delete`, key }
-          : { type: `set`, key, value: metadataWrite.value },
+          ? { type: `delete` as const, key: key }
+          : {
+              type: `set` as const,
+              key: key,
+              value: metadataWrite.value,
+            },
       ),
       collectionMetadataMutations: Array.from(
         transaction.collectionMetadataWrites.entries(),
@@ -1474,7 +1469,7 @@ class PersistedCollectionRuntime<
   private createPersistedTxFromMutations(
     mutations: Array<PendingMutation<T>>,
     streamPosition: { term: number; seq: number; rowVersion: number },
-  ): PersistedTx<T, TKey> {
+  ): PersistedTx {
     return {
       txId: crypto.randomUUID(),
       term: streamPosition.term,
@@ -1483,24 +1478,24 @@ class PersistedCollectionRuntime<
       mutations: mutations.map((mutation) => {
         if (mutation.type === `delete`) {
           return {
-            type: `delete`,
-            key: mutation.key as TKey,
-            value: mutation.original as T,
+            type: `delete` as const,
+            key: mutation.key as string | number,
+            value: mutation.original as Record<string, unknown>,
           }
         }
 
         if (mutation.type === `insert`) {
           return {
-            type: `insert`,
-            key: mutation.key as TKey,
-            value: mutation.modified,
+            type: `insert` as const,
+            key: mutation.key as string | number,
+            value: mutation.modified as Record<string, unknown>,
           }
         }
 
         return {
-          type: `update`,
-          key: mutation.key as TKey,
-          value: mutation.modified,
+          type: `update` as const,
+          key: mutation.key as string | number,
+          value: mutation.modified as Record<string, unknown>,
         }
       }),
     }
@@ -1618,12 +1613,12 @@ class PersistedCollectionRuntime<
         changedRows: mutations
           .filter((mutation) => mutation.type !== `delete`)
           .map((mutation) => ({
-            key: mutation.key as TKey,
-            value: mutation.modified,
+            key: mutation.key as string | number,
+            value: mutation.modified as Record<string, unknown>,
           })),
         deletedKeys: mutations
           .filter((mutation) => mutation.type === `delete`)
-          .map((mutation) => mutation.key as TKey),
+          .map((mutation) => mutation.key as string | number),
         rowMetadataMutations: tx.rowMetadataMutations,
         collectionMetadataMutations: tx.collectionMetadataMutations,
       }),
@@ -1637,9 +1632,9 @@ class PersistedCollectionRuntime<
     seq: number
     txId: string
     latestRowVersion: number
-    changedRows: Array<{ key: TKey; value: T }>
-    deletedKeys: Array<TKey>
-    rowMetadataMutations?: Array<PersistedRowMetadataMutation<TKey>>
+    changedRows: Array<{ key: string | number; value: Record<string, unknown> }>
+    deletedKeys: Array<string | number>
+    rowMetadataMutations?: Array<PersistedRowMetadataMutation>
     collectionMetadataMutations?: Array<PersistedCollectionMetadataMutation>
     hasMetadataChanges?: boolean
     requiresFullReload?: boolean
@@ -1672,14 +1667,9 @@ class PersistedCollectionRuntime<
       txId: args.txId,
       latestRowVersion: args.latestRowVersion,
       requiresFullReload: false,
-      changedRows: args.changedRows as Array<{
-        key: string | number
-        value: Record<string, unknown>
-      }>,
+      changedRows: args.changedRows,
       deletedKeys: args.deletedKeys,
-      rowMetadataMutations: rowMetadataMutations as Array<
-        PersistedRowMetadataMutation<string | number>
-      >,
+      rowMetadataMutations,
       collectionMetadataMutations,
     }
   }

package/src/sqlite-core-adapter.ts

@@ -608,16 +608,20 @@ function sanitizeExpressionSqlFragment(fragment: string): string {
   return fragment
 }
 
-type InMemoryRow<TKey extends string | number, T extends object> = {
+type InMemoryRow<
+  TKey extends string | number = string | number,
+  T extends object = Record<string, unknown>,
+> = {
   key: TKey
   value: T
   metadata?: unknown
   rowVersion: number
 }
 
-function decodeStoredSqliteRows<TKey extends string | number, T extends object>(
-  storedRows: ReadonlyArray<StoredSqliteRow>,
-): Array<InMemoryRow<TKey, T>> {
+function decodeStoredSqliteRows<
+  TKey extends string | number = string | number,
+  T extends object = Record<string, unknown>,
+>(storedRows: ReadonlyArray<StoredSqliteRow>): Array<InMemoryRow<TKey, T>> {
   return storedRows.map((row) => {
     const key = decodePersistedStorageKey(row.key) as TKey
     const value = deserializePersistedRowValue<T>(row.value)
@@ -1002,10 +1006,7 @@ function buildIndexName(collectionId: string, signature: string): string {
   return `idx_${hashedPart}_${suffix}`
 }
 
-export class SQLiteCorePersistenceAdapter<
-  T extends object,
-  TKey extends string | number = string | number,
-> implements PersistenceAdapter<T, TKey> {
+export class SQLiteCorePersistenceAdapter implements PersistenceAdapter {
   private readonly driver: SQLiteDriver
   private readonly schemaVersion: number
   private readonly schemaMismatchPolicy: SQLiteCoreAdapterSchemaMismatchPolicy
@@ -1085,7 +1086,13 @@ export class SQLiteCorePersistenceAdapter<
     collectionId: string,
     options: LoadSubsetOptions,
     ctx?: { requiredIndexSignatures?: ReadonlyArray<string> },
-  ): Promise<Array<{ key: TKey; value: T; metadata?: unknown }>> {
+  ): Promise<
+    Array<{
+      key: string | number
+      value: Record<string, unknown>
+      metadata?: unknown
+    }>
+  > {
     const tableMapping = await this.ensureCollectionReady(collectionId)
     await this.touchRequiredIndexes(collectionId, ctx?.requiredIndexSignatures)
 
@@ -1109,7 +1116,10 @@ export class SQLiteCorePersistenceAdapter<
         this.loadSubsetInternal(tableMapping, whereFromOptions),
       ])
 
-      const mergedRows = new Map<string, InMemoryRow<TKey, T>>()
+      const mergedRows = new Map<
+        string,
+        InMemoryRow<string | number, Record<string, unknown>>
+      >()
       for (const row of [...whereCurrentRows, ...whereFromRows]) {
         mergedRows.set(encodePersistedStorageKey(row.key), row)
       }
@@ -1134,10 +1144,7 @@ export class SQLiteCorePersistenceAdapter<
     }))
   }
 
-  async applyCommittedTx(
-    collectionId: string,
-    tx: PersistedTx<T, TKey>,
-  ): Promise<void> {
+  async applyCommittedTx(collectionId: string, tx: PersistedTx): Promise<void> {
     const tableMapping = await this.ensureCollectionReady(collectionId)
     const collectionTableSql = quoteIdentifier(tableMapping.tableName)
     const tombstoneTableSql = quoteIdentifier(tableMapping.tombstoneTableName)
@@ -1166,10 +1173,7 @@ export class SQLiteCorePersistenceAdapter<
       )
       const currentRowVersion = versionRows[0]?.latest_row_version ?? 0
       const nextRowVersion = Math.max(currentRowVersion + 1, tx.rowVersion)
-      const replayDelta: ReplayableTxDelta<
-        Record<string, unknown>,
-        TKey
-      > | null = tx.truncate
+      const replayDelta: ReplayableTxDelta | null = tx.truncate
         ? null
         : {
             txId: tx.txId,
@@ -1178,7 +1182,7 @@ export class SQLiteCorePersistenceAdapter<
               .filter((mutation) => mutation.type !== `delete`)
               .map((mutation) => ({
                 key: mutation.key,
-                value: mutation.value as Record<string, unknown>,
+                value: mutation.value,
               })),
             deletedKeys: tx.mutations
               .filter((mutation) => mutation.type === `delete`)
@@ -1379,7 +1383,7 @@ export class SQLiteCorePersistenceAdapter<
   async scanRows(
     collectionId: string,
     options?: PersistedRowScanOptions,
-  ): Promise<Array<PersistedScannedRow<T, TKey>>> {
+  ): Promise<Array<PersistedScannedRow>> {
     const tableMapping = await this.ensureCollectionReady(collectionId)
     const collectionTableSql = quoteIdentifier(tableMapping.tableName)
 
@@ -1392,7 +1396,7 @@ export class SQLiteCorePersistenceAdapter<
            FROM ${collectionTableSql}`,
     )
 
-    return decodeStoredSqliteRows<TKey, T>(storedRows).map((row) => ({
+    return decodeStoredSqliteRows(storedRows).map((row) => ({
       key: row.key,
       value: row.value,
       metadata: row.metadata,
@@ -1531,7 +1535,7 @@ export class SQLiteCorePersistenceAdapter<
   async pullSince(
     collectionId: string,
     fromRowVersion: number,
-  ): Promise<SQLitePullSinceResult<TKey>> {
+  ): Promise<SQLitePullSinceResult<string | number>> {
     const tableMapping = await this.ensureCollectionReady(collectionId)
     const collectionTableSql = quoteIdentifier(tableMapping.tableName)
     const tombstoneTableSql = quoteIdentifier(tableMapping.tombstoneTableName)
@@ -1593,9 +1597,9 @@ export class SQLiteCorePersistenceAdapter<
       }
     }
 
-    const decodeKey = (encodedKey: string): TKey => {
+    const decodeKey = (encodedKey: string): string | number => {
       try {
-        return decodePersistedStorageKey(encodedKey) as TKey
+        return decodePersistedStorageKey(encodedKey)
       } catch (error) {
         throw new InvalidPersistedStorageKeyEncodingError(
           `${encodedKey}: ${(error as Error).message}`,
@@ -1604,10 +1608,9 @@ export class SQLiteCorePersistenceAdapter<
     }
 
     const deltas = replayRows.map((row) => {
-      const parsed = deserializePersistedRowValue<ReplayableTxDelta<
-        Record<string, unknown>,
-        TKey
-      > | null>(row.replay_json ?? `null`)
+      const parsed = deserializePersistedRowValue<ReplayableTxDelta | null>(
+        row.replay_json ?? `null`,
+      )
       if (!parsed) {
         throw new InvalidPersistedCollectionConfigError(
           `missing replay payload for applied_tx row`,
@@ -1645,7 +1648,7 @@ export class SQLiteCorePersistenceAdapter<
   private async loadSubsetInternal(
     tableMapping: CollectionTableMapping,
     options: LoadSubsetOptions,
-  ): Promise<Array<InMemoryRow<TKey, T>>> {
+  ): Promise<Array<InMemoryRow<string | number, Record<string, unknown>>>> {
     const collectionTableSql = quoteIdentifier(tableMapping.tableName)
     const whereCompiled = options.where
       ? compileSqlExpression(options.where)
@@ -1669,7 +1672,7 @@ export class SQLiteCorePersistenceAdapter<
       sql,
       queryParams,
     )
-    const parsedRows = decodeStoredSqliteRows<TKey, T>(storedRows)
+    const parsedRows = decodeStoredSqliteRows(storedRows)
 
     const filteredRows = this.applyInMemoryWhere(parsedRows, options.where)
     const orderedRows = this.applyInMemoryOrderBy(filteredRows, options.orderBy)
@@ -1681,25 +1684,23 @@ export class SQLiteCorePersistenceAdapter<
   }
 
   private applyInMemoryWhere(
-    rows: Array<InMemoryRow<TKey, T>>,
+    rows: Array<InMemoryRow<string | number, Record<string, unknown>>>,
     where: IR.BasicExpression<boolean> | undefined,
-  ): Array<InMemoryRow<TKey, T>> {
+  ): Array<InMemoryRow<string | number, Record<string, unknown>>> {
     if (!where) {
       return rows
     }
 
     const evaluator = compileRowExpressionEvaluator(where)
     return rows.filter((row) =>
-      toBooleanPredicate(
-        evaluator(row.value as Record<string, unknown>) as boolean | null,
-      ),
+      toBooleanPredicate(evaluator(row.value) as boolean | null),
     )
   }
 
   private applyInMemoryOrderBy(
-    rows: Array<InMemoryRow<TKey, T>>,
+    rows: Array<InMemoryRow<string | number, Record<string, unknown>>>,
     orderBy: IR.OrderBy | undefined,
-  ): Array<InMemoryRow<TKey, T>> {
+  ): Array<InMemoryRow<string | number, Record<string, unknown>>> {
     if (!orderBy || orderBy.length === 0) {
       return rows
     }
@@ -1712,12 +1713,8 @@ export class SQLiteCorePersistenceAdapter<
     const ordered = [...rows]
     ordered.sort((left, right) => {
       for (const clause of compiledClauses) {
-        const leftValue = clause.evaluator(
-          left.value as Record<string, unknown>,
-        )
-        const rightValue = clause.evaluator(
-          right.value as Record<string, unknown>,
-        )
+        const leftValue = clause.evaluator(left.value)
+        const rightValue = clause.evaluator(right.value)
 
         const comparison = compareOrderByValues(
           leftValue,
@@ -1747,10 +1744,10 @@ export class SQLiteCorePersistenceAdapter<
   }
 
   private applyInMemoryPagination(
-    rows: Array<InMemoryRow<TKey, T>>,
+    rows: Array<InMemoryRow<string | number, Record<string, unknown>>>,
     limit: number | undefined,
     offset: number | undefined,
-  ): Array<InMemoryRow<TKey, T>> {
+  ): Array<InMemoryRow<string | number, Record<string, unknown>>> {
     const start = offset ?? 0
     if (limit === undefined) {
       return rows.slice(start)
@@ -2121,9 +2118,8 @@ export class SQLiteCorePersistenceAdapter<
   }
 }
 
-export function createSQLiteCorePersistenceAdapter<
-  T extends object,
-  TKey extends string | number = string | number,
->(options: SQLiteCoreAdapterOptions): PersistenceAdapter<T, TKey> {
-  return new SQLiteCorePersistenceAdapter<T, TKey>(options)
+export function createSQLiteCorePersistenceAdapter(
+  options: SQLiteCoreAdapterOptions,
+): PersistenceAdapter {
+  return new SQLiteCorePersistenceAdapter(options)
 }