@livestore/livestore 0.0.58-dev.5 → 0.0.58-dev.7

package/src/store.ts

@@ -1,6 +1,7 @@
 import type {
   BootDb,
   BootStatus,
+  EventId,
   IntentionalShutdownCause,
   ParamsObject,
   PreparedBindValues,
@@ -10,10 +11,16 @@ import type {
 } from '@livestore/common'
 import { getExecArgsFromMutation, prepareBindValues, UnexpectedError } from '@livestore/common'
 import type { LiveStoreSchema, MutationEvent } from '@livestore/common/schema'
-import { makeMutationEventSchemaMemo, SCHEMA_META_TABLE, SCHEMA_MUTATIONS_META_TABLE } from '@livestore/common/schema'
+import {
+  makeMutationEventSchemaMemo,
+  SCHEMA_META_TABLE,
+  SCHEMA_MUTATIONS_META_TABLE,
+  SESSION_CHANGESET_META_TABLE,
+} from '@livestore/common/schema'
 import { assertNever, makeNoopTracer, shouldNeverHappen } from '@livestore/utils'
 import {
   Cause,
+  Data,
   Deferred,
   Duration,
   Effect,
@@ -23,6 +30,7 @@ import {
   Layer,
   Logger,
   LogLevel,
+  MutableHashMap,
   OtelTracer,
   Queue,
   Runtime,
@@ -74,8 +82,8 @@ export type StoreOptions<
   fiberSet: FiberSet.FiberSet
   runtime: Runtime.Runtime<Scope.Scope>
   batchUpdates: (runUpdates: () => void) => void
-  // TODO remove this temporary solution and find a better way to avoid re-processing the same mutation
-  __processedMutationIds: Set<string>
+  currentMutationEventIdRef: { current: EventId }
+  unsyncedMutationEvents: MutableHashMap.MutableHashMap<EventId, MutationEvent.ForSchema<TSchema>>
 }
 
 export type RefreshReason =
@@ -109,9 +117,6 @@ export type StoreOtel = {
   queriesSpanContext: otel.Context
 }
 
-let storeCount = 0
-const uniqueStoreId = () => `store-${++storeCount}`
-
 export type StoreMutateOptions = {
   label?: string
   skipRefresh?: boolean
@@ -133,7 +138,7 @@ export class Store<
   TGraphQLContext extends BaseGraphQLContext = BaseGraphQLContext,
   TSchema extends LiveStoreSchema = LiveStoreSchema,
 > extends Inspectable.Class {
-  id = uniqueStoreId()
+  readonly storeId: string
   reactivityGraph: ReactivityGraph
   syncDbWrapper: SynchronousDatabaseWrapper
   adapter: StoreAdapter
@@ -150,15 +155,15 @@ export class Store<
   private fiberSet: FiberSet.FiberSet
   private runtime: Runtime.Runtime<Scope.Scope>
 
-  // TODO remove this temporary solution and find a better way to avoid re-processing the same mutation
-  private __processedMutationIds
-  private __processedMutationWithoutRefreshIds = new Set<string>()
-
   /** RC-based set to see which queries are currently subscribed to */
   activeQueries: ReferenceCountedSet<LiveQuery<any>>
 
+  // NOTE this is currently exposed for the Devtools databrowser to emit mutation events
   readonly __mutationEventSchema
 
+  private currentMutationEventIdRef
+  private unsyncedMutationEvents
+
   // #region constructor
   private constructor({
     adapter,
@@ -168,12 +173,19 @@ export class Store<
     otelOptions,
     disableDevtools,
     batchUpdates,
-    __processedMutationIds,
+    currentMutationEventIdRef,
+    unsyncedMutationEvents,
+    storeId,
     fiberSet,
     runtime,
   }: StoreOptions<TGraphQLContext, TSchema>) {
     super()
 
+    this.storeId = storeId
+
+    this.currentMutationEventIdRef = currentMutationEventIdRef
+    this.unsyncedMutationEvents = unsyncedMutationEvents
+
     this.syncDbWrapper = new SynchronousDatabaseWrapper({ otel: otelOptions, db: adapter.syncDb })
     this.adapter = adapter
     this.schema = schema
@@ -184,9 +196,6 @@ export class Store<
     // TODO refactor
     this.__mutationEventSchema = makeMutationEventSchemaMemo(schema)
 
-    // TODO remove this temporary solution and find a better way to avoid re-processing the same mutation
-    this.__processedMutationIds = __processedMutationIds
-
     // TODO generalize the `tableRefs` concept to allow finer-grained refs
     this.tableRefs = {}
     this.activeQueries = new ReferenceCountedSet()
@@ -222,7 +231,7 @@ export class Store<
       isRunningInDevtools
         ? this.schema.tables.keys()
         : Array.from(this.schema.tables.keys()).filter(
-            (_) => _ !== SCHEMA_META_TABLE && _ !== SCHEMA_MUTATIONS_META_TABLE,
+            (_) => _ !== SCHEMA_META_TABLE && _ !== SCHEMA_MUTATIONS_META_TABLE && _ !== SESSION_CHANGESET_META_TABLE,
           ),
     )
     const existingTableRefs = new Map(
@@ -241,9 +250,11 @@ export class Store<
 
     Effect.gen(this, function* () {
       yield* this.adapter.coordinator.syncMutations.pipe(
-        Stream.tapSync((mutationEventDecoded) => {
-          this.mutate({ wasSyncMessage: true }, mutationEventDecoded)
-        }),
+        Stream.tapChunk((mutationsEventsDecodedChunk) =>
+          Effect.sync(() => {
+            this.mutate({ wasSyncMessage: true }, ...mutationsEventsDecodedChunk)
+          }),
+        ),
         Stream.runDrain,
         Effect.interruptible,
         Effect.withSpan('LiveStore:syncMutations'),
@@ -327,17 +338,21 @@ export class Store<
 
   // #region mutate
   mutate: {
-    <const TMutationArg extends ReadonlyArray<MutationEvent.ForSchema<TSchema>>>(...list: TMutationArg): void
+    <const TMutationArg extends ReadonlyArray<MutationEvent.PartialForSchema<TSchema>>>(...list: TMutationArg): void
     (
-      txn: <const TMutationArg extends ReadonlyArray<MutationEvent.ForSchema<TSchema>>>(...list: TMutationArg) => void,
+      txn: <const TMutationArg extends ReadonlyArray<MutationEvent.PartialForSchema<TSchema>>>(
+        ...list: TMutationArg
+      ) => void,
     ): void
-    <const TMutationArg extends ReadonlyArray<MutationEvent.ForSchema<TSchema>>>(
+    <const TMutationArg extends ReadonlyArray<MutationEvent.PartialForSchema<TSchema>>>(
       options: StoreMutateOptions,
       ...list: TMutationArg
     ): void
     (
       options: StoreMutateOptions,
-      txn: <const TMutationArg extends ReadonlyArray<MutationEvent.ForSchema<TSchema>>>(...list: TMutationArg) => void,
+      txn: <const TMutationArg extends ReadonlyArray<MutationEvent.PartialForSchema<TSchema>>>(
+        ...list: TMutationArg
+      ) => void,
     ): void
   } = (firstMutationOrTxnFnOrOptions: any, ...restMutations: any[]) => {
     let mutationsEvents: MutationEvent.ForSchema<TSchema>[]
@@ -361,16 +376,14 @@ export class Store<
       mutationsEvents = [firstMutationOrTxnFnOrOptions, ...restMutations]
     }
 
-    mutationsEvents = mutationsEvents.filter((_) => !this.__processedMutationIds.has(_.id))
+    mutationsEvents = mutationsEvents.filter(
+      (_) => _.id === undefined || !MutableHashMap.has(this.unsyncedMutationEvents, Data.struct(_.id)),
+    )
 
     if (mutationsEvents.length === 0) {
       return
     }
 
-    for (const mutationEvent of mutationsEvents) {
-      this.__processedMutationIds.add(mutationEvent.id)
-    }
-
     const label = options?.label ?? 'mutate'
     const skipRefresh = options?.skipRefresh ?? false
     const wasSyncMessage = options?.wasSyncMessage ?? false
@@ -385,7 +398,7 @@ export class Store<
 
     let durationMs: number
 
-    return this.otel.tracer.startActiveSpan(
+    const res = this.otel.tracer.startActiveSpan(
       'LiveStore:mutate',
       { attributes: { 'livestore.mutateLabel': label } },
       this.otel.mutationsSpanContext,
@@ -465,6 +478,16 @@ export class Store<
         return { durationMs }
       },
     )
+
+    // NOTE we need to add the mutation events to the unsynced mutation events map only after running the code above
+    // so the short-circuiting in `mutateWithoutRefresh` doesn't kick in for those events
+    for (const mutationEvent of mutationsEvents) {
+      if (mutationEvent.id !== undefined) {
+        MutableHashMap.set(this.unsyncedMutationEvents, Data.struct(mutationEvent.id), mutationEvent)
+      }
+    }
+
+    return res
   }
 
   /**
@@ -492,19 +515,30 @@ export class Store<
    * the caller must refresh queries after calling this method.
    */
   mutateWithoutRefresh = (
-    mutationEventDecoded: MutationEvent.ForSchema<TSchema>,
+    mutationEventDecoded_: MutationEvent.ForSchema<TSchema> | MutationEvent.PartialForSchema<TSchema>,
     options: {
       otelContext: otel.Context
       coordinatorMode: 'default' | 'skip-coordinator' | 'skip-persist'
     },
   ): { writeTables: ReadonlySet<string>; durationMs: number } => {
+    const mutationDef =
+      this.schema.mutations.get(mutationEventDecoded_.mutation) ??
+      shouldNeverHappen(`Unknown mutation type: ${mutationEventDecoded_.mutation}`)
+
+    const mutationEventDecoded: MutationEvent.ForSchema<TSchema> = mutationEventDecoded_.hasOwnProperty('id')
+      ? (mutationEventDecoded_ as MutationEvent.ForSchema<TSchema>)
+      : {
+          ...mutationEventDecoded_,
+          ...this.getNextMutationEventId({ localOnly: mutationDef.options.localOnly }),
+        }
+
     // NOTE we also need this temporary workaround here since some code-paths use `mutateWithoutRefresh` directly
     // e.g. the row-query functionality
-    if (this.__processedMutationWithoutRefreshIds.has(mutationEventDecoded.id)) {
+    if (MutableHashMap.has(this.unsyncedMutationEvents, Data.struct(mutationEventDecoded.id))) {
       // NOTE this data should never be used
       return { writeTables: new Set(), durationMs: 0 }
     } else {
-      this.__processedMutationWithoutRefreshIds.add(mutationEventDecoded.id)
+      MutableHashMap.set(this.unsyncedMutationEvents, Data.struct(mutationEventDecoded.id), mutationEventDecoded)
     }
 
     const { otelContext, coordinatorMode = 'default' } = options
@@ -524,10 +558,6 @@ export class Store<
         const allWriteTables = new Set<string>()
         let durationMsTotal = 0
 
-        const mutationDef =
-          this.schema.mutations.get(mutationEventDecoded.mutation) ??
-          shouldNeverHappen(`Unknown mutation type: ${mutationEventDecoded.mutation}`)
-
         const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
 
         for (const {
@@ -549,7 +579,7 @@ export class Store<
           // Asynchronously apply mutation to a persistent storage (we're not awaiting this promise here)
           this.adapter.coordinator
             .mutate(mutationEventEncoded as MutationEvent.AnyEncoded, { persisted: coordinatorMode !== 'skip-persist' })
-            .pipe(Runtime.runFork(this.runtime))
+            .pipe(this.runEffectFork)
         }
 
         // Uncomment to print a list of queries currently registered on the store
@@ -568,7 +598,7 @@ export class Store<
    * This should only be used for framework-internal purposes;
    * all app writes should go through mutate.
    */
-  execute = (
+  __execute = (
     query: string,
     params: ParamsObject = {},
     writeTables?: ReadonlySet<string>,
@@ -579,10 +609,21 @@ export class Store<
     this.adapter.coordinator.execute(query, prepareBindValues(params, query)).pipe(this.runEffectFork)
   }
 
-  select = (query: string, params: ParamsObject = {}) => {
+  __select = (query: string, params: ParamsObject = {}) => {
     return this.syncDbWrapper.select(query, { bindValues: prepareBindValues(params, query) })
   }
 
+  private getNextMutationEventId = ({ localOnly }: { localOnly: boolean }): { id: EventId; parentId: EventId } => {
+    const id = this.adapter.coordinator.getNextMutationEventId({ localOnly }).pipe(Effect.runSync)
+    const parentId = localOnly
+      ? this.currentMutationEventIdRef.current
+      : { global: this.currentMutationEventIdRef.current.global, local: 0 }
+
+    this.currentMutationEventIdRef.current = id
+
+    return { id, parentId }
+  }
+
   private makeTableRef = (tableName: string) =>
     this.reactivityGraph.makeRef(null, {
       equal: () => false,
@@ -745,7 +786,13 @@ export const createStore = <
 
     const mutationEventSchema = makeMutationEventSchemaMemo(schema)
 
-    const __processedMutationIds = new Set<string>()
+    // TODO get rid of this
+    // const __processedMutationIds = new Set<number>()
+
+    const currentMutationEventIdRef = { current: yield* adapter.coordinator.getCurrentMutationEventId }
+
+    // TODO fill up with unsynced mutation events from the coordinator
+    const unsyncedMutationEvents = MutableHashMap.empty<EventId, MutationEvent.ForSchema<TSchema>>()
 
     // TODO consider moving booting into the storage backend
     if (boot !== undefined) {
@@ -765,12 +812,24 @@ export const createStore = <
           }
         },
         mutate: (...list) => {
-          for (const mutationEventDecoded of list) {
+          for (const mutationEventDecoded_ of list) {
             const mutationDef =
-              schema.mutations.get(mutationEventDecoded.mutation) ??
-              shouldNeverHappen(`Unknown mutation type: ${mutationEventDecoded.mutation}`)
+              schema.mutations.get(mutationEventDecoded_.mutation) ??
+              shouldNeverHappen(`Unknown mutation type: ${mutationEventDecoded_.mutation}`)
+
+            const parentId = mutationDef.options.localOnly
+              ? currentMutationEventIdRef.current
+              : { global: currentMutationEventIdRef.current.global, local: 0 }
+
+            currentMutationEventIdRef.current = adapter.coordinator
+              .getNextMutationEventId({ localOnly: mutationDef.options.localOnly })
+              .pipe(Effect.runSync)
+
+            const mutationEventDecoded = { ...mutationEventDecoded_, id: currentMutationEventIdRef.current, parentId }
+
+            MutableHashMap.set(unsyncedMutationEvents, Data.struct(mutationEventDecoded.id), mutationEventDecoded)
 
-            __processedMutationIds.add(mutationEventDecoded.id)
+            // __processedMutationIds.add(mutationEventDecoded.id.global)
 
             const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
             // const { bindValues, statementSql } = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
@@ -828,7 +887,8 @@ export const createStore = <
         otelOptions: { tracer: otelTracer, rootSpanContext: otelRootSpanContext },
         reactivityGraph,
         disableDevtools,
-        __processedMutationIds,
+        currentMutationEventIdRef,
+        unsyncedMutationEvents,
         fiberSet,
         runtime,
         batchUpdates: batchUpdates ?? ((run) => run()),