@livestore/common 0.2.0-dev.2 → 0.3.0-dev.0

package/src/sync/syncstate.ts

@@ -0,0 +1,385 @@
+import { shouldNeverHappen } from '@livestore/utils'
+import { ReadonlyArray, Schema } from '@livestore/utils/effect'
+
+import * as EventId from '../schema/EventId.js'
+import * as MutationEvent from '../schema/MutationEvent.js'
+
+/**
+ * SyncState represents the current sync state of a sync node relative to an upstream node.
+ * Events flow from local to upstream, with each state maintaining its own event head.
+ *
+ * Event Chain Structure:
+ * ```
+ *                 +-------------------------+------------------------+
+ *                 |      ROLLBACK TAIL      |     PENDING EVENTS     |
+ *                 +-------------------------+------------------------+
+ *                                         ▼                       ▼
+ *                                  Upstream Head             Local Head
+ *   Example:              (0,0), (0,1), (1,0)     (1,1), (1,2), (2,0)
+ * ```
+ *
+ * State:
+ * - **Pending Events**: Events awaiting acknowledgment from the upstream.
+ *   - Can be confirmed or rejected by the upstream.
+ *   - Subject to rebase if rejected.
+ * - **Rollback Tail**: Events that are kept around temporarily for potential rollback until confirmed by upstream.
+ *
+ * Payloads:
+ * - `PayloadUpstreamRebase`: Upstream has performed a rebase, so downstream must roll back to the specified event
+ *    and rebase the pending events on top of the new events.
+ * - `PayloadUpstreamAdvance`: Upstream has advanced, so downstream must rebase the pending events on top of the new events.
+ * - `PayloadUpstreamTrimRollbackTail`: Upstream has advanced, so downstream can trim the rollback tail.
+ * - `PayloadLocalPush`: Local push payload
+ *
+ * Invariants:
+ * 1. **Chain Continuity**: Each event must reference its immediate parent.
+ * 2. **Head Ordering**: Upstream Head ≤ Local Head.
+ * 3. **ID Sequence**: Must follow the pattern (1,0)→(1,1)→(1,2)→(2,0).
+ *
+ * The `updateSyncState` function processes updates to the sync state based on incoming payloads,
+ * handling cases such as upstream rebase, advance, local push, and rollback tail trimming.
+ */
+export interface SyncState {
+  pending: ReadonlyArray<MutationEvent.EncodedWithMeta>
+  rollbackTail: ReadonlyArray<MutationEvent.EncodedWithMeta>
+  upstreamHead: EventId.EventId
+  localHead: EventId.EventId
+}
+
+export const SyncState = Schema.Struct({
+  pending: Schema.Array(MutationEvent.EncodedWithMeta),
+  rollbackTail: Schema.Array(MutationEvent.EncodedWithMeta),
+  upstreamHead: EventId.EventId,
+  localHead: EventId.EventId,
+}).annotations({ title: 'SyncState' })
+
+export class PayloadUpstreamRebase extends Schema.TaggedStruct('upstream-rebase', {
+  /** Rollback until this event in the rollback tail (inclusive). Starting from the end of the rollback tail. */
+  rollbackUntil: EventId.EventId,
+  newEvents: Schema.Array(MutationEvent.EncodedWithMeta),
+  /** Trim rollback tail up to this event (inclusive). */
+  trimRollbackUntil: Schema.optional(EventId.EventId),
+}) {}
+
+export class PayloadUpstreamAdvance extends Schema.TaggedStruct('upstream-advance', {
+  newEvents: Schema.Array(MutationEvent.EncodedWithMeta),
+  /** Trim rollback tail up to this event (inclusive). */
+  trimRollbackUntil: Schema.optional(EventId.EventId),
+}) {}
+
+export class PayloadLocalPush extends Schema.TaggedStruct('local-push', {
+  newEvents: Schema.Array(MutationEvent.EncodedWithMeta),
+}) {}
+
+export class Payload extends Schema.Union(PayloadUpstreamRebase, PayloadUpstreamAdvance, PayloadLocalPush) {}
+
+export const PayloadUpstream = Schema.Union(PayloadUpstreamRebase, PayloadUpstreamAdvance)
+
+export type PayloadUpstream = typeof PayloadUpstream.Type
+
+export type UpdateResultAdvance = {
+  _tag: 'advance'
+  newSyncState: SyncState
+  previousSyncState: SyncState
+  /** Events which weren't pending before the update */
+  newEvents: ReadonlyArray<MutationEvent.EncodedWithMeta>
+}
+
+export type UpdateResultRebase = {
+  _tag: 'rebase'
+  newSyncState: SyncState
+  previousSyncState: SyncState
+  /** Events which weren't pending before the update */
+  newEvents: ReadonlyArray<MutationEvent.EncodedWithMeta>
+  eventsToRollback: ReadonlyArray<MutationEvent.EncodedWithMeta>
+}
+
+export type UpdateResultReject = {
+  _tag: 'reject'
+  previousSyncState: SyncState
+  /** The minimum id that the new events must have */
+  expectedMinimumId: EventId.EventId
+}
+
+export type UpdateResult = UpdateResultAdvance | UpdateResultRebase | UpdateResultReject
+
+export const updateSyncState = ({
+  syncState,
+  payload,
+  isLocalEvent,
+  isEqualEvent,
+  ignoreLocalEvents = false,
+}: {
+  syncState: SyncState
+  payload: typeof Payload.Type
+  isLocalEvent: (event: MutationEvent.EncodedWithMeta) => boolean
+  isEqualEvent: (a: MutationEvent.EncodedWithMeta, b: MutationEvent.EncodedWithMeta) => boolean
+  /** This is used in the leader which should ignore local events when receiving an upstream-advance payload */
+  ignoreLocalEvents?: boolean
+}): UpdateResult => {
+  const trimRollbackTail = (
+    rollbackTail: ReadonlyArray<MutationEvent.EncodedWithMeta>,
+  ): ReadonlyArray<MutationEvent.EncodedWithMeta> => {
+    const trimRollbackUntil = payload._tag === 'local-push' ? undefined : payload.trimRollbackUntil
+    if (trimRollbackUntil === undefined) return rollbackTail
+    const index = rollbackTail.findIndex((event) => EventId.isEqual(event.id, trimRollbackUntil))
+    if (index === -1) return []
+    return rollbackTail.slice(index + 1)
+  }
+
+  switch (payload._tag) {
+    case 'upstream-rebase': {
+      // Find the index of the rollback event in the rollback tail
+      const rollbackIndex = syncState.rollbackTail.findIndex((event) =>
+        EventId.isEqual(event.id, payload.rollbackUntil),
+      )
+      if (rollbackIndex === -1) {
+        return shouldNeverHappen(
+          `Rollback event not found in rollback tail. Rollback until: [${payload.rollbackUntil.global},${payload.rollbackUntil.local}]. Rollback tail: [${syncState.rollbackTail.map((e) => e.toString()).join(', ')}]`,
+        )
+      }
+
+      const eventsToRollback = [...syncState.rollbackTail.slice(rollbackIndex), ...syncState.pending]
+
+      // Get the last new event's ID as the new upstream head
+      const newUpstreamHead = payload.newEvents.at(-1)?.id ?? syncState.upstreamHead
+
+      // Rebase pending events on top of the new events
+      const rebasedPending = rebaseEvents({
+        events: syncState.pending,
+        baseEventId: newUpstreamHead,
+        isLocalEvent,
+      })
+
+      return {
+        _tag: 'rebase',
+        newSyncState: {
+          pending: rebasedPending,
+          rollbackTail: trimRollbackTail([...syncState.rollbackTail.slice(0, rollbackIndex), ...payload.newEvents]),
+          upstreamHead: newUpstreamHead,
+          localHead: rebasedPending.at(-1)?.id ?? newUpstreamHead,
+        },
+        previousSyncState: syncState,
+        newEvents: payload.newEvents,
+        eventsToRollback,
+      }
+    }
+
+    case 'upstream-advance': {
+      if (payload.newEvents.length === 0) {
+        return {
+          _tag: 'advance',
+          newSyncState: {
+            pending: syncState.pending,
+            rollbackTail: trimRollbackTail(syncState.rollbackTail),
+            upstreamHead: syncState.upstreamHead,
+            localHead: syncState.localHead,
+          },
+          previousSyncState: syncState,
+          newEvents: [],
+        }
+      }
+
+      // Validate that newEvents are sorted in ascending order by eventId
+      for (let i = 1; i < payload.newEvents.length; i++) {
+        if (EventId.isGreaterThan(payload.newEvents[i - 1]!.id, payload.newEvents[i]!.id)) {
+          return shouldNeverHappen('Events must be sorted in ascending order by eventId')
+        }
+      }
+
+      const newUpstreamHead = payload.newEvents.at(-1)!.id
+
+      const divergentPendingIndex = findDivergencePoint({
+        existingEvents: syncState.pending,
+        incomingEvents: payload.newEvents,
+        isEqualEvent,
+        isLocalEvent,
+        ignoreLocalEvents,
+      })
+
+      if (divergentPendingIndex === -1) {
+        const pendingEventIds = new Set(syncState.pending.map((e) => `${e.id.global},${e.id.local}`))
+        const newEvents = payload.newEvents.filter((e) => !pendingEventIds.has(`${e.id.global},${e.id.local}`))
+
+        // In the case where the incoming events are a subset of the pending events,
+        // we need to split the pending events into two groups:
+        // - pendingMatching: The pending events up to point where they match the incoming events
+        // - pendingRemaining: The pending events after the point where they match the incoming events
+        // The `localIndexOffset` is used to account for the local events that are being ignored
+        let localIndexOffset = 0
+        const [pendingMatching, pendingRemaining] = ReadonlyArray.splitWhere(
+          syncState.pending,
+          (pendingEvent, index) => {
+            if (ignoreLocalEvents && isLocalEvent(pendingEvent)) {
+              localIndexOffset++
+              return false
+            }
+
+            const newEvent = payload.newEvents.at(index - localIndexOffset)
+            if (!newEvent) {
+              return true
+            }
+            return isEqualEvent(pendingEvent, newEvent) === false
+          },
+        )
+
+        const seenEventIds = new Set<string>()
+        const pendingAndNewEvents = [...pendingMatching, ...payload.newEvents].filter((event) => {
+          const eventIdStr = `${event.id.global},${event.id.local}`
+          if (seenEventIds.has(eventIdStr)) {
+            return false
+          }
+          seenEventIds.add(eventIdStr)
+          return true
+        })
+
+        return {
+          _tag: 'advance',
+          newSyncState: {
+            pending: pendingRemaining,
+            rollbackTail: trimRollbackTail([...syncState.rollbackTail, ...pendingAndNewEvents]),
+            upstreamHead: newUpstreamHead,
+            localHead: pendingRemaining.at(-1)?.id ?? newUpstreamHead,
+          },
+          previousSyncState: syncState,
+          newEvents,
+        }
+      } else {
+        const divergentPending = syncState.pending.slice(divergentPendingIndex)
+        const rebasedPending = rebaseEvents({
+          events: divergentPending,
+          baseEventId: newUpstreamHead,
+          isLocalEvent,
+        })
+
+        const divergentNewEventsIndex = findDivergencePoint({
+          existingEvents: payload.newEvents,
+          incomingEvents: syncState.pending,
+          isEqualEvent,
+          isLocalEvent,
+          ignoreLocalEvents,
+        })
+
+        return {
+          _tag: 'rebase',
+          newSyncState: {
+            pending: rebasedPending,
+            rollbackTail: trimRollbackTail([...syncState.rollbackTail, ...payload.newEvents]),
+            upstreamHead: newUpstreamHead,
+            localHead: rebasedPending.at(-1)!.id,
+          },
+          previousSyncState: syncState,
+          newEvents: [...payload.newEvents.slice(divergentNewEventsIndex), ...rebasedPending],
+          eventsToRollback: [...syncState.rollbackTail, ...divergentPending],
+        }
+      }
+    }
+
+    case 'local-push': {
+      if (payload.newEvents.length === 0) {
+        return { _tag: 'advance', newSyncState: syncState, previousSyncState: syncState, newEvents: [] }
+      }
+
+      const newEventsFirst = payload.newEvents.at(0)!
+      const invalidEventId = EventId.isGreaterThan(newEventsFirst.id, syncState.localHead) === false
+
+      if (invalidEventId) {
+        const expectedMinimumId = EventId.nextPair(syncState.localHead, true).id
+        return { _tag: 'reject', previousSyncState: syncState, expectedMinimumId }
+      } else {
+        return {
+          _tag: 'advance',
+          newSyncState: {
+            pending: [...syncState.pending, ...payload.newEvents],
+            rollbackTail: syncState.rollbackTail,
+            upstreamHead: syncState.upstreamHead,
+            localHead: payload.newEvents.at(-1)!.id,
+          },
+          previousSyncState: syncState,
+          newEvents: payload.newEvents,
+        }
+      }
+    }
+
+    // case 'upstream-trim-rollback-tail': {
+    //   // Find the index of the new rollback start in the rollback tail
+    //   const startIndex = syncState.rollbackTail.findIndex((event) => eventIdsEqual(event.id, payload.trimRollbackUntil))
+    //   if (startIndex === -1) {
+    //     return shouldNeverHappen('New rollback start event not found in rollback tail')
+    //   }
+
+    //   // Keep only the events from the start index onwards
+    //   const newRollbackTail = syncState.rollbackTail.slice(startIndex)
+
+    //   return {
+    //     _tag: 'advance',
+    //     syncState: {
+    //       pending: syncState.pending,
+    //       rollbackTail: newRollbackTail,
+    //       upstreamHead: syncState.upstreamHead,
+    //       localHead: syncState.localHead,
+    //     },
+    //     newEvents: [],
+    //   }
+    // }
+  }
+}
+
+/**
+ * Gets the index relative to `existingEvents` where the divergence point is
+ * by comparing each event in `existingEvents` to the corresponding event in `incomingEvents`
+ */
+const findDivergencePoint = ({
+  existingEvents,
+  incomingEvents,
+  isEqualEvent,
+  isLocalEvent,
+  ignoreLocalEvents,
+}: {
+  existingEvents: ReadonlyArray<MutationEvent.EncodedWithMeta>
+  incomingEvents: ReadonlyArray<MutationEvent.EncodedWithMeta>
+  isEqualEvent: (a: MutationEvent.EncodedWithMeta, b: MutationEvent.EncodedWithMeta) => boolean
+  isLocalEvent: (event: MutationEvent.EncodedWithMeta) => boolean
+  ignoreLocalEvents: boolean
+}): number => {
+  if (ignoreLocalEvents) {
+    const filteredExistingEvents = existingEvents.filter((event) => !isLocalEvent(event))
+    const divergencePointWithoutLocalEvents = findDivergencePoint({
+      existingEvents: filteredExistingEvents,
+      incomingEvents,
+      isEqualEvent,
+      isLocalEvent,
+      ignoreLocalEvents: false,
+    })
+
+    if (divergencePointWithoutLocalEvents === -1) return -1
+
+    const divergencePointEventId = existingEvents[divergencePointWithoutLocalEvents]!.id
+    // Now find the divergence point in the original array
+    return existingEvents.findIndex((event) => EventId.isEqual(event.id, divergencePointEventId))
+  }
+
+  return existingEvents.findIndex((existingEvent, index) => {
+    const incomingEvent = incomingEvents[index]
+    // return !incomingEvent || !isEqualEvent(existingEvent, incomingEvent)
+    return incomingEvent && !isEqualEvent(existingEvent, incomingEvent)
+  })
+}
+
+const rebaseEvents = ({
+  events,
+  baseEventId,
+  isLocalEvent,
+}: {
+  events: ReadonlyArray<MutationEvent.EncodedWithMeta>
+  baseEventId: EventId.EventId
+  isLocalEvent: (event: MutationEvent.EncodedWithMeta) => boolean
+}): ReadonlyArray<MutationEvent.EncodedWithMeta> => {
+  let prevEventId = baseEventId
+  return events.map((event) => {
+    const isLocal = isLocalEvent(event)
+    const newEvent = event.rebase(prevEventId, isLocal)
+    prevEventId = newEvent.id
+    return newEvent
+  })
+}

package/src/sync/validate-push-payload.ts

@@ -0,0 +1,18 @@
+import { Effect } from '@livestore/utils/effect'
+
+import type { MutationEvent } from '../schema/mod.js'
+import { InvalidPushError } from './sync.js'
+
+// TODO proper batch validation
+export const validatePushPayload = (batch: ReadonlyArray<MutationEvent.AnyEncoded>, currentEventId: number) =>
+  Effect.gen(function* () {
+    if (batch[0]!.id.global <= currentEventId) {
+      return yield* InvalidPushError.make({
+        reason: {
+          _tag: 'ServerAhead',
+          minimumExpectedId: currentEventId + 1,
+          providedId: batch[0]!.id.global,
+        },
+      })
+    }
+  })

package/src/version.ts

@@ -2,7 +2,7 @@
 // import packageJson from '../package.json' with { type: 'json' }
 // export const liveStoreVersion = packageJson.version
 
-export const liveStoreVersion = '0.2.0-dev.1' as const
+export const liveStoreVersion = '0.2.0' as const
 
 /**
  * This version number is incremented whenever the internal storage format changes in a breaking way.
@@ -11,4 +11,4 @@ export const liveStoreVersion = '0.2.0-dev.1' as const
  * While LiveStore is in alpha, this might happen more frequently.
  * In the future, LiveStore will provide a migration path for older database files to avoid the impression of data loss.
  */
-export const liveStoreStorageFormatVersion = 2
+export const liveStoreStorageFormatVersion = 3

package/dist/schema/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"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"}

package/dist/schema/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AAChD,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAGrE,OAAO,EAAE,+BAA+B,EAAE,MAAM,yBAAyB,CAAA;AACzE,OAAO,EAKL,cAAc,GACf,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEjD,OAAO,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAA;AAEzD,cAAc,oBAAoB,CAAA;AAClC,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAA;AAC1C,cAAc,gBAAgB,CAAA;AAC9B,cAAc,qBAAqB,CAAA;AAEnC,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC,GAAG,CAAC,2BAA2B,CAAC,CAAA;AA+B5E,MAAM,CAAC,MAAM,UAAU,GAAG;AACxB,iIAAiI;AACjI,WAGC,EAC2C,EAAE;IAC9C,MAAM,WAAW,GAA4B,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC;QAC5E,CAAC,CAAC,WAAW,CAAC,MAAM;QACpB,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,CAAA;IAErC,MAAM,MAAM,GAAG,IAAI,GAAG,EAAoB,CAAA;IAE1C,KAAK,MAAM,QAAQ,IAAI,WAAW,EAAE,CAAC;QACnC,qDAAqD;QACrD,IAAI,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YAC5C,iBAAiB,CAAC,yBAAyB,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,uCAAuC,CAAC,CAAA;QAChH,CAAC;QACD,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAA;IACnD,CAAC;IAED,KAAK,MAAM,QAAQ,IAAI,YAAY,EAAE,CAAC;QACpC,6CAA6C;QAC7C,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAA;IAC/C,CAAC;IAED,MAAM,SAAS,GAAmB,IAAI,GAAG,EAAE,CAAA;IAE3C,IAAI,eAAe,CAAC,WAAW,CAAC,SAAS,CAAC,EAAE,CAAC;QAC3C,KAAK,MAAM,QAAQ,IAAI,WAAW,CAAC,SAAS,EAAE,CAAC;YAC7C,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAA;QACxC,CAAC;IACH,CAAC;SAAM,CAAC;QACN,KAAK,MAAM,QAAQ,IAAI,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,SAAS,IAAI,EAAE,CAAC,EAAE,CAAC;YAClE,IAAI,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;gBACjC,iBAAiB,CAAC,4BAA4B,QAAQ,CAAC,IAAI,0CAA0C,CAAC,CAAA;YACxG,CAAC;YACD,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAA;QACxC,CAAC;IACH,CAAC;IAED,SAAS,CAAC,GAAG,CAAC,cAAc,CAAC,IAAI,EAAE,cAAc,CAAC,CAAA;IAElD,KAAK,MAAM,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC;QACvC,IAAI,wBAAwB,CAAC,QAAQ,CAAC,EAAE,CAAC;YACvC,MAAM,mBAAmB,GAAG,+BAA+B,CAAC,QAAQ,CAAC,CAAA;YACrE,SAAS,CAAC,GAAG,CAAC,mBAAmB,CAAC,MAAM,CAAC,IAAI,EAAE,mBAAmB,CAAC,MAAM,CAAC,CAAA;YAC1E,SAAS,CAAC,GAAG,CAAC,mBAAmB,CAAC,MAAM,CAAC,IAAI,EAAE,mBAAmB,CAAC,MAAM,CAAC,CAAA;YAC1E,SAAS,CAAC,GAAG,CAAC,mBAAmB,CAAC,MAAM,CAAC,IAAI,EAAE,mBAAmB,CAAC,MAAM,CAAC,CAAA;QAC5E,CAAC;IACH,CAAC;IAED,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC;QAC1B,IAAI,EAAE,UAAU;QAChB,MAAM,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC;KACzD,CAAC,CAAA;IAEF,OAAO;QACL,KAAK,EAAE,qBAAqB;QAC5B,aAAa,EAAE,MAAM,CAAC,GAAG,CAAC,wBAAwB,CAAQ;QAC1D,mBAAmB,EAAE,MAAM,CAAC,GAAG,CAAC,8BAA8B,CAAQ;QACtE,MAAM;QACN,SAAS;QACT,gBAAgB,EAAE,WAAW,CAAC,UAAU,IAAI,EAAE,QAAQ,EAAE,YAAY,EAAE;QACtE,IAAI;KACqB,CAAA;AAC7B,CAAC,CAAA"}

package/dist/sync/next-mutation-event-id-pair.d.ts

@@ -1,14 +0,0 @@
-import { Effect } from '@livestore/utils/effect';
-import type { EventId } from '../adapter-types.js';
-export declare const makeNextMutationEventIdPair: (currentMutationEventIdRef: {
-    current: EventId;
-}) => (opts: {
-    localOnly: boolean;
-}) => Effect.Effect<{
-    id: {
-        global: number;
-        local: number;
-    };
-    parentId: EventId;
-}, never, never>;
-//# sourceMappingURL=next-mutation-event-id-pair.d.ts.map

package/dist/sync/next-mutation-event-id-pair.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"next-mutation-event-id-pair.d.ts","sourceRoot":"","sources":["../../src/sync/next-mutation-event-id-pair.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAEhD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAElD,eAAO,MAAM,2BAA2B,8BACV;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,YAAY;IAAE,SAAS,EAAE,OAAO,CAAA;CAAE;;;;;;gBAc9E,CAAA"}

package/dist/sync/next-mutation-event-id-pair.js

@@ -1,13 +0,0 @@
-import { Effect } from '@livestore/utils/effect';
-export const makeNextMutationEventIdPair = (currentMutationEventIdRef) => (opts) => Effect.gen(function* () {
-    // NOTE we always point to `local: 0` for non-localOnly mutations
-    const parentId = opts.localOnly
-        ? currentMutationEventIdRef.current
-        : { global: currentMutationEventIdRef.current.global, local: 0 };
-    const id = opts.localOnly
-        ? { global: parentId.global, local: parentId.local + 1 }
-        : { global: parentId.global + 1, local: 0 };
-    currentMutationEventIdRef.current = id;
-    return { id, parentId };
-});
-//# sourceMappingURL=next-mutation-event-id-pair.js.map

package/dist/sync/next-mutation-event-id-pair.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"next-mutation-event-id-pair.js","sourceRoot":"","sources":["../../src/sync/next-mutation-event-id-pair.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAIhD,MAAM,CAAC,MAAM,2BAA2B,GACtC,CAAC,yBAA+C,EAAE,EAAE,CAAC,CAAC,IAA4B,EAAE,EAAE,CACpF,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,iEAAiE;IACjE,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS;QAC7B,CAAC,CAAC,yBAAyB,CAAC,OAAO;QACnC,CAAC,CAAC,EAAE,MAAM,EAAE,yBAAyB,CAAC,OAAO,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,CAAA;IAElE,MAAM,EAAE,GAAG,IAAI,CAAC,SAAS;QACvB,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,QAAQ,CAAC,KAAK,GAAG,CAAC,EAAE;QACxD,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAA;IAE7C,yBAAyB,CAAC,OAAO,GAAG,EAAE,CAAA;IAEtC,OAAO,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAA;AACzB,CAAC,CAAC,CAAA"}

package/src/sync/next-mutation-event-id-pair.ts

@@ -1,20 +0,0 @@
-import { Effect } from '@livestore/utils/effect'
-
-import type { EventId } from '../adapter-types.js'
-
-export const makeNextMutationEventIdPair =
-  (currentMutationEventIdRef: { current: EventId }) => (opts: { localOnly: boolean }) =>
-    Effect.gen(function* () {
-      // NOTE we always point to `local: 0` for non-localOnly mutations
-      const parentId = opts.localOnly
-        ? currentMutationEventIdRef.current
-        : { global: currentMutationEventIdRef.current.global, local: 0 }
-
-      const id = opts.localOnly
-        ? { global: parentId.global, local: parentId.local + 1 }
-        : { global: parentId.global + 1, local: 0 }
-
-      currentMutationEventIdRef.current = id
-
-      return { id, parentId }
-    })