@rocicorp/zero 0.26.1-canary.9 → 0.26.2-canary.1

package/out/replicache/src/db/commit.js.map

@@ -1 +1 @@
-{"version":3,"file":"commit.js","sources":["../../../../../replicache/src/db/commit.ts"],"sourcesContent":["import {\n  assert,\n  assertArray,\n  assertBoolean,\n  assertNumber,\n  assertObject,\n  assertString,\n  unreachable,\n} from '../../../shared/src/asserts.ts';\nimport {assertJSONValue} from '../../../shared/src/json.ts';\nimport {skipCommitDataAsserts} from '../config.ts';\nimport {type FrozenCookie, compareCookies} from '../cookies.ts';\nimport {type Chunk, type CreateChunk, type Refs, toRefs} from '../dag/chunk.ts';\nimport {type MustGetChunk, type Read, mustGetHeadHash} from '../dag/store.ts';\nimport {\n  type FrozenJSONValue,\n  type FrozenTag,\n  assertDeepFrozen,\n  deepFreeze,\n} from '../frozen-json.ts';\nimport {type Hash, assertHash} from '../hash.ts';\nimport type {IndexDefinition} from '../index-defs.ts';\nimport type {ClientID} from '../sync/ids.ts';\nimport * as MetaType from './meta-type-enum.ts';\n\nexport const DEFAULT_HEAD_NAME = 'main';\n\nexport function commitIsLocalDD31(\n  commit: Commit<Meta>,\n): commit is Commit<LocalMetaDD31> {\n  return isLocalMetaDD31(commit.meta);\n}\n\nexport function commitIsLocal(\n  commit: Commit<Meta>,\n): commit is Commit<LocalMetaDD31> {\n  return commitIsLocalDD31(commit);\n}\n\nexport function commitIsSnapshot(\n  commit: Commit<Meta>,\n): commit is Commit<SnapshotMetaDD31> {\n  return isSnapshotMetaDD31(commit.meta);\n}\n\nexport class Commit<M extends Meta> {\n  readonly chunk: Chunk<CommitData<M>>;\n\n  constructor(chunk: Chunk<CommitData<M>>) {\n    this.chunk = chunk;\n  }\n\n  get meta(): M {\n    return this.chunk.data.meta;\n  }\n\n  get valueHash(): Hash {\n    // Already validated!\n    return this.chunk.data.valueHash;\n  }\n\n  getMutationID(clientID: ClientID, dagRead: MustGetChunk): Promise<number> {\n    return getMutationID(clientID, dagRead, this.meta);\n  }\n\n  async getNextMutationID(\n    clientID: ClientID,\n    dagRead: MustGetChunk,\n  ): Promise<number> {\n    return (await this.getMutationID(clientID, dagRead)) + 1;\n  }\n\n  get indexes(): readonly IndexRecord[] {\n    // Already validated!\n    return this.chunk.data.indexes;\n  }\n}\n\nexport async function getMutationID(\n  clientID: ClientID,\n  dagRead: MustGetChunk,\n  meta: Meta,\n): Promise<number> {\n  switch (meta.type) {\n    case MetaType.SnapshotDD31:\n      return meta.lastMutationIDs[clientID] ?? 0;\n\n    case MetaType.LocalDD31: {\n      if (meta.clientID === clientID) {\n        return meta.mutationID;\n      }\n      const {basisHash} = meta;\n      const basisCommit = await commitFromHash(basisHash, dagRead);\n      return getMutationID(clientID, dagRead, basisCommit.meta);\n    }\n\n    default:\n      unreachable(meta);\n  }\n}\n\n/**\n * Returns the set of local commits from the given `fromCommitHash` back to but not\n * including its base snapshot. If `fromCommitHash` is a snapshot, the returned vector\n * will be empty. When, as typical, `fromCommitHash` is the head of the default chain\n * then the returned commits are the set of pending commits, ie the set of local commits\n * that have not yet been pushed to the data layer.\n *\n * The vector of commits is returned in reverse chain order, that is, starting\n * with the commit with hash `fromCommitHash` and walking backwards.\n */\nexport async function localMutations(\n  fromCommitHash: Hash,\n  dagRead: Read,\n): Promise<Commit<LocalMetaDD31>[]> {\n  const commits = await commitChain(fromCommitHash, dagRead);\n  // Filter does not deal with type narrowing.\n  return commits.filter(c => commitIsLocal(c)) as Commit<LocalMetaDD31>[];\n}\n\nexport async function localMutationsDD31(\n  fromCommitHash: Hash,\n  dagRead: Read,\n): Promise<Commit<LocalMetaDD31>[]> {\n  const commits = await commitChain(fromCommitHash, dagRead);\n  // Filter does not deal with type narrowing.\n  return commits.filter(c => commitIsLocalDD31(c)) as Commit<LocalMetaDD31>[];\n}\n\nexport async function localMutationsGreaterThan(\n  commit: Commit<Meta>,\n  mutationIDLimits: Record<ClientID, number>,\n  dagRead: Read,\n): Promise<Commit<LocalMetaDD31>[]> {\n  const commits: Commit<LocalMetaDD31>[] = [];\n  const remainingMutationIDLimits = new Map(Object.entries(mutationIDLimits));\n  while (!commitIsSnapshot(commit) && remainingMutationIDLimits.size > 0) {\n    if (commitIsLocalDD31(commit)) {\n      const {meta} = commit;\n      const mutationIDLowerLimit = remainingMutationIDLimits.get(meta.clientID);\n      if (mutationIDLowerLimit !== undefined) {\n        if (meta.mutationID <= mutationIDLowerLimit) {\n          remainingMutationIDLimits.delete(meta.clientID);\n        } else {\n          commits.push(commit as Commit<LocalMetaDD31>);\n        }\n      }\n    }\n    const {basisHash} = commit.meta;\n    if (basisHash === null) {\n      throw new Error(`Commit ${commit.chunk.hash} has no basis`);\n    }\n    commit = await commitFromHash(basisHash, dagRead);\n  }\n  return commits;\n}\n\nexport async function baseSnapshotFromHead(\n  name: string,\n  dagRead: Read,\n): Promise<Commit<SnapshotMetaDD31>> {\n  const hash = await dagRead.getHead(name);\n  assert(hash, `Missing head ${name}`);\n  return baseSnapshotFromHash(hash, dagRead);\n}\n\nexport async function baseSnapshotHashFromHash(\n  hash: Hash,\n  dagRead: Read,\n): Promise<Hash> {\n  return (await baseSnapshotFromHash(hash, dagRead)).chunk.hash;\n}\n\nexport async function baseSnapshotFromHash(\n  hash: Hash,\n  dagRead: Read,\n): Promise<Commit<SnapshotMetaDD31>> {\n  const commit = await commitFromHash(hash, dagRead);\n  return baseSnapshotFromCommit(commit, dagRead);\n}\n\nexport async function baseSnapshotFromCommit(\n  commit: Commit<Meta>,\n  dagRead: Read,\n): Promise<Commit<SnapshotMetaDD31>> {\n  while (!commitIsSnapshot(commit)) {\n    const {meta} = commit;\n    if (isLocalMetaDD31(meta)) {\n      commit = await commitFromHash(meta.baseSnapshotHash, dagRead);\n    } else {\n      const {basisHash} = meta;\n      if (basisHash === null) {\n        throw new Error(`Commit ${commit.chunk.hash} has no basis`);\n      }\n      commit = await commitFromHash(basisHash, dagRead);\n    }\n  }\n  return commit;\n}\n\nexport function snapshotMetaParts(\n  c: Commit<SnapshotMetaDD31>,\n  clientID: ClientID,\n): [lastMutationID: number, cookie: FrozenCookie | FrozenJSONValue] {\n  const m = c.meta;\n  const lmid = m.lastMutationIDs[clientID] ?? 0;\n  return [lmid, m.cookieJSON];\n}\n\nexport function compareCookiesForSnapshots(\n  a: Commit<SnapshotMetaDD31>,\n  b: Commit<SnapshotMetaDD31>,\n): number {\n  return compareCookies(a.meta.cookieJSON, b.meta.cookieJSON);\n}\n\n/**\n * Returns all commits from the commit with fromCommitHash to its base snapshot,\n * inclusive of both. Resulting vector is in chain-head-first order (so snapshot\n * comes last).\n */\nexport async function commitChain(\n  fromCommitHash: Hash,\n  dagRead: Read,\n): Promise<Commit<Meta>[]> {\n  let commit = await commitFromHash(fromCommitHash, dagRead);\n  const commits = [];\n  while (!commitIsSnapshot(commit)) {\n    const {meta} = commit;\n    const {basisHash} = meta;\n    if (basisHash === null) {\n      throw new Error(`Commit ${commit.chunk.hash} has no basis`);\n    }\n    commits.push(commit);\n    commit = await commitFromHash(basisHash, dagRead);\n  }\n  commits.push(commit);\n  return commits;\n}\n\nexport async function commitFromHash(\n  hash: Hash,\n  dagRead: MustGetChunk,\n): Promise<Commit<Meta>> {\n  const chunk = await dagRead.mustGetChunk(hash);\n  return fromChunk(chunk);\n}\n\nexport async function commitFromHead(\n  name: string,\n  dagRead: Read,\n): Promise<Commit<Meta>> {\n  const hash = await mustGetHeadHash(name, dagRead);\n  return commitFromHash(hash, dagRead);\n}\n\nexport type LocalMetaDD31 = {\n  readonly type: MetaType.LocalDD31;\n  readonly basisHash: Hash;\n  readonly mutationID: number;\n  readonly mutatorName: string;\n  readonly mutatorArgsJSON: FrozenJSONValue;\n  readonly originalHash: Hash | null;\n  readonly timestamp: number;\n  readonly clientID: ClientID;\n  readonly baseSnapshotHash: Hash;\n};\n\nexport type LocalMeta = LocalMetaDD31;\n\nexport function assertLocalMetaDD31(\n  v: Record<string, unknown>,\n): asserts v is LocalMetaDD31 {\n  // type already asserted\n  assertString(v.clientID);\n  assertNumber(v.mutationID);\n  assertString(v.mutatorName);\n  if (!v.mutatorName) {\n    throw new Error('Missing mutator name');\n  }\n  assertJSONValue(v.mutatorArgsJSON);\n  if (v.originalHash !== null) {\n    assertHash(v.originalHash);\n  }\n  assertNumber(v.timestamp);\n}\n\nexport function isLocalMetaDD31(meta: Meta): meta is LocalMetaDD31 {\n  return meta.type === MetaType.LocalDD31;\n}\n\nexport function assertLocalCommitDD31(\n  c: Commit<Meta>,\n): asserts c is Commit<LocalMetaDD31> {\n  assertLocalMetaDD31(c.meta);\n}\n\nexport type SnapshotMetaDD31 = {\n  readonly type: MetaType.SnapshotDD31;\n  readonly basisHash: Hash | null;\n  readonly lastMutationIDs: Record<ClientID, number>;\n  readonly cookieJSON: FrozenCookie;\n};\n\nexport type SnapshotMeta = SnapshotMetaDD31;\n\nexport function assertSnapshotMetaDD31(\n  v: Record<string, unknown>,\n): asserts v is SnapshotMetaDD31 {\n  // type already asserted\n  if (v.basisHash !== null) {\n    assertHash(v.basisHash);\n  }\n  assertJSONValue(v.cookieJSON);\n  assertLastMutationIDs(v.lastMutationIDs);\n}\n\nfunction assertLastMutationIDs(\n  v: unknown,\n): asserts v is Record<ClientID, number> {\n  assertObject(v);\n  for (const e of Object.values(v)) {\n    assertNumber(e);\n  }\n}\n\nexport type Meta = LocalMetaDD31 | SnapshotMetaDD31;\n\nexport function assertSnapshotCommitDD31(\n  c: Commit<Meta>,\n): asserts c is Commit<SnapshotMetaDD31> {\n  assertSnapshotMetaDD31(c.meta);\n}\n\nfunction isSnapshotMetaDD31(meta: Meta): meta is SnapshotMetaDD31 {\n  return meta.type === MetaType.SnapshotDD31;\n}\n\nfunction assertMeta(v: unknown): asserts v is Meta {\n  assertObject(v);\n  assertDeepFrozen(v);\n  if (v.basisHash !== null) {\n    assertString(v.basisHash);\n  }\n\n  assertNumber(v.type);\n  switch (v.type) {\n    case MetaType.LocalDD31:\n      assertLocalMetaDD31(v);\n      break;\n    case MetaType.SnapshotDD31:\n      assertSnapshotMetaDD31(v);\n      break;\n    default:\n      throw new Error(`Invalid enum value ${v.type}`);\n  }\n}\n\n/**\n * This is the type used for index definitions as defined in the Commit chunk data.\n *\n * Changing this requires a REPLICACHE_FORMAT_VERSION bump.\n */\nexport type ChunkIndexDefinition = {\n  readonly name: string;\n  readonly keyPrefix: string;\n  readonly jsonPointer: string;\n  // Used to not exist\n  readonly allowEmpty?: boolean;\n};\n\nexport function chunkIndexDefinitionEqualIgnoreName(\n  a: ChunkIndexDefinition,\n  b: ChunkIndexDefinition,\n): boolean {\n  return (\n    a.jsonPointer === b.jsonPointer &&\n    (a.allowEmpty ?? false) === (b.allowEmpty ?? false) &&\n    a.keyPrefix === b.keyPrefix\n  );\n}\n\nfunction assertChunkIndexDefinition(\n  v: unknown,\n): asserts v is ChunkIndexDefinition {\n  assertObject(v);\n  assertDeepFrozen(v);\n  assertString(v.name);\n  assertString(v.keyPrefix);\n  assertString(v.jsonPointer);\n  if (v.allowEmpty !== undefined) {\n    assertBoolean(v.allowEmpty);\n  }\n}\n\nexport function toChunkIndexDefinition(\n  name: string,\n  indexDefinition: IndexDefinition,\n): Required<ChunkIndexDefinition> {\n  return {\n    name,\n    keyPrefix: indexDefinition.prefix ?? '',\n    jsonPointer: indexDefinition.jsonPointer,\n    allowEmpty: indexDefinition.allowEmpty ?? false,\n  };\n}\n\nexport type IndexRecord = {\n  readonly definition: ChunkIndexDefinition;\n  readonly valueHash: Hash;\n};\n\nfunction assertIndexRecord(v: unknown): asserts v is IndexRecord {\n  assertObject(v);\n  assertDeepFrozen(v);\n  assertChunkIndexDefinition(v.definition);\n  assertString(v.valueHash);\n}\n\nfunction assertIndexRecords(v: unknown): asserts v is IndexRecord[] {\n  assertArray(v);\n  assertDeepFrozen(v);\n  for (const ir of v) {\n    assertIndexRecord(ir);\n  }\n}\n\nexport function newLocalDD31(\n  createChunk: CreateChunk,\n  basisHash: Hash,\n  baseSnapshotHash: Hash,\n  mutationID: number,\n  mutatorName: string,\n  mutatorArgsJSON: FrozenJSONValue,\n  originalHash: Hash | null,\n  valueHash: Hash,\n  indexes: readonly IndexRecord[],\n  timestamp: number,\n  clientID: ClientID,\n): Commit<LocalMetaDD31> {\n  const meta: LocalMetaDD31 = {\n    type: MetaType.LocalDD31,\n    basisHash,\n    baseSnapshotHash,\n    mutationID,\n    mutatorName,\n    mutatorArgsJSON,\n    originalHash,\n    timestamp,\n    clientID,\n  };\n  return commitFromCommitData(\n    createChunk,\n    makeCommitData(meta, valueHash, indexes),\n  );\n}\n\nexport function newSnapshotDD31(\n  createChunk: CreateChunk,\n  basisHash: Hash | null,\n  lastMutationIDs: Record<ClientID, number>,\n  cookieJSON: FrozenCookie,\n  valueHash: Hash,\n  indexes: readonly IndexRecord[],\n): Commit<SnapshotMetaDD31> {\n  return commitFromCommitData(\n    createChunk,\n    newSnapshotCommitDataDD31(\n      basisHash,\n      lastMutationIDs,\n      cookieJSON,\n      valueHash,\n      indexes,\n    ),\n  );\n}\n\nexport function newSnapshotCommitDataDD31(\n  basisHash: Hash | null,\n  lastMutationIDs: Record<ClientID, number>,\n  cookieJSON: FrozenCookie,\n  valueHash: Hash,\n  indexes: readonly IndexRecord[],\n): CommitData<SnapshotMetaDD31> {\n  const meta: SnapshotMetaDD31 = {\n    type: MetaType.SnapshotDD31,\n    basisHash,\n    lastMutationIDs,\n    cookieJSON,\n  };\n  return makeCommitData(meta, valueHash, indexes);\n}\n\nexport function fromChunk(chunk: Chunk): Commit<Meta> {\n  validateChunk(chunk);\n  return new Commit(chunk);\n}\n\nfunction commitFromCommitData<M extends Meta>(\n  createChunk: CreateChunk,\n  data: CommitData<M>,\n): Commit<M> {\n  return new Commit(createChunk(data, getRefs(data)));\n}\n\nexport function getRefs(data: CommitData<Meta>): Refs {\n  const refs: Set<Hash> = new Set();\n  refs.add(data.valueHash);\n  const {meta} = data;\n  switch (meta.type) {\n    case MetaType.LocalDD31:\n      meta.basisHash && refs.add(meta.basisHash);\n      // Local has weak originalHash\n      break;\n    case MetaType.SnapshotDD31:\n      // Snapshot has weak basisHash\n      break;\n    default:\n      unreachable(meta);\n  }\n\n  for (const index of data.indexes) {\n    refs.add(index.valueHash);\n  }\n\n  return toRefs(refs);\n}\n\nexport type CommitData<M extends Meta> = FrozenTag<{\n  readonly meta: M;\n  readonly valueHash: Hash;\n  readonly indexes: readonly IndexRecord[];\n}>;\n\nexport function makeCommitData<M extends Meta>(\n  meta: M,\n  valueHash: Hash,\n  indexes: readonly IndexRecord[],\n): CommitData<M> {\n  return deepFreeze({\n    meta,\n    valueHash,\n    indexes,\n  }) as unknown as CommitData<M>;\n}\n\nexport function assertCommitData(v: unknown): asserts v is CommitData<Meta> {\n  if (skipCommitDataAsserts) {\n    return;\n  }\n\n  assertObject(v);\n  assertDeepFrozen(v);\n  assertMeta(v.meta);\n  assertString(v.valueHash);\n  assertIndexRecords(v.indexes);\n}\n\nfunction validateChunk(chunk: Chunk): asserts chunk is Chunk<CommitData<Meta>> {\n  const {data} = chunk;\n  assertCommitData(data);\n\n  const seen = new Set();\n  for (const index of data.indexes) {\n    const {name} = index.definition;\n    if (seen.has(name)) {\n      throw new Error(`Duplicate index ${name}`);\n    }\n    seen.add(name);\n  }\n}\n"],"names":["MetaType.SnapshotDD31","MetaType.LocalDD31","skipCommitDataAsserts"],"mappings":"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"}
+{"version":3,"file":"commit.js","names":[],"sources":["../../../../../replicache/src/db/commit.ts"],"sourcesContent":["import {\n  assert,\n  assertArray,\n  assertBoolean,\n  assertNumber,\n  assertObject,\n  assertString,\n  unreachable,\n} from '../../../shared/src/asserts.ts';\nimport {assertJSONValue} from '../../../shared/src/json.ts';\nimport {skipCommitDataAsserts} from '../config.ts';\nimport {type FrozenCookie, compareCookies} from '../cookies.ts';\nimport {type Chunk, type CreateChunk, type Refs, toRefs} from '../dag/chunk.ts';\nimport {type MustGetChunk, type Read, mustGetHeadHash} from '../dag/store.ts';\nimport {\n  type FrozenJSONValue,\n  type FrozenTag,\n  assertDeepFrozen,\n  deepFreeze,\n} from '../frozen-json.ts';\nimport {type Hash, assertHash} from '../hash.ts';\nimport type {IndexDefinition} from '../index-defs.ts';\nimport type {ClientID} from '../sync/ids.ts';\nimport * as MetaType from './meta-type-enum.ts';\n\nexport const DEFAULT_HEAD_NAME = 'main';\n\nexport function commitIsLocalDD31(\n  commit: Commit<Meta>,\n): commit is Commit<LocalMetaDD31> {\n  return isLocalMetaDD31(commit.meta);\n}\n\nexport function commitIsLocal(\n  commit: Commit<Meta>,\n): commit is Commit<LocalMetaDD31> {\n  return commitIsLocalDD31(commit);\n}\n\nexport function commitIsSnapshot(\n  commit: Commit<Meta>,\n): commit is Commit<SnapshotMetaDD31> {\n  return isSnapshotMetaDD31(commit.meta);\n}\n\nexport class Commit<M extends Meta> {\n  readonly chunk: Chunk<CommitData<M>>;\n\n  constructor(chunk: Chunk<CommitData<M>>) {\n    this.chunk = chunk;\n  }\n\n  get meta(): M {\n    return this.chunk.data.meta;\n  }\n\n  get valueHash(): Hash {\n    // Already validated!\n    return this.chunk.data.valueHash;\n  }\n\n  getMutationID(clientID: ClientID, dagRead: MustGetChunk): Promise<number> {\n    return getMutationID(clientID, dagRead, this.meta);\n  }\n\n  async getNextMutationID(\n    clientID: ClientID,\n    dagRead: MustGetChunk,\n  ): Promise<number> {\n    return (await this.getMutationID(clientID, dagRead)) + 1;\n  }\n\n  get indexes(): readonly IndexRecord[] {\n    // Already validated!\n    return this.chunk.data.indexes;\n  }\n}\n\nexport async function getMutationID(\n  clientID: ClientID,\n  dagRead: MustGetChunk,\n  meta: Meta,\n): Promise<number> {\n  switch (meta.type) {\n    case MetaType.SnapshotDD31:\n      return meta.lastMutationIDs[clientID] ?? 0;\n\n    case MetaType.LocalDD31: {\n      if (meta.clientID === clientID) {\n        return meta.mutationID;\n      }\n      const {basisHash} = meta;\n      const basisCommit = await commitFromHash(basisHash, dagRead);\n      return getMutationID(clientID, dagRead, basisCommit.meta);\n    }\n\n    default:\n      unreachable(meta);\n  }\n}\n\n/**\n * Returns the set of local commits from the given `fromCommitHash` back to but not\n * including its base snapshot. If `fromCommitHash` is a snapshot, the returned vector\n * will be empty. When, as typical, `fromCommitHash` is the head of the default chain\n * then the returned commits are the set of pending commits, ie the set of local commits\n * that have not yet been pushed to the data layer.\n *\n * The vector of commits is returned in reverse chain order, that is, starting\n * with the commit with hash `fromCommitHash` and walking backwards.\n */\nexport async function localMutations(\n  fromCommitHash: Hash,\n  dagRead: Read,\n): Promise<Commit<LocalMetaDD31>[]> {\n  const commits = await commitChain(fromCommitHash, dagRead);\n  // Filter does not deal with type narrowing.\n  return commits.filter(c => commitIsLocal(c)) as Commit<LocalMetaDD31>[];\n}\n\nexport async function localMutationsDD31(\n  fromCommitHash: Hash,\n  dagRead: Read,\n): Promise<Commit<LocalMetaDD31>[]> {\n  const commits = await commitChain(fromCommitHash, dagRead);\n  // Filter does not deal with type narrowing.\n  return commits.filter(c => commitIsLocalDD31(c)) as Commit<LocalMetaDD31>[];\n}\n\nexport async function localMutationsGreaterThan(\n  commit: Commit<Meta>,\n  mutationIDLimits: Record<ClientID, number>,\n  dagRead: Read,\n): Promise<Commit<LocalMetaDD31>[]> {\n  const commits: Commit<LocalMetaDD31>[] = [];\n  const remainingMutationIDLimits = new Map(Object.entries(mutationIDLimits));\n  while (!commitIsSnapshot(commit) && remainingMutationIDLimits.size > 0) {\n    if (commitIsLocalDD31(commit)) {\n      const {meta} = commit;\n      const mutationIDLowerLimit = remainingMutationIDLimits.get(meta.clientID);\n      if (mutationIDLowerLimit !== undefined) {\n        if (meta.mutationID <= mutationIDLowerLimit) {\n          remainingMutationIDLimits.delete(meta.clientID);\n        } else {\n          commits.push(commit as Commit<LocalMetaDD31>);\n        }\n      }\n    }\n    const {basisHash} = commit.meta;\n    if (basisHash === null) {\n      throw new Error(`Commit ${commit.chunk.hash} has no basis`);\n    }\n    commit = await commitFromHash(basisHash, dagRead);\n  }\n  return commits;\n}\n\nexport async function baseSnapshotFromHead(\n  name: string,\n  dagRead: Read,\n): Promise<Commit<SnapshotMetaDD31>> {\n  const hash = await dagRead.getHead(name);\n  assert(hash, `Missing head ${name}`);\n  return baseSnapshotFromHash(hash, dagRead);\n}\n\nexport async function baseSnapshotHashFromHash(\n  hash: Hash,\n  dagRead: Read,\n): Promise<Hash> {\n  return (await baseSnapshotFromHash(hash, dagRead)).chunk.hash;\n}\n\nexport async function baseSnapshotFromHash(\n  hash: Hash,\n  dagRead: Read,\n): Promise<Commit<SnapshotMetaDD31>> {\n  const commit = await commitFromHash(hash, dagRead);\n  return baseSnapshotFromCommit(commit, dagRead);\n}\n\nexport async function baseSnapshotFromCommit(\n  commit: Commit<Meta>,\n  dagRead: Read,\n): Promise<Commit<SnapshotMetaDD31>> {\n  while (!commitIsSnapshot(commit)) {\n    const {meta} = commit;\n    if (isLocalMetaDD31(meta)) {\n      commit = await commitFromHash(meta.baseSnapshotHash, dagRead);\n    } else {\n      const {basisHash} = meta;\n      if (basisHash === null) {\n        throw new Error(`Commit ${commit.chunk.hash} has no basis`);\n      }\n      commit = await commitFromHash(basisHash, dagRead);\n    }\n  }\n  return commit;\n}\n\nexport function snapshotMetaParts(\n  c: Commit<SnapshotMetaDD31>,\n  clientID: ClientID,\n): [lastMutationID: number, cookie: FrozenCookie | FrozenJSONValue] {\n  const m = c.meta;\n  const lmid = m.lastMutationIDs[clientID] ?? 0;\n  return [lmid, m.cookieJSON];\n}\n\nexport function compareCookiesForSnapshots(\n  a: Commit<SnapshotMetaDD31>,\n  b: Commit<SnapshotMetaDD31>,\n): number {\n  return compareCookies(a.meta.cookieJSON, b.meta.cookieJSON);\n}\n\n/**\n * Returns all commits from the commit with fromCommitHash to its base snapshot,\n * inclusive of both. Resulting vector is in chain-head-first order (so snapshot\n * comes last).\n */\nexport async function commitChain(\n  fromCommitHash: Hash,\n  dagRead: Read,\n): Promise<Commit<Meta>[]> {\n  let commit = await commitFromHash(fromCommitHash, dagRead);\n  const commits = [];\n  while (!commitIsSnapshot(commit)) {\n    const {meta} = commit;\n    const {basisHash} = meta;\n    if (basisHash === null) {\n      throw new Error(`Commit ${commit.chunk.hash} has no basis`);\n    }\n    commits.push(commit);\n    commit = await commitFromHash(basisHash, dagRead);\n  }\n  commits.push(commit);\n  return commits;\n}\n\nexport async function commitFromHash(\n  hash: Hash,\n  dagRead: MustGetChunk,\n): Promise<Commit<Meta>> {\n  const chunk = await dagRead.mustGetChunk(hash);\n  return fromChunk(chunk);\n}\n\nexport async function commitFromHead(\n  name: string,\n  dagRead: Read,\n): Promise<Commit<Meta>> {\n  const hash = await mustGetHeadHash(name, dagRead);\n  return commitFromHash(hash, dagRead);\n}\n\nexport type LocalMetaDD31 = {\n  readonly type: MetaType.LocalDD31;\n  readonly basisHash: Hash;\n  readonly mutationID: number;\n  readonly mutatorName: string;\n  readonly mutatorArgsJSON: FrozenJSONValue;\n  readonly originalHash: Hash | null;\n  readonly timestamp: number;\n  readonly clientID: ClientID;\n  readonly baseSnapshotHash: Hash;\n};\n\nexport type LocalMeta = LocalMetaDD31;\n\nexport function assertLocalMetaDD31(\n  v: Record<string, unknown>,\n): asserts v is LocalMetaDD31 {\n  // type already asserted\n  assertString(v.clientID);\n  assertNumber(v.mutationID);\n  assertString(v.mutatorName);\n  if (!v.mutatorName) {\n    throw new Error('Missing mutator name');\n  }\n  assertJSONValue(v.mutatorArgsJSON);\n  if (v.originalHash !== null) {\n    assertHash(v.originalHash);\n  }\n  assertNumber(v.timestamp);\n}\n\nexport function isLocalMetaDD31(meta: Meta): meta is LocalMetaDD31 {\n  return meta.type === MetaType.LocalDD31;\n}\n\nexport function assertLocalCommitDD31(\n  c: Commit<Meta>,\n): asserts c is Commit<LocalMetaDD31> {\n  assertLocalMetaDD31(c.meta);\n}\n\nexport type SnapshotMetaDD31 = {\n  readonly type: MetaType.SnapshotDD31;\n  readonly basisHash: Hash | null;\n  readonly lastMutationIDs: Record<ClientID, number>;\n  readonly cookieJSON: FrozenCookie;\n};\n\nexport type SnapshotMeta = SnapshotMetaDD31;\n\nexport function assertSnapshotMetaDD31(\n  v: Record<string, unknown>,\n): asserts v is SnapshotMetaDD31 {\n  // type already asserted\n  if (v.basisHash !== null) {\n    assertHash(v.basisHash);\n  }\n  assertJSONValue(v.cookieJSON);\n  assertLastMutationIDs(v.lastMutationIDs);\n}\n\nfunction assertLastMutationIDs(\n  v: unknown,\n): asserts v is Record<ClientID, number> {\n  assertObject(v);\n  for (const e of Object.values(v)) {\n    assertNumber(e);\n  }\n}\n\nexport type Meta = LocalMetaDD31 | SnapshotMetaDD31;\n\nexport function assertSnapshotCommitDD31(\n  c: Commit<Meta>,\n): asserts c is Commit<SnapshotMetaDD31> {\n  assertSnapshotMetaDD31(c.meta);\n}\n\nfunction isSnapshotMetaDD31(meta: Meta): meta is SnapshotMetaDD31 {\n  return meta.type === MetaType.SnapshotDD31;\n}\n\nfunction assertMeta(v: unknown): asserts v is Meta {\n  assertObject(v);\n  assertDeepFrozen(v);\n  if (v.basisHash !== null) {\n    assertString(v.basisHash);\n  }\n\n  assertNumber(v.type);\n  switch (v.type) {\n    case MetaType.LocalDD31:\n      assertLocalMetaDD31(v);\n      break;\n    case MetaType.SnapshotDD31:\n      assertSnapshotMetaDD31(v);\n      break;\n    default:\n      throw new Error(`Invalid enum value ${v.type}`);\n  }\n}\n\n/**\n * This is the type used for index definitions as defined in the Commit chunk data.\n *\n * Changing this requires a REPLICACHE_FORMAT_VERSION bump.\n */\nexport type ChunkIndexDefinition = {\n  readonly name: string;\n  readonly keyPrefix: string;\n  readonly jsonPointer: string;\n  // Used to not exist\n  readonly allowEmpty?: boolean;\n};\n\nexport function chunkIndexDefinitionEqualIgnoreName(\n  a: ChunkIndexDefinition,\n  b: ChunkIndexDefinition,\n): boolean {\n  return (\n    a.jsonPointer === b.jsonPointer &&\n    (a.allowEmpty ?? false) === (b.allowEmpty ?? false) &&\n    a.keyPrefix === b.keyPrefix\n  );\n}\n\nfunction assertChunkIndexDefinition(\n  v: unknown,\n): asserts v is ChunkIndexDefinition {\n  assertObject(v);\n  assertDeepFrozen(v);\n  assertString(v.name);\n  assertString(v.keyPrefix);\n  assertString(v.jsonPointer);\n  if (v.allowEmpty !== undefined) {\n    assertBoolean(v.allowEmpty);\n  }\n}\n\nexport function toChunkIndexDefinition(\n  name: string,\n  indexDefinition: IndexDefinition,\n): Required<ChunkIndexDefinition> {\n  return {\n    name,\n    keyPrefix: indexDefinition.prefix ?? '',\n    jsonPointer: indexDefinition.jsonPointer,\n    allowEmpty: indexDefinition.allowEmpty ?? false,\n  };\n}\n\nexport type IndexRecord = {\n  readonly definition: ChunkIndexDefinition;\n  readonly valueHash: Hash;\n};\n\nfunction assertIndexRecord(v: unknown): asserts v is IndexRecord {\n  assertObject(v);\n  assertDeepFrozen(v);\n  assertChunkIndexDefinition(v.definition);\n  assertString(v.valueHash);\n}\n\nfunction assertIndexRecords(v: unknown): asserts v is IndexRecord[] {\n  assertArray(v);\n  assertDeepFrozen(v);\n  for (const ir of v) {\n    assertIndexRecord(ir);\n  }\n}\n\nexport function newLocalDD31(\n  createChunk: CreateChunk,\n  basisHash: Hash,\n  baseSnapshotHash: Hash,\n  mutationID: number,\n  mutatorName: string,\n  mutatorArgsJSON: FrozenJSONValue,\n  originalHash: Hash | null,\n  valueHash: Hash,\n  indexes: readonly IndexRecord[],\n  timestamp: number,\n  clientID: ClientID,\n): Commit<LocalMetaDD31> {\n  const meta: LocalMetaDD31 = {\n    type: MetaType.LocalDD31,\n    basisHash,\n    baseSnapshotHash,\n    mutationID,\n    mutatorName,\n    mutatorArgsJSON,\n    originalHash,\n    timestamp,\n    clientID,\n  };\n  return commitFromCommitData(\n    createChunk,\n    makeCommitData(meta, valueHash, indexes),\n  );\n}\n\nexport function newSnapshotDD31(\n  createChunk: CreateChunk,\n  basisHash: Hash | null,\n  lastMutationIDs: Record<ClientID, number>,\n  cookieJSON: FrozenCookie,\n  valueHash: Hash,\n  indexes: readonly IndexRecord[],\n): Commit<SnapshotMetaDD31> {\n  return commitFromCommitData(\n    createChunk,\n    newSnapshotCommitDataDD31(\n      basisHash,\n      lastMutationIDs,\n      cookieJSON,\n      valueHash,\n      indexes,\n    ),\n  );\n}\n\nexport function newSnapshotCommitDataDD31(\n  basisHash: Hash | null,\n  lastMutationIDs: Record<ClientID, number>,\n  cookieJSON: FrozenCookie,\n  valueHash: Hash,\n  indexes: readonly IndexRecord[],\n): CommitData<SnapshotMetaDD31> {\n  const meta: SnapshotMetaDD31 = {\n    type: MetaType.SnapshotDD31,\n    basisHash,\n    lastMutationIDs,\n    cookieJSON,\n  };\n  return makeCommitData(meta, valueHash, indexes);\n}\n\nexport function fromChunk(chunk: Chunk): Commit<Meta> {\n  validateChunk(chunk);\n  return new Commit(chunk);\n}\n\nfunction commitFromCommitData<M extends Meta>(\n  createChunk: CreateChunk,\n  data: CommitData<M>,\n): Commit<M> {\n  return new Commit(createChunk(data, getRefs(data)));\n}\n\nexport function getRefs(data: CommitData<Meta>): Refs {\n  const refs: Set<Hash> = new Set();\n  refs.add(data.valueHash);\n  const {meta} = data;\n  switch (meta.type) {\n    case MetaType.LocalDD31:\n      meta.basisHash && refs.add(meta.basisHash);\n      // Local has weak originalHash\n      break;\n    case MetaType.SnapshotDD31:\n      // Snapshot has weak basisHash\n      break;\n    default:\n      unreachable(meta);\n  }\n\n  for (const index of data.indexes) {\n    refs.add(index.valueHash);\n  }\n\n  return toRefs(refs);\n}\n\nexport type CommitData<M extends Meta> = FrozenTag<{\n  readonly meta: M;\n  readonly valueHash: Hash;\n  readonly indexes: readonly IndexRecord[];\n}>;\n\nexport function makeCommitData<M extends Meta>(\n  meta: M,\n  valueHash: Hash,\n  indexes: readonly IndexRecord[],\n): CommitData<M> {\n  return deepFreeze({\n    meta,\n    valueHash,\n    indexes,\n  }) as unknown as CommitData<M>;\n}\n\nexport function assertCommitData(v: unknown): asserts v is CommitData<Meta> {\n  if (skipCommitDataAsserts) {\n    return;\n  }\n\n  assertObject(v);\n  assertDeepFrozen(v);\n  assertMeta(v.meta);\n  assertString(v.valueHash);\n  assertIndexRecords(v.indexes);\n}\n\nfunction validateChunk(chunk: Chunk): asserts chunk is Chunk<CommitData<Meta>> {\n  const {data} = chunk;\n  assertCommitData(data);\n\n  const seen = new Set();\n  for (const index of data.indexes) {\n    const {name} = index.definition;\n    if (seen.has(name)) {\n      throw new Error(`Duplicate index ${name}`);\n    }\n    seen.add(name);\n  }\n}\n"],"mappings":"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"}

package/out/replicache/src/db/index.js

@@ -1,134 +1,91 @@
-import { Remove, Add } from "./index-operation-enum.js";
-class IndexRead {
-  meta;
-  map;
-  constructor(meta, map) {
-    this.meta = meta;
-    this.map = map;
-  }
-}
-class IndexWrite extends IndexRead {
-  // Note: does not update self.meta.valueHash (doesn't need to at this point as flush
-  // is only called during commit.)
-  flush() {
-    return this.map.flush();
-  }
-  clear() {
-    return this.map.clear();
-  }
-}
+//#region ../replicache/src/db/index.ts
+var IndexRead = class {
+	meta;
+	map;
+	constructor(meta, map) {
+		this.meta = meta;
+		this.map = map;
+	}
+};
+var IndexWrite = class extends IndexRead {
+	flush() {
+		return this.map.flush();
+	}
+	clear() {
+		return this.map.clear();
+	}
+};
 async function indexValue(lc, index, op, key, val, jsonPointer, allowEmpty) {
-  try {
-    for (const entry of getIndexKeys(key, val, jsonPointer, allowEmpty)) {
-      switch (op) {
-        case Add:
-          await index.put(entry, val);
-          break;
-        case Remove:
-          await index.del(entry);
-          break;
-      }
-    }
-  } catch (e) {
-    lc.info?.("Not indexing value", val, ":", e);
-  }
+	try {
+		for (const entry of getIndexKeys(key, val, jsonPointer, allowEmpty)) switch (op) {
+			case 0:
+				await index.put(entry, val);
+				break;
+			case 1:
+				await index.del(entry);
+				break;
+		}
+	} catch (e) {
+		lc.info?.("Not indexing value", val, ":", e);
+	}
 }
 function getIndexKeys(primary, value, jsonPointer, allowEmpty) {
-  const target = evaluateJSONPointer(value, jsonPointer);
-  if (target === void 0) {
-    if (allowEmpty) {
-      return [];
-    }
-    throw new Error(`No value at path: ${jsonPointer}`);
-  }
-  const values = Array.isArray(target) ? target : [target];
-  const indexKeys = [];
-  for (const value2 of values) {
-    if (typeof value2 === "string") {
-      indexKeys.push(encodeIndexKey([value2, primary]));
-    } else {
-      throw new Error("Unsupported target type");
-    }
-  }
-  return indexKeys;
+	const target = evaluateJSONPointer(value, jsonPointer);
+	if (target === void 0) {
+		if (allowEmpty) return [];
+		throw new Error(`No value at path: ${jsonPointer}`);
+	}
+	const values = Array.isArray(target) ? target : [target];
+	const indexKeys = [];
+	for (const value of values) if (typeof value === "string") indexKeys.push(encodeIndexKey([value, primary]));
+	else throw new Error("Unsupported target type");
+	return indexKeys;
 }
-const KEY_VERSION_0 = "\0";
-const KEY_SEPARATOR = "\0";
 function encodeIndexKey(indexKey) {
-  const secondary = indexKey[0];
-  const primary = indexKey[1];
-  if (secondary.includes("\0")) {
-    throw new Error("Secondary key cannot contain null byte");
-  }
-  return KEY_VERSION_0 + secondary + KEY_SEPARATOR + primary;
+	const secondary = indexKey[0];
+	const primary = indexKey[1];
+	if (secondary.includes("\0")) throw new Error("Secondary key cannot contain null byte");
+	return "\0" + secondary + "\0" + primary;
 }
 function encodeIndexScanKey(secondary, primary) {
-  const k = encodeIndexKey([secondary, primary || ""]);
-  if (primary === void 0) {
-    return k.slice(0, k.length - 1);
-  }
-  return k;
+	const k = encodeIndexKey([secondary, primary || ""]);
+	if (primary === void 0) return k.slice(0, k.length - 1);
+	return k;
 }
 function decodeIndexKey(encodedIndexKey) {
-  if (encodedIndexKey[0] !== KEY_VERSION_0) {
-    throw new Error("Invalid version");
-  }
-  const versionLen = KEY_VERSION_0.length;
-  const separatorLen = KEY_SEPARATOR.length;
-  const separatorOffset = encodedIndexKey.indexOf(KEY_SEPARATOR, versionLen);
-  if (separatorOffset === -1) {
-    throw new Error("Invalid formatting");
-  }
-  const secondary = encodedIndexKey.slice(versionLen, separatorOffset);
-  const primary = encodedIndexKey.slice(separatorOffset + separatorLen);
-  return [secondary, primary];
+	if (encodedIndexKey[0] !== "\0") throw new Error("Invalid version");
+	const versionLen = 1;
+	const separatorLen = 1;
+	const separatorOffset = encodedIndexKey.indexOf("\0", versionLen);
+	if (separatorOffset === -1) throw new Error("Invalid formatting");
+	return [encodedIndexKey.slice(versionLen, separatorOffset), encodedIndexKey.slice(separatorOffset + separatorLen)];
 }
 function evaluateJSONPointer(value, pointer) {
-  function parseIndex(s) {
-    if (s.startsWith("+") || s.startsWith("0") && s.length !== 1) {
-      return void 0;
-    }
-    return parseInt(s, 10);
-  }
-  if (pointer === "") {
-    return value;
-  }
-  if (!pointer.startsWith("/")) {
-    throw new Error(`Invalid JSON pointer: ${pointer}`);
-  }
-  const tokens = pointer.split("/").slice(1).map((x) => x.replace(/~1/g, "/").replace(/~0/g, "~"));
-  let target = value;
-  for (const token of tokens) {
-    let targetOpt;
-    if (Array.isArray(target)) {
-      const i = parseIndex(token);
-      if (i === void 0) {
-        return void 0;
-      }
-      targetOpt = target[i];
-    } else if (target === null) {
-      return void 0;
-    } else if (typeof target === "object") {
-      target = target;
-      targetOpt = target[token];
-    }
-    if (targetOpt === void 0) {
-      return void 0;
-    }
-    target = targetOpt;
-  }
-  return target;
+	function parseIndex(s) {
+		if (s.startsWith("+") || s.startsWith("0") && s.length !== 1) return;
+		return parseInt(s, 10);
+	}
+	if (pointer === "") return value;
+	if (!pointer.startsWith("/")) throw new Error(`Invalid JSON pointer: ${pointer}`);
+	const tokens = pointer.split("/").slice(1).map((x) => x.replace(/~1/g, "/").replace(/~0/g, "~"));
+	let target = value;
+	for (const token of tokens) {
+		let targetOpt;
+		if (Array.isArray(target)) {
+			const i = parseIndex(token);
+			if (i === void 0) return;
+			targetOpt = target[i];
+		} else if (target === null) return;
+		else if (typeof target === "object") {
+			target = target;
+			targetOpt = target[token];
+		}
+		if (targetOpt === void 0) return;
+		target = targetOpt;
+	}
+	return target;
 }
-export {
-  IndexRead,
-  IndexWrite,
-  KEY_SEPARATOR,
-  KEY_VERSION_0,
-  decodeIndexKey,
-  encodeIndexKey,
-  encodeIndexScanKey,
-  evaluateJSONPointer,
-  getIndexKeys,
-  indexValue
-};
-//# sourceMappingURL=index.js.map
+//#endregion
+export { IndexRead, IndexWrite, decodeIndexKey, encodeIndexScanKey, indexValue };
+
+//# sourceMappingURL=index.js.map

package/out/replicache/src/db/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../../../replicache/src/db/index.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport type {BTreeRead} from '../btree/read.ts';\nimport type {BTreeWrite} from '../btree/write.ts';\nimport type {FrozenJSONObject, FrozenJSONValue} from '../frozen-json.ts';\nimport type {Hash} from '../hash.ts';\nimport type {IndexRecord} from './commit.ts';\nimport * as IndexOperation from './index-operation-enum.ts';\n\ntype IndexOperation = Enum<typeof IndexOperation>;\n\nexport class IndexRead<BTree = BTreeRead> {\n  readonly meta: IndexRecord;\n  readonly map: BTree;\n\n  constructor(meta: IndexRecord, map: BTree) {\n    this.meta = meta;\n    this.map = map;\n  }\n}\n\nexport class IndexWrite extends IndexRead<BTreeWrite> {\n  // Note: does not update self.meta.valueHash (doesn't need to at this point as flush\n  // is only called during commit.)\n  flush(): Promise<Hash> {\n    return this.map.flush();\n  }\n\n  clear(): Promise<void> {\n    return this.map.clear();\n  }\n}\n\n// Index or de-index a single primary entry.\nexport async function indexValue(\n  lc: LogContext,\n  index: BTreeWrite,\n  op: IndexOperation,\n  key: string,\n  val: FrozenJSONValue,\n  jsonPointer: string,\n  allowEmpty: boolean,\n): Promise<void> {\n  try {\n    for (const entry of getIndexKeys(key, val, jsonPointer, allowEmpty)) {\n      switch (op) {\n        case IndexOperation.Add:\n          await index.put(entry, val);\n          break;\n        case IndexOperation.Remove:\n          await index.del(entry);\n          break;\n      }\n    }\n  } catch (e) {\n    // Right now all the errors that index_value() returns are customers dev\n    // problems: either the value is not json, the pointer is into nowhere, etc.\n    // So we ignore them.\n    lc.info?.('Not indexing value', val, ':', e);\n  }\n}\n\n// Gets the set of index keys for a given primary key and value.\nexport function getIndexKeys(\n  primary: string,\n  value: FrozenJSONValue,\n  jsonPointer: string,\n  allowEmpty: boolean,\n): string[] {\n  const target = evaluateJSONPointer(value, jsonPointer);\n  if (target === undefined) {\n    if (allowEmpty) {\n      return [];\n    }\n    throw new Error(`No value at path: ${jsonPointer}`);\n  }\n\n  const values = Array.isArray(target) ? target : [target];\n\n  const indexKeys: string[] = [];\n  for (const value of values) {\n    if (typeof value === 'string') {\n      indexKeys.push(encodeIndexKey([value, primary]));\n    } else {\n      throw new Error('Unsupported target type');\n    }\n  }\n\n  return indexKeys;\n}\n\nexport const KEY_VERSION_0 = '\\u0000';\nexport const KEY_SEPARATOR = '\\u0000';\n\n/**\n * When using indexes the key is a tuple of the secondary key and the primary\n * key.\n */\nexport type IndexKey = readonly [secondary: string, primary: string];\n\n// An index key is encoded to vec of bytes in the following order:\n//   - key version byte(s), followed by\n//   - the secondary key bytes (which for now is a UTF8 encoded string), followed by\n//   - the key separator, a null byte, followed by\n//   - the primary key bytes\n//\n// The null separator byte ensures that if a secondary key A is longer than B then\n// A always sorts after B. Appending the primary key ensures index keys with\n// identical secondary keys sort in primary key order. Secondary keys must not\n// contain a zero (null) byte.\nexport function encodeIndexKey(indexKey: IndexKey): string {\n  const secondary = indexKey[0];\n  const primary = indexKey[1];\n\n  if (secondary.includes('\\u0000')) {\n    throw new Error('Secondary key cannot contain null byte');\n  }\n  return KEY_VERSION_0 + secondary + KEY_SEPARATOR + primary;\n}\n\n// Returns bytes that can be used to scan for the given secondary index value.\n//\n// Consider a scan for start_secondary_key=\"a\" (97). We want to scan with scan\n// key [0, 97]. We could also scan with [0, 97, 0], but then we couldn't use\n// this function for prefix scans, so we lop off the null byte. If we want\n// the scan to be exclusive, we scan with the next greater value, [0, 97, 1]\n// (we disallow zero bytes in secondary keys).\n//\n// Now it gets a little tricky. We also want to be able to scan using the\n// primary key, start_key. When we do this we have to encode the scan key\n// a little differently We essentially have to fix the value of the\n// secondary key so we can vary the start_key. That is, the match on\n// start_secondary_key becomes an exact match.\n//\n// Consider the scan for start_secondary_key=\"a\" and start_key=[2]. We want\n// to scan with [0, 97, 0, 2]. If we want exclusive we want to scan with\n// the next highest value, [0, 97, 0, 2, 0] (zero bytes are allowed in primary\n// keys). So far so good. It is important to notice that we need to\n// be able to distinguish between not wanting use start_key and wanting to\n// use start_key=[]. In the former case we want to scan with the secondary\n// key value, possibly followed by a 1 with no trailing zero byte ([0, 97]\n// or [0, 97, 1]). In the latter case we want to scan by the secondary\n// key value, followed by the zero byte, followed by the primary key value\n// and another zero if it is exclusive ([0, 97, 0] or [0, 97, 0, 0]).\n// This explains why we need the Option around start_key.\nexport function encodeIndexScanKey(\n  secondary: string,\n  primary: string | undefined,\n): string {\n  const k = encodeIndexKey([secondary, primary || '']);\n  if (primary === undefined) {\n    return k.slice(0, k.length - 1);\n  }\n  return k;\n}\n\n// Decodes an IndexKey encoded by encode_index_key.\nexport function decodeIndexKey(encodedIndexKey: string): IndexKey {\n  if (encodedIndexKey[0] !== KEY_VERSION_0) {\n    throw new Error('Invalid version');\n  }\n\n  const versionLen = KEY_VERSION_0.length;\n  const separatorLen = KEY_SEPARATOR.length;\n  const separatorOffset = encodedIndexKey.indexOf(KEY_SEPARATOR, versionLen);\n  if (separatorOffset === -1) {\n    throw new Error('Invalid formatting');\n  }\n\n  const secondary = encodedIndexKey.slice(versionLen, separatorOffset);\n  const primary = encodedIndexKey.slice(separatorOffset + separatorLen);\n  return [secondary, primary];\n}\n\nexport function evaluateJSONPointer(\n  value: FrozenJSONValue,\n  pointer: string,\n): FrozenJSONValue | undefined {\n  function parseIndex(s: string): number | undefined {\n    if (s.startsWith('+') || (s.startsWith('0') && s.length !== 1)) {\n      return undefined;\n    }\n    return parseInt(s, 10);\n  }\n\n  if (pointer === '') {\n    return value;\n  }\n  if (!pointer.startsWith('/')) {\n    throw new Error(`Invalid JSON pointer: ${pointer}`);\n  }\n\n  const tokens = pointer\n    .split('/')\n    .slice(1)\n    .map(x => x.replace(/~1/g, '/').replace(/~0/g, '~'));\n\n  let target = value;\n  for (const token of tokens) {\n    let targetOpt;\n    if (Array.isArray(target)) {\n      const i = parseIndex(token);\n      if (i === undefined) {\n        return undefined;\n      }\n      targetOpt = target[i];\n    } else if (target === null) {\n      return undefined;\n    } else if (typeof target === 'object') {\n      target = target as FrozenJSONObject;\n      targetOpt = target[token];\n    }\n    if (targetOpt === undefined) {\n      return undefined;\n    }\n    target = targetOpt;\n  }\n  return target;\n}\n"],"names":["IndexOperation.Add","IndexOperation.Remove","value"],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../../../replicache/src/db/index.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport type {BTreeRead} from '../btree/read.ts';\nimport type {BTreeWrite} from '../btree/write.ts';\nimport type {FrozenJSONObject, FrozenJSONValue} from '../frozen-json.ts';\nimport type {Hash} from '../hash.ts';\nimport type {IndexRecord} from './commit.ts';\nimport * as IndexOperation from './index-operation-enum.ts';\n\ntype IndexOperation = Enum<typeof IndexOperation>;\n\nexport class IndexRead<BTree = BTreeRead> {\n  readonly meta: IndexRecord;\n  readonly map: BTree;\n\n  constructor(meta: IndexRecord, map: BTree) {\n    this.meta = meta;\n    this.map = map;\n  }\n}\n\nexport class IndexWrite extends IndexRead<BTreeWrite> {\n  // Note: does not update self.meta.valueHash (doesn't need to at this point as flush\n  // is only called during commit.)\n  flush(): Promise<Hash> {\n    return this.map.flush();\n  }\n\n  clear(): Promise<void> {\n    return this.map.clear();\n  }\n}\n\n// Index or de-index a single primary entry.\nexport async function indexValue(\n  lc: LogContext,\n  index: BTreeWrite,\n  op: IndexOperation,\n  key: string,\n  val: FrozenJSONValue,\n  jsonPointer: string,\n  allowEmpty: boolean,\n): Promise<void> {\n  try {\n    for (const entry of getIndexKeys(key, val, jsonPointer, allowEmpty)) {\n      switch (op) {\n        case IndexOperation.Add:\n          await index.put(entry, val);\n          break;\n        case IndexOperation.Remove:\n          await index.del(entry);\n          break;\n      }\n    }\n  } catch (e) {\n    // Right now all the errors that index_value() returns are customers dev\n    // problems: either the value is not json, the pointer is into nowhere, etc.\n    // So we ignore them.\n    lc.info?.('Not indexing value', val, ':', e);\n  }\n}\n\n// Gets the set of index keys for a given primary key and value.\nexport function getIndexKeys(\n  primary: string,\n  value: FrozenJSONValue,\n  jsonPointer: string,\n  allowEmpty: boolean,\n): string[] {\n  const target = evaluateJSONPointer(value, jsonPointer);\n  if (target === undefined) {\n    if (allowEmpty) {\n      return [];\n    }\n    throw new Error(`No value at path: ${jsonPointer}`);\n  }\n\n  const values = Array.isArray(target) ? target : [target];\n\n  const indexKeys: string[] = [];\n  for (const value of values) {\n    if (typeof value === 'string') {\n      indexKeys.push(encodeIndexKey([value, primary]));\n    } else {\n      throw new Error('Unsupported target type');\n    }\n  }\n\n  return indexKeys;\n}\n\nexport const KEY_VERSION_0 = '\\u0000';\nexport const KEY_SEPARATOR = '\\u0000';\n\n/**\n * When using indexes the key is a tuple of the secondary key and the primary\n * key.\n */\nexport type IndexKey = readonly [secondary: string, primary: string];\n\n// An index key is encoded to vec of bytes in the following order:\n//   - key version byte(s), followed by\n//   - the secondary key bytes (which for now is a UTF8 encoded string), followed by\n//   - the key separator, a null byte, followed by\n//   - the primary key bytes\n//\n// The null separator byte ensures that if a secondary key A is longer than B then\n// A always sorts after B. Appending the primary key ensures index keys with\n// identical secondary keys sort in primary key order. Secondary keys must not\n// contain a zero (null) byte.\nexport function encodeIndexKey(indexKey: IndexKey): string {\n  const secondary = indexKey[0];\n  const primary = indexKey[1];\n\n  if (secondary.includes('\\u0000')) {\n    throw new Error('Secondary key cannot contain null byte');\n  }\n  return KEY_VERSION_0 + secondary + KEY_SEPARATOR + primary;\n}\n\n// Returns bytes that can be used to scan for the given secondary index value.\n//\n// Consider a scan for start_secondary_key=\"a\" (97). We want to scan with scan\n// key [0, 97]. We could also scan with [0, 97, 0], but then we couldn't use\n// this function for prefix scans, so we lop off the null byte. If we want\n// the scan to be exclusive, we scan with the next greater value, [0, 97, 1]\n// (we disallow zero bytes in secondary keys).\n//\n// Now it gets a little tricky. We also want to be able to scan using the\n// primary key, start_key. When we do this we have to encode the scan key\n// a little differently We essentially have to fix the value of the\n// secondary key so we can vary the start_key. That is, the match on\n// start_secondary_key becomes an exact match.\n//\n// Consider the scan for start_secondary_key=\"a\" and start_key=[2]. We want\n// to scan with [0, 97, 0, 2]. If we want exclusive we want to scan with\n// the next highest value, [0, 97, 0, 2, 0] (zero bytes are allowed in primary\n// keys). So far so good. It is important to notice that we need to\n// be able to distinguish between not wanting use start_key and wanting to\n// use start_key=[]. In the former case we want to scan with the secondary\n// key value, possibly followed by a 1 with no trailing zero byte ([0, 97]\n// or [0, 97, 1]). In the latter case we want to scan by the secondary\n// key value, followed by the zero byte, followed by the primary key value\n// and another zero if it is exclusive ([0, 97, 0] or [0, 97, 0, 0]).\n// This explains why we need the Option around start_key.\nexport function encodeIndexScanKey(\n  secondary: string,\n  primary: string | undefined,\n): string {\n  const k = encodeIndexKey([secondary, primary || '']);\n  if (primary === undefined) {\n    return k.slice(0, k.length - 1);\n  }\n  return k;\n}\n\n// Decodes an IndexKey encoded by encode_index_key.\nexport function decodeIndexKey(encodedIndexKey: string): IndexKey {\n  if (encodedIndexKey[0] !== KEY_VERSION_0) {\n    throw new Error('Invalid version');\n  }\n\n  const versionLen = KEY_VERSION_0.length;\n  const separatorLen = KEY_SEPARATOR.length;\n  const separatorOffset = encodedIndexKey.indexOf(KEY_SEPARATOR, versionLen);\n  if (separatorOffset === -1) {\n    throw new Error('Invalid formatting');\n  }\n\n  const secondary = encodedIndexKey.slice(versionLen, separatorOffset);\n  const primary = encodedIndexKey.slice(separatorOffset + separatorLen);\n  return [secondary, primary];\n}\n\nexport function evaluateJSONPointer(\n  value: FrozenJSONValue,\n  pointer: string,\n): FrozenJSONValue | undefined {\n  function parseIndex(s: string): number | undefined {\n    if (s.startsWith('+') || (s.startsWith('0') && s.length !== 1)) {\n      return undefined;\n    }\n    return parseInt(s, 10);\n  }\n\n  if (pointer === '') {\n    return value;\n  }\n  if (!pointer.startsWith('/')) {\n    throw new Error(`Invalid JSON pointer: ${pointer}`);\n  }\n\n  const tokens = pointer\n    .split('/')\n    .slice(1)\n    .map(x => x.replace(/~1/g, '/').replace(/~0/g, '~'));\n\n  let target = value;\n  for (const token of tokens) {\n    let targetOpt;\n    if (Array.isArray(target)) {\n      const i = parseIndex(token);\n      if (i === undefined) {\n        return undefined;\n      }\n      targetOpt = target[i];\n    } else if (target === null) {\n      return undefined;\n    } else if (typeof target === 'object') {\n      target = target as FrozenJSONObject;\n      targetOpt = target[token];\n    }\n    if (targetOpt === undefined) {\n      return undefined;\n    }\n    target = targetOpt;\n  }\n  return target;\n}\n"],"mappings":";AAWA,IAAa,YAAb,MAA0C;CACxC;CACA;CAEA,YAAY,MAAmB,KAAY;AACzC,OAAK,OAAO;AACZ,OAAK,MAAM;;;AAIf,IAAa,aAAb,cAAgC,UAAsB;CAGpD,QAAuB;AACrB,SAAO,KAAK,IAAI,OAAO;;CAGzB,QAAuB;AACrB,SAAO,KAAK,IAAI,OAAO;;;AAK3B,eAAsB,WACpB,IACA,OACA,IACA,KACA,KACA,aACA,YACe;AACf,KAAI;AACF,OAAK,MAAM,SAAS,aAAa,KAAK,KAAK,aAAa,WAAW,CACjE,SAAQ,IAAR;GACE,KAAK;AACH,UAAM,MAAM,IAAI,OAAO,IAAI;AAC3B;GACF,KAAK;AACH,UAAM,MAAM,IAAI,MAAM;AACtB;;UAGC,GAAG;AAIV,KAAG,OAAO,sBAAsB,KAAK,KAAK,EAAE;;;AAKhD,SAAgB,aACd,SACA,OACA,aACA,YACU;CACV,MAAM,SAAS,oBAAoB,OAAO,YAAY;AACtD,KAAI,WAAW,KAAA,GAAW;AACxB,MAAI,WACF,QAAO,EAAE;AAEX,QAAM,IAAI,MAAM,qBAAqB,cAAc;;CAGrD,MAAM,SAAS,MAAM,QAAQ,OAAO,GAAG,SAAS,CAAC,OAAO;CAExD,MAAM,YAAsB,EAAE;AAC9B,MAAK,MAAM,SAAS,OAClB,KAAI,OAAO,UAAU,SACnB,WAAU,KAAK,eAAe,CAAC,OAAO,QAAQ,CAAC,CAAC;KAEhD,OAAM,IAAI,MAAM,0BAA0B;AAI9C,QAAO;;AAsBT,SAAgB,eAAe,UAA4B;CACzD,MAAM,YAAY,SAAS;CAC3B,MAAM,UAAU,SAAS;AAEzB,KAAI,UAAU,SAAS,KAAS,CAC9B,OAAM,IAAI,MAAM,yCAAyC;AAE3D,QAAA,OAAuB,YAAA,OAA4B;;AA4BrD,SAAgB,mBACd,WACA,SACQ;CACR,MAAM,IAAI,eAAe,CAAC,WAAW,WAAW,GAAG,CAAC;AACpD,KAAI,YAAY,KAAA,EACd,QAAO,EAAE,MAAM,GAAG,EAAE,SAAS,EAAE;AAEjC,QAAO;;AAIT,SAAgB,eAAe,iBAAmC;AAChE,KAAI,gBAAgB,OAAA,KAClB,OAAM,IAAI,MAAM,kBAAkB;CAGpC,MAAM,aAAa;CACnB,MAAM,eAAe;CACrB,MAAM,kBAAkB,gBAAgB,QAAA,MAAuB,WAAW;AAC1E,KAAI,oBAAoB,GACtB,OAAM,IAAI,MAAM,qBAAqB;AAKvC,QAAO,CAFW,gBAAgB,MAAM,YAAY,gBAAgB,EACpD,gBAAgB,MAAM,kBAAkB,aAAa,CAC1C;;AAG7B,SAAgB,oBACd,OACA,SAC6B;CAC7B,SAAS,WAAW,GAA+B;AACjD,MAAI,EAAE,WAAW,IAAI,IAAK,EAAE,WAAW,IAAI,IAAI,EAAE,WAAW,EAC1D;AAEF,SAAO,SAAS,GAAG,GAAG;;AAGxB,KAAI,YAAY,GACd,QAAO;AAET,KAAI,CAAC,QAAQ,WAAW,IAAI,CAC1B,OAAM,IAAI,MAAM,yBAAyB,UAAU;CAGrD,MAAM,SAAS,QACZ,MAAM,IAAI,CACV,MAAM,EAAE,CACR,KAAI,MAAK,EAAE,QAAQ,OAAO,IAAI,CAAC,QAAQ,OAAO,IAAI,CAAC;CAEtD,IAAI,SAAS;AACb,MAAK,MAAM,SAAS,QAAQ;EAC1B,IAAI;AACJ,MAAI,MAAM,QAAQ,OAAO,EAAE;GACzB,MAAM,IAAI,WAAW,MAAM;AAC3B,OAAI,MAAM,KAAA,EACR;AAEF,eAAY,OAAO;aACV,WAAW,KACpB;WACS,OAAO,WAAW,UAAU;AACrC,YAAS;AACT,eAAY,OAAO;;AAErB,MAAI,cAAc,KAAA,EAChB;AAEF,WAAS;;AAEX,QAAO"}

package/out/replicache/src/db/read.js

@@ -1,72 +1,56 @@
 import { BTreeRead } from "../btree/read.js";
-import { commitFromHead, commitFromHash, DEFAULT_HEAD_NAME } from "./commit.js";
+import { DEFAULT_HEAD_NAME, commitFromHash, commitFromHead } from "./commit.js";
 import { IndexRead } from "./index.js";
-class Read {
-  #dagRead;
-  map;
-  indexes;
-  constructor(dagRead, map, indexes) {
-    this.#dagRead = dagRead;
-    this.map = map;
-    this.indexes = indexes;
-  }
-  has(key) {
-    return this.map.has(key);
-  }
-  get(key) {
-    return this.map.get(key);
-  }
-  isEmpty() {
-    return this.map.isEmpty();
-  }
-  getMapForIndex(indexName) {
-    const idx = this.indexes.get(indexName);
-    if (idx === void 0) {
-      throw new Error(`Unknown index name: ${indexName}`);
-    }
-    return idx.map;
-  }
-  get closed() {
-    return this.#dagRead.closed;
-  }
-  close() {
-    this.#dagRead.release();
-  }
-}
+//#region ../replicache/src/db/read.ts
+var Read = class {
+	#dagRead;
+	map;
+	indexes;
+	constructor(dagRead, map, indexes) {
+		this.#dagRead = dagRead;
+		this.map = map;
+		this.indexes = indexes;
+	}
+	has(key) {
+		return this.map.has(key);
+	}
+	get(key) {
+		return this.map.get(key);
+	}
+	isEmpty() {
+		return this.map.isEmpty();
+	}
+	getMapForIndex(indexName) {
+		const idx = this.indexes.get(indexName);
+		if (idx === void 0) throw new Error(`Unknown index name: ${indexName}`);
+		return idx.map;
+	}
+	get closed() {
+		return this.#dagRead.closed;
+	}
+	close() {
+		this.#dagRead.release();
+	}
+};
 function readFromDefaultHead(dagRead, formatVersion) {
-  return readFromHead(DEFAULT_HEAD_NAME, dagRead, formatVersion);
+	return readFromHead(DEFAULT_HEAD_NAME, dagRead, formatVersion);
 }
 async function readFromHead(name, dagRead, formatVersion) {
-  const commit = await commitFromHead(name, dagRead);
-  return readFromCommit(commit, dagRead, formatVersion);
+	return readFromCommit(await commitFromHead(name, dagRead), dagRead, formatVersion);
 }
 async function readFromHash(hash, dagRead, formatVersion) {
-  const commit = await commitFromHash(hash, dagRead);
-  return readFromCommit(commit, dagRead, formatVersion);
+	return readFromCommit(await commitFromHash(hash, dagRead), dagRead, formatVersion);
 }
 function readFromCommit(commit, dagRead, formatVersion) {
-  const indexes = readIndexesForRead(commit, dagRead, formatVersion);
-  const map = new BTreeRead(dagRead, formatVersion, commit.valueHash);
-  return new Read(dagRead, map, indexes);
+	const indexes = readIndexesForRead(commit, dagRead, formatVersion);
+	return new Read(dagRead, new BTreeRead(dagRead, formatVersion, commit.valueHash), indexes);
 }
 function readIndexesForRead(commit, dagRead, formatVersion) {
-  const m = /* @__PURE__ */ new Map();
-  for (const index of commit.indexes) {
-    m.set(
-      index.definition.name,
-      new IndexRead(
-        index,
-        new BTreeRead(dagRead, formatVersion, index.valueHash)
-      )
-    );
-  }
-  return m;
+	const m = /* @__PURE__ */ new Map();
+	for (const index of commit.indexes) m.set(index.definition.name, new IndexRead(index, new BTreeRead(dagRead, formatVersion, index.valueHash)));
+	return m;
 }
-export {
-  Read,
-  readFromDefaultHead,
-  readFromHash,
-  readFromHead,
-  readIndexesForRead
-};
-//# sourceMappingURL=read.js.map
+//#endregion
+export { Read, readFromDefaultHead, readFromHash, readIndexesForRead };
+
+//# sourceMappingURL=read.js.map

package/out/replicache/src/db/read.js.map

@@ -1 +1 @@
-{"version":3,"file":"read.js","sources":["../../../../../replicache/src/db/read.ts"],"sourcesContent":["import type {Enum} from '../../../shared/src/enum.ts';\nimport {BTreeRead} from '../btree/read.ts';\nimport type {Read as DagRead} from '../dag/store.ts';\nimport type * as FormatVersion from '../format-version-enum.ts';\nimport type {FrozenJSONValue} from '../frozen-json.ts';\nimport type {Hash} from '../hash.ts';\nimport type {Commit} from './commit.ts';\nimport {\n  DEFAULT_HEAD_NAME,\n  type Meta,\n  commitFromHash,\n  commitFromHead,\n} from './commit.ts';\nimport {IndexRead} from './index.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nexport class Read {\n  readonly #dagRead: DagRead;\n  map: BTreeRead;\n  readonly indexes: Map<string, IndexRead>;\n\n  constructor(\n    dagRead: DagRead,\n    map: BTreeRead,\n    indexes: Map<string, IndexRead>,\n  ) {\n    this.#dagRead = dagRead;\n    this.map = map;\n    this.indexes = indexes;\n  }\n\n  has(key: string): Promise<boolean> {\n    return this.map.has(key);\n  }\n\n  get(key: string): Promise<FrozenJSONValue | undefined> {\n    return this.map.get(key);\n  }\n\n  isEmpty(): Promise<boolean> {\n    return this.map.isEmpty();\n  }\n\n  getMapForIndex(indexName: string): BTreeRead {\n    const idx = this.indexes.get(indexName);\n    if (idx === undefined) {\n      throw new Error(`Unknown index name: ${indexName}`);\n    }\n    return idx.map;\n  }\n\n  get closed(): boolean {\n    return this.#dagRead.closed;\n  }\n\n  close(): void {\n    this.#dagRead.release();\n  }\n}\n\nexport function readFromDefaultHead(\n  dagRead: DagRead,\n  formatVersion: FormatVersion,\n): Promise<Read> {\n  return readFromHead(DEFAULT_HEAD_NAME, dagRead, formatVersion);\n}\n\nexport async function readFromHead(\n  name: string,\n  dagRead: DagRead,\n  formatVersion: FormatVersion,\n): Promise<Read> {\n  const commit = await commitFromHead(name, dagRead);\n  return readFromCommit(commit, dagRead, formatVersion);\n}\n\nexport async function readFromHash(\n  hash: Hash,\n  dagRead: DagRead,\n  formatVersion: FormatVersion,\n): Promise<Read> {\n  const commit = await commitFromHash(hash, dagRead);\n  return readFromCommit(commit, dagRead, formatVersion);\n}\n\nfunction readFromCommit(\n  commit: Commit<Meta>,\n  dagRead: DagRead,\n  formatVersion: FormatVersion,\n): Read {\n  const indexes = readIndexesForRead(commit, dagRead, formatVersion);\n  const map = new BTreeRead(dagRead, formatVersion, commit.valueHash);\n  return new Read(dagRead, map, indexes);\n}\n\nexport function readIndexesForRead(\n  commit: Commit<Meta>,\n  dagRead: DagRead,\n  formatVersion: FormatVersion,\n): Map<string, IndexRead> {\n  const m = new Map();\n  for (const index of commit.indexes) {\n    m.set(\n      index.definition.name,\n      new IndexRead(\n        index,\n        new BTreeRead(dagRead, formatVersion, index.valueHash),\n      ),\n    );\n  }\n  return m;\n}\n"],"names":[],"mappings":";;;AAiBO,MAAM,KAAK;AAAA,EACP;AAAA,EACT;AAAA,EACS;AAAA,EAET,YACE,SACA,KACA,SACA;AACA,SAAK,WAAW;AAChB,SAAK,MAAM;AACX,SAAK,UAAU;AAAA,EACjB;AAAA,EAEA,IAAI,KAA+B;AACjC,WAAO,KAAK,IAAI,IAAI,GAAG;AAAA,EACzB;AAAA,EAEA,IAAI,KAAmD;AACrD,WAAO,KAAK,IAAI,IAAI,GAAG;AAAA,EACzB;AAAA,EAEA,UAA4B;AAC1B,WAAO,KAAK,IAAI,QAAA;AAAA,EAClB;AAAA,EAEA,eAAe,WAA8B;AAC3C,UAAM,MAAM,KAAK,QAAQ,IAAI,SAAS;AACtC,QAAI,QAAQ,QAAW;AACrB,YAAM,IAAI,MAAM,uBAAuB,SAAS,EAAE;AAAA,IACpD;AACA,WAAO,IAAI;AAAA,EACb;AAAA,EAEA,IAAI,SAAkB;AACpB,WAAO,KAAK,SAAS;AAAA,EACvB;AAAA,EAEA,QAAc;AACZ,SAAK,SAAS,QAAA;AAAA,EAChB;AACF;AAEO,SAAS,oBACd,SACA,eACe;AACf,SAAO,aAAa,mBAAmB,SAAS,aAAa;AAC/D;AAEA,eAAsB,aACpB,MACA,SACA,eACe;AACf,QAAM,SAAS,MAAM,eAAe,MAAM,OAAO;AACjD,SAAO,eAAe,QAAQ,SAAS,aAAa;AACtD;AAEA,eAAsB,aACpB,MACA,SACA,eACe;AACf,QAAM,SAAS,MAAM,eAAe,MAAM,OAAO;AACjD,SAAO,eAAe,QAAQ,SAAS,aAAa;AACtD;AAEA,SAAS,eACP,QACA,SACA,eACM;AACN,QAAM,UAAU,mBAAmB,QAAQ,SAAS,aAAa;AACjE,QAAM,MAAM,IAAI,UAAU,SAAS,eAAe,OAAO,SAAS;AAClE,SAAO,IAAI,KAAK,SAAS,KAAK,OAAO;AACvC;AAEO,SAAS,mBACd,QACA,SACA,eACwB;AACxB,QAAM,wBAAQ,IAAA;AACd,aAAW,SAAS,OAAO,SAAS;AAClC,MAAE;AAAA,MACA,MAAM,WAAW;AAAA,MACjB,IAAI;AAAA,QACF;AAAA,QACA,IAAI,UAAU,SAAS,eAAe,MAAM,SAAS;AAAA,MAAA;AAAA,IACvD;AAAA,EAEJ;AACA,SAAO;AACT;"}
+{"version":3,"file":"read.js","names":["#dagRead"],"sources":["../../../../../replicache/src/db/read.ts"],"sourcesContent":["import type {Enum} from '../../../shared/src/enum.ts';\nimport {BTreeRead} from '../btree/read.ts';\nimport type {Read as DagRead} from '../dag/store.ts';\nimport type * as FormatVersion from '../format-version-enum.ts';\nimport type {FrozenJSONValue} from '../frozen-json.ts';\nimport type {Hash} from '../hash.ts';\nimport type {Commit} from './commit.ts';\nimport {\n  DEFAULT_HEAD_NAME,\n  type Meta,\n  commitFromHash,\n  commitFromHead,\n} from './commit.ts';\nimport {IndexRead} from './index.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nexport class Read {\n  readonly #dagRead: DagRead;\n  map: BTreeRead;\n  readonly indexes: Map<string, IndexRead>;\n\n  constructor(\n    dagRead: DagRead,\n    map: BTreeRead,\n    indexes: Map<string, IndexRead>,\n  ) {\n    this.#dagRead = dagRead;\n    this.map = map;\n    this.indexes = indexes;\n  }\n\n  has(key: string): Promise<boolean> {\n    return this.map.has(key);\n  }\n\n  get(key: string): Promise<FrozenJSONValue | undefined> {\n    return this.map.get(key);\n  }\n\n  isEmpty(): Promise<boolean> {\n    return this.map.isEmpty();\n  }\n\n  getMapForIndex(indexName: string): BTreeRead {\n    const idx = this.indexes.get(indexName);\n    if (idx === undefined) {\n      throw new Error(`Unknown index name: ${indexName}`);\n    }\n    return idx.map;\n  }\n\n  get closed(): boolean {\n    return this.#dagRead.closed;\n  }\n\n  close(): void {\n    this.#dagRead.release();\n  }\n}\n\nexport function readFromDefaultHead(\n  dagRead: DagRead,\n  formatVersion: FormatVersion,\n): Promise<Read> {\n  return readFromHead(DEFAULT_HEAD_NAME, dagRead, formatVersion);\n}\n\nexport async function readFromHead(\n  name: string,\n  dagRead: DagRead,\n  formatVersion: FormatVersion,\n): Promise<Read> {\n  const commit = await commitFromHead(name, dagRead);\n  return readFromCommit(commit, dagRead, formatVersion);\n}\n\nexport async function readFromHash(\n  hash: Hash,\n  dagRead: DagRead,\n  formatVersion: FormatVersion,\n): Promise<Read> {\n  const commit = await commitFromHash(hash, dagRead);\n  return readFromCommit(commit, dagRead, formatVersion);\n}\n\nfunction readFromCommit(\n  commit: Commit<Meta>,\n  dagRead: DagRead,\n  formatVersion: FormatVersion,\n): Read {\n  const indexes = readIndexesForRead(commit, dagRead, formatVersion);\n  const map = new BTreeRead(dagRead, formatVersion, commit.valueHash);\n  return new Read(dagRead, map, indexes);\n}\n\nexport function readIndexesForRead(\n  commit: Commit<Meta>,\n  dagRead: DagRead,\n  formatVersion: FormatVersion,\n): Map<string, IndexRead> {\n  const m = new Map();\n  for (const index of commit.indexes) {\n    m.set(\n      index.definition.name,\n      new IndexRead(\n        index,\n        new BTreeRead(dagRead, formatVersion, index.valueHash),\n      ),\n    );\n  }\n  return m;\n}\n"],"mappings":";;;;AAiBA,IAAa,OAAb,MAAkB;CAChB;CACA;CACA;CAEA,YACE,SACA,KACA,SACA;AACA,QAAA,UAAgB;AAChB,OAAK,MAAM;AACX,OAAK,UAAU;;CAGjB,IAAI,KAA+B;AACjC,SAAO,KAAK,IAAI,IAAI,IAAI;;CAG1B,IAAI,KAAmD;AACrD,SAAO,KAAK,IAAI,IAAI,IAAI;;CAG1B,UAA4B;AAC1B,SAAO,KAAK,IAAI,SAAS;;CAG3B,eAAe,WAA8B;EAC3C,MAAM,MAAM,KAAK,QAAQ,IAAI,UAAU;AACvC,MAAI,QAAQ,KAAA,EACV,OAAM,IAAI,MAAM,uBAAuB,YAAY;AAErD,SAAO,IAAI;;CAGb,IAAI,SAAkB;AACpB,SAAO,MAAA,QAAc;;CAGvB,QAAc;AACZ,QAAA,QAAc,SAAS;;;AAI3B,SAAgB,oBACd,SACA,eACe;AACf,QAAO,aAAa,mBAAmB,SAAS,cAAc;;AAGhE,eAAsB,aACpB,MACA,SACA,eACe;AAEf,QAAO,eADQ,MAAM,eAAe,MAAM,QAAQ,EACpB,SAAS,cAAc;;AAGvD,eAAsB,aACpB,MACA,SACA,eACe;AAEf,QAAO,eADQ,MAAM,eAAe,MAAM,QAAQ,EACpB,SAAS,cAAc;;AAGvD,SAAS,eACP,QACA,SACA,eACM;CACN,MAAM,UAAU,mBAAmB,QAAQ,SAAS,cAAc;AAElE,QAAO,IAAI,KAAK,SADJ,IAAI,UAAU,SAAS,eAAe,OAAO,UAAU,EACrC,QAAQ;;AAGxC,SAAgB,mBACd,QACA,SACA,eACwB;CACxB,MAAM,oBAAI,IAAI,KAAK;AACnB,MAAK,MAAM,SAAS,OAAO,QACzB,GAAE,IACA,MAAM,WAAW,MACjB,IAAI,UACF,OACA,IAAI,UAAU,SAAS,eAAe,MAAM,UAAU,CACvD,CACF;AAEH,QAAO"}

package/out/replicache/src/db/rebase.js

@@ -1,85 +1,30 @@
 import { assert } from "../../../shared/src/asserts.js";
-import { WriteTransactionImpl } from "../transactions.js";
-import { isLocalMetaDD31, commitFromHash, assertLocalMetaDD31 } from "./commit.js";
+import { assertLocalMetaDD31, commitFromHash, isLocalMetaDD31 } from "./commit.js";
 import { newWriteLocal } from "./write.js";
+import { WriteTransactionImpl } from "../transactions.js";
+//#region ../replicache/src/db/rebase.ts
 async function rebaseMutation(mutation, dagWrite, basisHash, mutators, lc, mutationClientID, formatVersion, zeroData) {
-  const localMeta = mutation.meta;
-  const name = localMeta.mutatorName;
-  if (isLocalMetaDD31(localMeta)) {
-    assert(
-      localMeta.clientID === mutationClientID,
-      "mutationClientID must match clientID of LocalMeta"
-    );
-  }
-  const maybeMutatorImpl = mutators[name];
-  if (!maybeMutatorImpl) {
-    lc.error?.(`Cannot rebase unknown mutator ${name}`);
-  }
-  const mutatorImpl = maybeMutatorImpl || (async () => {
-  });
-  const args = localMeta.mutatorArgsJSON;
-  const basisCommit = await commitFromHash(basisHash, dagWrite);
-  const nextMutationID = await basisCommit.getNextMutationID(
-    mutationClientID,
-    dagWrite
-  );
-  if (nextMutationID !== localMeta.mutationID) {
-    throw new Error(
-      `Inconsistent mutation ID: original: ${localMeta.mutationID}, next: ${nextMutationID} - mutationClientID: ${mutationClientID} mutatorName: ${name}`
-    );
-  }
-  {
-    assertLocalMetaDD31(localMeta);
-  }
-  const dbWrite = await newWriteLocal(
-    basisHash,
-    name,
-    args,
-    mutation.chunk.hash,
-    dagWrite,
-    localMeta.timestamp,
-    mutationClientID,
-    formatVersion
-  );
-  const tx = new WriteTransactionImpl(
-    mutationClientID,
-    await dbWrite.getMutationID(),
-    "rebase",
-    zeroData,
-    dbWrite,
-    lc
-  );
-  await mutatorImpl(tx, args);
-  return dbWrite;
+	const localMeta = mutation.meta;
+	const name = localMeta.mutatorName;
+	if (isLocalMetaDD31(localMeta)) assert(localMeta.clientID === mutationClientID, "mutationClientID must match clientID of LocalMeta");
+	const maybeMutatorImpl = mutators[name];
+	if (!maybeMutatorImpl) lc.error?.(`Cannot rebase unknown mutator ${name}`);
+	const mutatorImpl = maybeMutatorImpl || (async () => {});
+	const args = localMeta.mutatorArgsJSON;
+	const nextMutationID = await (await commitFromHash(basisHash, dagWrite)).getNextMutationID(mutationClientID, dagWrite);
+	if (nextMutationID !== localMeta.mutationID) throw new Error(`Inconsistent mutation ID: original: ${localMeta.mutationID}, next: ${nextMutationID} - mutationClientID: ${mutationClientID} mutatorName: ${name}`);
+	if (formatVersion >= 5) assertLocalMetaDD31(localMeta);
+	const dbWrite = await newWriteLocal(basisHash, name, args, mutation.chunk.hash, dagWrite, localMeta.timestamp, mutationClientID, formatVersion);
+	await mutatorImpl(new WriteTransactionImpl(mutationClientID, await dbWrite.getMutationID(), "rebase", zeroData, dbWrite, lc), args);
+	return dbWrite;
 }
 async function rebaseMutationAndPutCommit(mutation, dagWrite, basis, mutators, lc, mutationClientID, formatVersion, zeroData) {
-  const tx = await rebaseMutation(
-    mutation,
-    dagWrite,
-    basis,
-    mutators,
-    lc,
-    mutationClientID,
-    formatVersion,
-    zeroData
-  );
-  return tx.putCommit();
+	return (await rebaseMutation(mutation, dagWrite, basis, mutators, lc, mutationClientID, formatVersion, zeroData)).putCommit();
 }
 async function rebaseMutationAndCommit(mutation, dagWrite, basis, headName, mutators, lc, mutationClientID, formatVersion, zeroData) {
-  const dbWrite = await rebaseMutation(
-    mutation,
-    dagWrite,
-    basis,
-    mutators,
-    lc,
-    mutationClientID,
-    formatVersion,
-    zeroData
-  );
-  return dbWrite.commit(headName);
+	return (await rebaseMutation(mutation, dagWrite, basis, mutators, lc, mutationClientID, formatVersion, zeroData)).commit(headName);
 }
-export {
-  rebaseMutationAndCommit,
-  rebaseMutationAndPutCommit
-};
-//# sourceMappingURL=rebase.js.map
+//#endregion
+export { rebaseMutationAndCommit, rebaseMutationAndPutCommit };
+
+//# sourceMappingURL=rebase.js.map