Function createPersistedQueryAdapter

packages/query-db-collection/tests/query.test.ts:101–163

(
  seed: {
    rows?: ReadonlyMap<string, TItem>
    rowMetadata?: ReadonlyMap<string, unknown>
    collectionMetadata?: ReadonlyMap<string, unknown>
  } = {},
)

}

function createPersistedQueryAdapter<TItem extends { id: string }>(
  seed: {
    rows?: ReadonlyMap<string, TItem>
    rowMetadata?: ReadonlyMap<string, unknown>
    collectionMetadata?: ReadonlyMap<string, unknown>
  } = {},
) {
  const rows = new Map(seed.rows)
  const rowMetadata = new Map(seed.rowMetadata)
  const collectionMetadata = new Map(seed.collectionMetadata)

  return {
    rows,
    rowMetadata,
    collectionMetadata,
    loadSubset: async () =>
      Array.from(rows.values()).map((value) => ({
        key: value.id,
        value,
        metadata: rowMetadata.get(value.id),
      })),
    loadCollectionMetadata: async () =>
      Array.from(collectionMetadata.entries()).map(([key, value]) => ({
        key,
        value,
      })),
    scanRows: async () =>
      Array.from(rows.values()).map((value) => ({
        key: value.id,
        value,
        metadata: rowMetadata.get(value.id),
      })),
    applyCommittedTx: async (_collectionId: string, tx: any) => {
      if (tx.truncate) {
        rows.clear()
        rowMetadata.clear()
      }
      for (const mutation of tx.mutations) {
        if (mutation.type === `delete`) {
          rows.delete(mutation.key)
          rowMetadata.delete(mutation.key)
        } else {
          rows.set(mutation.key, mutation.value)
        }
      }
      for (const mutation of tx.rowMetadataMutations ?? []) {
        if (mutation.type === `delete`) {
          rowMetadata.delete(mutation.key)
        } else {
          rowMetadata.set(mutation.key, mutation.value)
        }
      }
      for (const mutation of tx.collectionMetadataMutations ?? []) {
        if (mutation.type === `delete`) {
          collectionMetadata.delete(mutation.key)
        } else {
          collectionMetadata.set(mutation.key, mutation.value)
        }