@livestore/common 0.4.0-dev.1 → 0.4.0-dev.10

package/src/sync/next/history-dag-common.ts

@@ -1,30 +1,11 @@
+import { shouldNeverHappen } from '@livestore/utils'
+import { Graph } from '@livestore/utils/effect'
 import type { EventDefFactsGroup } from '../../schema/EventDef.ts'
 import * as EventSequenceNumber from '../../schema/EventSequenceNumber.ts'
-import { graphology } from './graphology_.ts'
 
 export const connectionTypeOptions = ['parent', 'facts'] as const
 export type ConnectionType = (typeof connectionTypeOptions)[number]
 
-/**
- * Eventlog represented as a multi-DAG including edges for
- * - total-order (parent) relationships
- * - dependency (requires/reads facts) relationships
- */
-export type HistoryDag = graphology.IGraph<HistoryDagNode, { type: ConnectionType }>
-
-export const emptyHistoryDag = (): HistoryDag =>
-  new graphology.Graph({
-    allowSelfLoops: false,
-    multi: true,
-    type: 'directed',
-  })
-
-// TODO consider making `ROOT_ID` parent to itself
-export const rootParentNum = EventSequenceNumber.make({
-  global: EventSequenceNumber.ROOT.global - 1,
-  client: EventSequenceNumber.clientDefault,
-})
-
 export type HistoryDagNode = {
   seqNum: EventSequenceNumber.EventSequenceNumber
   parentSeqNum: EventSequenceNumber.EventSequenceNumber
@@ -37,6 +18,276 @@ export type HistoryDagNode = {
   sessionId: string | undefined
 }
 
+type HistoryDagEdgeAttributes = { type: ConnectionType }
+
+type HistoryDagEdgeEntry = {
+  edge: Graph.EdgeIndex
+  source: string
+  target: string
+  attributes: HistoryDagEdgeAttributes
+}
+
+type HistoryDagOptions = {
+  allowSelfLoops: boolean
+}
+
+const defaultOptions: HistoryDagOptions = {
+  allowSelfLoops: false,
+}
+
+const cloneFactsGroup = (factsGroup: EventDefFactsGroup): EventDefFactsGroup => ({
+  depRead: new Map(factsGroup.depRead),
+  depRequire: new Map(factsGroup.depRequire),
+  modifySet: new Map(factsGroup.modifySet),
+  modifyUnset: new Map(factsGroup.modifyUnset),
+})
+
+const cloneHistoryDagNode = (node: HistoryDagNode): HistoryDagNode => ({
+  ...node,
+  // Copy the event sequence numbers to avoid accidental aliasing
+  parentSeqNum: { ...node.parentSeqNum },
+  seqNum: { ...node.seqNum },
+  // Facts are represented via maps which should not be shared across DAG copies
+  factsGroup: cloneFactsGroup(node.factsGroup),
+})
+
+/**
+ * Mutable DAG wrapper that retains the previous string-based node ids API
+ * while delegating storage and algorithms to Effect's graph module.
+ */
+export class HistoryDag {
+  private readonly options: HistoryDagOptions
+  private readonly idToIndex: Map<string, Graph.NodeIndex>
+  private readonly indexToId: Map<Graph.NodeIndex, string>
+  private readonly graph: Graph.MutableDirectedGraph<HistoryDagNode, HistoryDagEdgeAttributes>
+
+  private constructor({
+    graph,
+    idToIndex,
+    indexToId,
+    options,
+  }: {
+    graph: Graph.MutableDirectedGraph<HistoryDagNode, HistoryDagEdgeAttributes>
+    idToIndex?: Map<string, Graph.NodeIndex>
+    indexToId?: Map<Graph.NodeIndex, string>
+    options?: Partial<HistoryDagOptions>
+  }) {
+    this.graph = graph
+    this.options = { ...defaultOptions, ...options }
+    this.idToIndex = idToIndex ? new Map(idToIndex) : new Map()
+    this.indexToId = indexToId ? new Map(indexToId) : new Map()
+  }
+
+  static create(options?: Partial<HistoryDagOptions>): HistoryDag {
+    const graph = Graph.beginMutation(Graph.directed<HistoryDagNode, HistoryDagEdgeAttributes>())
+    return options ? new HistoryDag({ graph, options }) : new HistoryDag({ graph })
+  }
+
+  copy(): HistoryDag {
+    const clone = HistoryDag.create(this.options)
+
+    for (const [id, index] of this.idToIndex) {
+      const node = this.graph.nodes.get(index) ?? shouldNeverHappen(`HistoryDag.copy missing node for ${id}`)
+      clone.addNode(id, cloneHistoryDagNode(node))
+    }
+
+    for (const edge of this.graph.edges.values()) {
+      const sourceId = this.indexToId.get(edge.source) ?? shouldNeverHappen('HistoryDag.copy missing source id')
+      const targetId = this.indexToId.get(edge.target) ?? shouldNeverHappen('HistoryDag.copy missing target id')
+      clone.addEdge(sourceId, targetId, { ...edge.data })
+    }
+
+    return clone
+  }
+
+  topologicalNodeIds(): Array<string> {
+    const walker = Graph.topo(this.graph)
+    const indices = Array.from(Graph.indices(walker))
+    return indices.map((index) => this.indexToId.get(index) ?? shouldNeverHappen(`Missing node id for index ${index}`))
+  }
+
+  addNode(id: string, attributes: HistoryDagNode): void {
+    if (this.idToIndex.has(id)) {
+      shouldNeverHappen(`HistoryDag node ${id} already exists`)
+    }
+
+    const nodeIndex = Graph.addNode(this.graph, attributes)
+    this.idToIndex.set(id, nodeIndex)
+    this.indexToId.set(nodeIndex, id)
+  }
+
+  hasNode(id: string): boolean {
+    return this.idToIndex.has(id)
+  }
+
+  getNodeAttributes(id: string): HistoryDagNode {
+    const index = this.idToIndex.get(id)
+    if (index === undefined) {
+      return shouldNeverHappen(`HistoryDag node ${id} not found`)
+    }
+
+    const node = this.graph.nodes.get(index)
+    return node ?? shouldNeverHappen(`HistoryDag node data missing for ${id}`)
+  }
+
+  nodes(): IterableIterator<string> {
+    return this.idToIndex.keys()
+  }
+
+  nodeEntries(): IterableIterator<{ key: string; attributes: HistoryDagNode }> {
+    return function* (this: HistoryDag) {
+      for (const [id, index] of this.idToIndex) {
+        const attributes = this.graph.nodes.get(index) ?? shouldNeverHappen(`HistoryDag node data missing for ${id}`)
+        yield { key: id, attributes }
+      }
+    }.call(this)
+  }
+
+  addEdge(sourceId: string, targetId: string, attributes: HistoryDagEdgeAttributes): Graph.EdgeIndex {
+    if (this.options.allowSelfLoops === false && sourceId === targetId) {
+      return shouldNeverHappen('HistoryDag self-loops are disabled')
+    }
+
+    const sourceIndex = this.idToIndex.get(sourceId)
+    const targetIndex = this.idToIndex.get(targetId)
+
+    if (sourceIndex === undefined || targetIndex === undefined) {
+      return shouldNeverHappen(`HistoryDag edge references unknown nodes: ${sourceId} -> ${targetId}`)
+    }
+
+    return Graph.addEdge(this.graph, sourceIndex, targetIndex, attributes)
+  }
+
+  edges(sourceId: string, targetId: string): Array<Graph.EdgeIndex> {
+    const sourceIndex = this.idToIndex.get(sourceId)
+    const targetIndex = this.idToIndex.get(targetId)
+
+    if (sourceIndex === undefined || targetIndex === undefined) {
+      return []
+    }
+
+    const adjacency = this.graph.adjacency.get(sourceIndex)
+    if (adjacency === undefined) {
+      return []
+    }
+
+    return adjacency.filter((edgeIndex) => {
+      const edge = this.graph.edges.get(edgeIndex)
+      return edge !== undefined && edge.target === targetIndex
+    })
+  }
+
+  inEdges(id: string): Array<Graph.EdgeIndex> {
+    const index = this.idToIndex.get(id)
+    if (index === undefined) {
+      return []
+    }
+    const incoming = this.graph.reverseAdjacency.get(index)
+    return incoming ? [...incoming] : []
+  }
+
+  outboundEdgeEntries(id: string): Array<HistoryDagEdgeEntry> {
+    const index = this.idToIndex.get(id)
+    if (index === undefined) {
+      return []
+    }
+
+    const adjacency = this.graph.adjacency.get(index)
+    if (adjacency === undefined) {
+      return []
+    }
+
+    return adjacency
+      .map((edgeIndex) => this.edgeEntry(edgeIndex))
+      .filter((entry): entry is HistoryDagEdgeEntry => entry !== undefined)
+  }
+
+  inboundEdgeEntries(id: string): Array<HistoryDagEdgeEntry> {
+    const index = this.idToIndex.get(id)
+    if (index === undefined) {
+      return []
+    }
+
+    const adjacency = this.graph.reverseAdjacency.get(index)
+    if (adjacency === undefined) {
+      return []
+    }
+
+    return adjacency
+      .map((edgeIndex) => this.edgeEntry(edgeIndex))
+      .filter((entry): entry is HistoryDagEdgeEntry => entry !== undefined)
+  }
+
+  getEdgeAttributes(edgeIndex: Graph.EdgeIndex): HistoryDagEdgeAttributes {
+    const edge = this.graph.edges.get(edgeIndex)
+    return edge?.data ?? shouldNeverHappen(`HistoryDag edge ${edgeIndex} not found`)
+  }
+
+  getEdgeAttribute<TKey extends keyof HistoryDagEdgeAttributes>(
+    edgeIndex: Graph.EdgeIndex,
+    key: TKey,
+  ): HistoryDagEdgeAttributes[TKey] {
+    const attributes = this.getEdgeAttributes(edgeIndex)
+    return attributes[key]
+  }
+
+  source(edgeIndex: Graph.EdgeIndex): string {
+    const edge = this.graph.edges.get(edgeIndex)
+    const sourceId = edge !== undefined ? this.indexToId.get(edge.source) : undefined
+    return sourceId ?? shouldNeverHappen(`HistoryDag edge ${edgeIndex} missing source`)
+  }
+
+  target(edgeIndex: Graph.EdgeIndex): string {
+    const edge = this.graph.edges.get(edgeIndex)
+    const targetId = edge !== undefined ? this.indexToId.get(edge.target) : undefined
+    return targetId ?? shouldNeverHappen(`HistoryDag edge ${edgeIndex} missing target`)
+  }
+
+  dropNode(id: string): void {
+    const index = this.idToIndex.get(id)
+    if (index === undefined) {
+      return
+    }
+
+    Graph.removeNode(this.graph, index)
+    this.idToIndex.delete(id)
+    this.indexToId.delete(index)
+  }
+
+  get size(): number {
+    return this.idToIndex.size
+  }
+
+  private edgeEntry(edgeIndex: Graph.EdgeIndex): HistoryDagEdgeEntry | undefined {
+    const edge = this.graph.edges.get(edgeIndex)
+    if (edge === undefined) {
+      return undefined
+    }
+
+    const source = this.indexToId.get(edge.source)
+    const target = this.indexToId.get(edge.target)
+
+    if (source === undefined || target === undefined) {
+      return undefined
+    }
+
+    return {
+      edge: edgeIndex,
+      source,
+      target,
+      attributes: edge.data,
+    }
+  }
+}
+
+export const emptyHistoryDag = (): HistoryDag => HistoryDag.create({ allowSelfLoops: false })
+
+// TODO consider making `ROOT_ID` parent to itself
+export const rootParentNum = EventSequenceNumber.make({
+  global: EventSequenceNumber.ROOT.global - 1,
+  client: EventSequenceNumber.clientDefault,
+})
+
 export const rootEventNode: HistoryDagNode = {
   seqNum: EventSequenceNumber.ROOT,
   parentSeqNum: rootParentNum,

package/src/sync/next/history-dag.ts

@@ -18,7 +18,9 @@ export const historyDagFromNodes = (dagNodes: HistoryDagNode[], options?: { skip
 
   const dag = emptyHistoryDag()
 
-  dagNodes.forEach((node) => dag.addNode(EventSequenceNumber.toString(node.seqNum), node))
+  dagNodes.forEach((node) => {
+    dag.addNode(EventSequenceNumber.toString(node.seqNum), node)
+  })
 
   dagNodes.forEach((node) => {
     if (EventSequenceNumber.toString(node.parentSeqNum) !== EventSequenceNumber.toString(rootParentNum)) {

package/src/sync/sync-backend-kv.ts

@@ -0,0 +1,22 @@
+import { Effect, KeyValueStore, Option } from '@livestore/utils/effect'
+import { UnexpectedError } from '../errors.ts'
+
+export const makeBackendIdHelper = Effect.gen(function* () {
+  const kv = yield* KeyValueStore.KeyValueStore
+
+  const backendIdKey = `backendId`
+  const backendIdRef = { current: yield* kv.get(backendIdKey).pipe(UnexpectedError.mapToUnexpectedError) }
+
+  const setBackendId = (backendId: string) =>
+    Effect.gen(function* () {
+      if (backendIdRef.current._tag === 'None' || backendIdRef.current.value !== backendId) {
+        backendIdRef.current = Option.some(backendId)
+        yield* kv.set(backendIdKey, backendId)
+      }
+    }).pipe(UnexpectedError.mapToUnexpectedError)
+
+  return {
+    lazySet: setBackendId,
+    get: () => backendIdRef.current,
+  }
+})

package/src/sync/sync-backend.ts

@@ -0,0 +1,185 @@
+import {
+  type Cause,
+  type Effect,
+  type HttpClient,
+  type KeyValueStore,
+  Option,
+  Schema,
+  type Scope,
+  type Stream,
+  type SubscriptionRef,
+} from '@livestore/utils/effect'
+import type { UnexpectedError } from '../adapter-types.ts'
+import type * as LiveStoreEvent from '../schema/LiveStoreEvent.ts'
+import type { EventSequenceNumber } from '../schema/mod.ts'
+import type { InvalidPullError, InvalidPushError, IsOfflineError } from './errors.ts'
+
+export * from './sync-backend-kv.ts'
+
+/**
+ * Those arguments can be used to implement multi-tenancy etc and are passed in from the store.
+ */
+export type MakeBackendArgs = {
+  storeId: string
+  clientId: string
+  payload: Schema.JsonValue | undefined
+}
+
+// TODO rename to `SyncProviderClientConstructor`
+export type SyncBackendConstructor<TSyncMetadata = Schema.JsonValue> = (
+  args: MakeBackendArgs,
+) => Effect.Effect<
+  SyncBackend<TSyncMetadata>,
+  UnexpectedError,
+  Scope.Scope | HttpClient.HttpClient | KeyValueStore.KeyValueStore
+>
+
+// TODO add more runtime sync metadata/metrics
+// - latency histogram
+// - number of events pushed/pulled
+// - dynamic sync backend data;
+//   - data center location (e.g. colo on CF workers)
+
+// TODO rename to `SyncProviderClient`
+export type SyncBackend<TSyncMetadata = Schema.JsonValue> = {
+  /**
+   * Can be implemented to prepare a connection to the sync backend to speed up the first pull/push.
+   */
+  connect: Effect.Effect<void, IsOfflineError | UnexpectedError, Scope.Scope>
+  pull: (
+    cursor: Option.Option<{
+      eventSequenceNumber: EventSequenceNumber.GlobalEventSequenceNumber
+      /** Metadata is needed by some sync backends */
+      metadata: Option.Option<TSyncMetadata>
+    }>,
+    options?: {
+      /**
+       * If true, the sync backend will return a stream of events that have been pushed after the cursor.
+       *
+       * @default false
+       */
+      live?: boolean
+    },
+  ) => Stream.Stream<PullResItem<TSyncMetadata>, IsOfflineError | InvalidPullError>
+  // TODO support transactions (i.e. group of mutation events which need to be applied together)
+  push: (
+    /**
+     * Constraints for batch:
+     * - Number of events: 1-100
+     * - sequence numbers must be in ascending order
+     * */
+    batch: ReadonlyArray<LiveStoreEvent.AnyEncodedGlobal>,
+  ) => Effect.Effect<void, IsOfflineError | InvalidPushError>
+  ping: Effect.Effect<void, IsOfflineError | UnexpectedError | Cause.TimeoutException>
+  // TODO also expose latency information additionally to whether the backend is connected
+  isConnected: SubscriptionRef.SubscriptionRef<boolean>
+  /**
+   * Metadata describing the sync backend. (Currently only used by devtools.)
+   */
+  metadata: { name: string; description: string } & Record<string, Schema.JsonValue>
+  /** Information about the sync backend capabilities. */
+  supports: {
+    /**
+     * Whether the sync backend supports the `hasMore` field in the pull response.
+     */
+    pullPageInfoKnown: boolean
+    /**
+     * Whether the sync backend supports the `live` option for the pull method and thus
+     * long-lived, reactive pull streams.
+     */
+    pullLive: boolean
+  }
+}
+
+/**
+ * Connectivity metadata emitted by sync backends.
+ */
+export const NetworkStatus = Schema.Struct({
+  /** True when the upstream sync backend is reachable and responding to health checks. */
+  isConnected: Schema.Boolean,
+  /** Unix epoch timestamp (ms) of the latest connectivity state transition. */
+  timestampMs: Schema.Number,
+  /** Devtools specific metadata describing simulator overrides. */
+  devtools: Schema.Struct({
+    /** Indicates whether the devtools latch forced the client into an offline state. */
+    latchClosed: Schema.Boolean,
+  }),
+}).annotations({ title: 'NetworkStatus' })
+
+export type NetworkStatus = typeof NetworkStatus.Type
+
+/**
+ * Runtime type guard for SyncBackend objects.
+ * Performs lightweight structural checks on the object shape.
+ */
+export const isSyncBackend = (value: unknown): value is SyncBackend<any> => {
+  if (typeof value !== 'object' || value === null) return false
+
+  const v: any = value
+  const hasCoreFns =
+    typeof v.connect === 'function' &&
+    typeof v.pull === 'function' &&
+    typeof v.push === 'function' &&
+    typeof v.ping === 'function'
+
+  const hasSupports =
+    typeof v.supports === 'object' &&
+    v.supports !== null &&
+    typeof v.supports.pullPageInfoKnown === 'boolean' &&
+    typeof v.supports.pullLive === 'boolean'
+
+  const hasMetadata =
+    typeof v.metadata === 'object' &&
+    v.metadata !== null &&
+    typeof v.metadata.name === 'string' &&
+    typeof v.metadata.description === 'string'
+
+  const hasIsConnected = typeof v.isConnected === 'object' && v.isConnected !== null
+
+  return hasCoreFns && hasSupports && hasMetadata && hasIsConnected
+}
+
+export const PullResPageInfo = Schema.Union(
+  Schema.TaggedStruct('MoreUnknown', {}),
+  Schema.TaggedStruct('MoreKnown', {
+    remaining: Schema.Number,
+  }),
+  Schema.TaggedStruct('NoMore', {}),
+)
+
+export type PullResPageInfo = typeof PullResPageInfo.Type
+
+export const pageInfoNoMore: PullResPageInfo = { _tag: 'NoMore' } as const
+export const pageInfoMoreUnknown: PullResPageInfo = { _tag: 'MoreUnknown' } as const
+export const pageInfoMoreKnown = (remaining: number): PullResPageInfo => ({ _tag: 'MoreKnown', remaining })
+
+export const pullResItemEmpty = <TSyncMetadata = Schema.JsonValue>(): PullResItem<TSyncMetadata> => ({
+  batch: [],
+  pageInfo: pageInfoNoMore,
+})
+
+export interface PullResItem<TSyncMetadata = Schema.JsonValue> {
+  batch: ReadonlyArray<{
+    eventEncoded: LiveStoreEvent.AnyEncodedGlobal
+    metadata: Option.Option<TSyncMetadata>
+  }>
+  pageInfo: PullResPageInfo
+}
+
+export const of = <TSyncMetadata = Schema.JsonValue>(obj: SyncBackend<TSyncMetadata>) => obj
+
+/**
+ * Useful to continue pulling from the last event in the batch.
+ */
+export const cursorFromPullResItem = <TSyncMetadata = Schema.JsonValue>(
+  item: PullResItem<TSyncMetadata>,
+): Option.Option<{
+  eventSequenceNumber: EventSequenceNumber.GlobalEventSequenceNumber
+  metadata: Option.Option<TSyncMetadata>
+}> => {
+  const lastEvent = item.batch.at(-1)
+  if (!lastEvent) {
+    return Option.none()
+  }
+  return Option.some({ eventSequenceNumber: lastEvent.eventEncoded.seqNum, metadata: lastEvent.metadata })
+}

package/src/sync/sync.ts

@@ -1,19 +1,8 @@
-import type { Effect, HttpClient, Option, Scope, Stream, SubscriptionRef } from '@livestore/utils/effect'
-import { Schema } from '@livestore/utils/effect'
+export * from './errors.ts'
+export * as SyncBackend from './sync-backend.ts'
 
-import type { UnexpectedError } from '../adapter-types.ts'
 import type { InitialSyncOptions } from '../leader-thread/types.ts'
-import * as EventSequenceNumber from '../schema/EventSequenceNumber.ts'
-import type * as LiveStoreEvent from '../schema/LiveStoreEvent.ts'
-
-/**
- * Those arguments can be used to implement multi-tenancy etc and are passed in from the store.
- */
-export type MakeBackendArgs = {
-  storeId: string
-  clientId: string
-  payload: Schema.JsonValue | undefined
-}
+import type { SyncBackendConstructor } from './sync-backend.ts'
 
 export type SyncOptions = {
   backend?: SyncBackendConstructor<any>
@@ -29,81 +18,9 @@ export type SyncOptions = {
    * @default 'ignore'
    * */
   onSyncError?: 'shutdown' | 'ignore'
-}
-
-// TODO rename to `SyncProviderClientConstructor`
-export type SyncBackendConstructor<TSyncMetadata = Schema.JsonValue> = (
-  args: MakeBackendArgs,
-) => Effect.Effect<SyncBackend<TSyncMetadata>, UnexpectedError, Scope.Scope | HttpClient.HttpClient>
-
-// TODO add more runtime sync metadata
-// - latency histogram
-// - number of events pushed/pulled
-// - dynamic sync backend data;
-//   - data center location (e.g. colo on CF workers)
-
-// TODO rename to `SyncProviderClient`
-export type SyncBackend<TSyncMetadata = Schema.JsonValue> = {
   /**
-   * Can be implemented to prepare a connection to the sync backend to speed up the first pull/push.
+   * Whether the sync backend should reactively pull new events from the sync backend
+   * @default true
    */
-  connect: Effect.Effect<void, IsOfflineError | UnexpectedError, HttpClient.HttpClient | Scope.Scope>
-  pull: (
-    args: Option.Option<{
-      cursor: EventSequenceNumber.EventSequenceNumber
-      metadata: Option.Option<TSyncMetadata>
-    }>,
-  ) => Stream.Stream<
-    {
-      batch: ReadonlyArray<{
-        eventEncoded: LiveStoreEvent.AnyEncodedGlobal
-        metadata: Option.Option<TSyncMetadata>
-      }>
-      remaining: number
-    },
-    IsOfflineError | InvalidPullError,
-    HttpClient.HttpClient
-  >
-  // TODO support transactions (i.e. group of mutation events which need to be applied together)
-  push: (
-    /**
-     * Constraints for batch:
-     * - Number of events: 1-100
-     * - sequence numbers must be in ascending order
-     * */
-    batch: ReadonlyArray<LiveStoreEvent.AnyEncodedGlobal>,
-  ) => Effect.Effect<void, IsOfflineError | InvalidPushError, HttpClient.HttpClient>
-  isConnected: SubscriptionRef.SubscriptionRef<boolean>
-  /**
-   * Metadata describing the sync backend. (Currently only used by devtools.)
-   */
-  metadata: { name: string; description: string } & Record<string, Schema.JsonValue>
+  livePull?: boolean
 }
-
-export class IsOfflineError extends Schema.TaggedError<IsOfflineError>()('IsOfflineError', {}) {}
-
-// TODO gt rid of this error in favour of SyncError
-export class InvalidPushError extends Schema.TaggedError<InvalidPushError>()('InvalidPushError', {
-  reason: Schema.Union(
-    Schema.TaggedStruct('Unexpected', {
-      message: Schema.String,
-    }),
-    Schema.TaggedStruct('ServerAhead', {
-      minimumExpectedNum: Schema.Number,
-      providedNum: Schema.Number,
-    }),
-  ),
-}) {}
-
-// TODO gt rid of this error in favour of SyncError
-export class InvalidPullError extends Schema.TaggedError<InvalidPullError>()('InvalidPullError', {
-  message: Schema.String,
-}) {}
-
-// TODO gt rid of this error in favour of SyncError
-export class LeaderAheadError extends Schema.TaggedError<LeaderAheadError>()('LeaderAheadError', {
-  minimumExpectedNum: EventSequenceNumber.EventSequenceNumber,
-  providedNum: EventSequenceNumber.EventSequenceNumber,
-  /** Generation number the client session should use for subsequent pushes */
-  // nextGeneration: Schema.Number,
-}) {}