@livestore/common 0.3.0-dev.17 → 0.3.0-dev.18

package/src/adapter-types.ts

@@ -167,6 +167,10 @@ export class IntentionalShutdownCause extends Schema.TaggedError<IntentionalShut
   },
 ) {}
 
+export class StoreInterrupted extends Schema.TaggedError<StoreInterrupted>()('LiveStore.StoreInterrupted', {
+  reason: Schema.String,
+}) {}
+
 export class SqliteError extends Schema.TaggedError<SqliteError>()('LiveStore.SqliteError', {
   query: Schema.optional(
     Schema.Struct({

package/src/leader-thread/LeaderSyncProcessor.ts

@@ -18,17 +18,17 @@ import type * as otel from '@opentelemetry/api'
 
 import type { SqliteDb } from '../adapter-types.js'
 import { UnexpectedError } from '../adapter-types.js'
-import { clientId } from '../devtools/devtools-messages-common.js'
 import type { LiveStoreSchema, SessionChangesetMetaRow } from '../schema/mod.js'
 import {
   EventId,
+  getMutationDef,
   MUTATION_LOG_META_TABLE,
   MutationEvent,
   mutationLogMetaTable,
   SESSION_CHANGESET_META_TABLE,
 } from '../schema/mod.js'
 import { updateRows } from '../sql-queries/index.js'
-import { InvalidPushError, LeaderAheadError } from '../sync/sync.js'
+import { LeaderAheadError } from '../sync/sync.js'
 import * as SyncState from '../sync/syncstate.js'
 import { sql } from '../util.js'
 import { makeApplyMutation } from './apply-mutation.js'
@@ -88,7 +88,7 @@ export const makeLeaderSyncProcessor = ({
     const syncStateSref = yield* SubscriptionRef.make<SyncState.SyncState | undefined>(undefined)
 
     const isLocalEvent = (mutationEventEncoded: MutationEvent.EncodedWithMeta) => {
-      const mutationDef = schema.mutations.get(mutationEventEncoded.mutation)!
+      const mutationDef = getMutationDef(schema, mutationEventEncoded.mutation)
       return mutationDef.options.clientOnly
     }
 
@@ -170,9 +170,7 @@ export const makeLeaderSyncProcessor = ({
         const syncState = yield* syncStateSref
         if (syncState === undefined) return shouldNeverHappen('Not initialized')
 
-        const mutationDef =
-          schema.mutations.get(partialMutationEvent.mutation) ??
-          shouldNeverHappen(`Unknown mutation: ${partialMutationEvent.mutation}`)
+        const mutationDef = getMutationDef(schema, partialMutationEvent.mutation)
 
         const mutationEventEncoded = new MutationEvent.EncodedWithMeta({
           ...partialMutationEvent,
@@ -227,7 +225,7 @@ export const makeLeaderSyncProcessor = ({
           const filteredBatch = pendingMutationEvents
             // Don't sync clientOnly mutations
             .filter((mutationEventEncoded) => {
-              const mutationDef = schema.mutations.get(mutationEventEncoded.mutation)!
+              const mutationDef = getMutationDef(schema, mutationEventEncoded.mutation)
               return mutationDef.options.clientOnly === false
             })
 
@@ -463,7 +461,7 @@ const backgroundApplyLocalPushes = ({
 
       // Don't sync clientOnly mutations
       const filteredBatch = updateResult.newEvents.filter((mutationEventEncoded) => {
-        const mutationDef = schema.mutations.get(mutationEventEncoded.mutation)!
+        const mutationDef = getMutationDef(schema, mutationEventEncoded.mutation)
         return mutationDef.options.clientOnly === false
       })
 
@@ -617,7 +615,7 @@ const backgroundBackendPulling = ({
           })
 
           const filteredRebasedPending = updateResult.newSyncState.pending.filter((mutationEvent) => {
-            const mutationDef = schema.mutations.get(mutationEvent.mutation)!
+            const mutationDef = getMutationDef(schema, mutationEvent.mutation)
             return mutationDef.options.clientOnly === false
           })
           yield* restartBackendPushing(filteredRebasedPending)

package/src/leader-thread/apply-mutation.ts

@@ -6,6 +6,7 @@ import type { PreparedBindValues, SqliteDb, SqliteError, UnexpectedError } from
 import { getExecArgsFromMutation } from '../mutation.js'
 import {
   EventId,
+  getMutationDef,
   type LiveStoreSchema,
   MUTATION_LOG_META_TABLE,
   type MutationEvent,
@@ -34,7 +35,7 @@ export const makeApplyMutation: Effect.Effect<ApplyMutation, never, Scope.Scope
       // TODO Running `Schema.hash` can be a bottleneck for larger schemas. There is an opportunity to run this
       // at build time and lookup the pre-computed hash at runtime.
       // Also see https://github.com/Effect-TS/effect/issues/2719
-      [...leaderThreadCtx.schema.mutations.entries()].map(([k, v]) => [k, Schema.hash(v.schema)] as const),
+      [...leaderThreadCtx.schema.mutations.map.entries()].map(([k, v]) => [k, Schema.hash(v.schema)] as const),
     )
 
     return (mutationEventEncoded, options) =>
@@ -43,7 +44,7 @@ export const makeApplyMutation: Effect.Effect<ApplyMutation, never, Scope.Scope
         const skipMutationLog = options?.skipMutationLog ?? false
 
         const mutationName = mutationEventEncoded.mutation
-        const mutationDef = schema.mutations.get(mutationName) ?? shouldNeverHappen(`Unknown mutation: ${mutationName}`)
+        const mutationDef = getMutationDef(schema, mutationName)
 
         const execArgsArr = getExecArgsFromMutation({
           mutationDef,
@@ -175,7 +176,7 @@ const makeShouldExcludeMutationFromLog = memoizeByRef((schema: LiveStoreSchema)
   return (mutationName: string, mutationEventEncoded: MutationEvent.AnyEncoded): boolean => {
     if (mutationLogExclude.has(mutationName)) return true
 
-    const mutationDef = schema.mutations.get(mutationName) ?? shouldNeverHappen(`Unknown mutation: ${mutationName}`)
+    const mutationDef = getMutationDef(schema, mutationName)
     const execArgsArr = getExecArgsFromMutation({
       mutationDef,
       mutationEvent: { decoded: undefined, encoded: mutationEventEncoded },

package/src/rehydrate-from-mutationlog.ts

@@ -4,7 +4,7 @@ import { Chunk, Effect, Option, Schema, Stream } from '@livestore/utils/effect'
 import { type MigrationOptionsFromMutationLog, type SqliteDb, UnexpectedError } from './adapter-types.js'
 import { makeApplyMutation } from './leader-thread/apply-mutation.js'
 import type { LiveStoreSchema, MutationDef, MutationEvent, MutationLogMetaRow } from './schema/mod.js'
-import { EventId, MUTATION_LOG_META_TABLE } from './schema/mod.js'
+import { EventId, getMutationDef, MUTATION_LOG_META_TABLE } from './schema/mod.js'
 import type { PreparedBindValues } from './util.js'
 import { sql } from './util.js'
 
@@ -33,7 +33,7 @@ export const rehydrateFromMutationLog = ({
 
     const processMutation = (row: MutationLogMetaRow) =>
       Effect.gen(function* () {
-        const mutationDef = schema.mutations.get(row.mutation) ?? shouldNeverHappen(`Unknown mutation ${row.mutation}`)
+        const mutationDef = getMutationDef(schema, row.mutation)
 
         if (migrationOptions.excludeMutations?.has(row.mutation) === true) return
 

package/src/schema/MutationEvent.ts

@@ -124,7 +124,7 @@ export const makeMutationEventSchema = <TSchema extends LiveStoreSchema>(
   schema: TSchema,
 ): ForMutationDefRecord<TSchema['_MutationDefMapType']> =>
   Schema.Union(
-    ...[...schema.mutations.values()].map((def) =>
+    ...[...schema.mutations.map.values()].map((def) =>
       Schema.Struct({
         mutation: Schema.Literal(def.name),
         args: def.schema,
@@ -140,7 +140,7 @@ export const makeMutationEventPartialSchema = <TSchema extends LiveStoreSchema>(
   schema: TSchema,
 ): MutationEventPartialSchema<TSchema['_MutationDefMapType']> =>
   Schema.Union(
-    ...[...schema.mutations.values()].map((def) =>
+    ...[...schema.mutations.map.values()].map((def) =>
       Schema.Struct({
         mutation: Schema.Literal(def.name),
         args: def.schema,

package/src/schema/mutations.ts

@@ -2,7 +2,10 @@ import { Schema } from '@livestore/utils/effect'
 
 import type { BindValues } from '../sql-queries/sql-queries.js'
 
-export type MutationDefMap = Map<string | 'livestore.RawSql', MutationDef.Any>
+export type MutationDefMap = {
+  map: Map<string | 'livestore.RawSql', MutationDef.Any>
+  wasProvided: boolean
+}
 export type MutationDefRecord = {
   'livestore.RawSql': RawSqlMutation
   [name: string]: MutationDef.Any

package/src/schema/schema.ts

@@ -72,29 +72,32 @@ export const makeSchema = <TInputSchema extends InputSchema>(
     tables.set(tableDef.sqliteDef.name, tableDef)
   }
 
-  const mutations: MutationDefMap = new Map()
+  const mutations: MutationDefMap = {
+    map: new Map(),
+    wasProvided: inputSchema.mutations !== undefined,
+  }
 
   if (isReadonlyArray(inputSchema.mutations)) {
     for (const mutation of inputSchema.mutations) {
-      mutations.set(mutation.name, mutation)
+      mutations.map.set(mutation.name, mutation)
     }
   } else {
     for (const mutation of Object.values(inputSchema.mutations ?? {})) {
-      if (mutations.has(mutation.name)) {
+      if (mutations.map.has(mutation.name)) {
         shouldNeverHappen(`Duplicate mutation name: ${mutation.name}. Please use unique names for mutations.`)
       }
-      mutations.set(mutation.name, mutation)
+      mutations.map.set(mutation.name, mutation)
     }
   }
 
-  mutations.set(rawSqlMutation.name, rawSqlMutation)
+  mutations.map.set(rawSqlMutation.name, rawSqlMutation)
 
   for (const tableDef of tables.values()) {
     if (tableHasDerivedMutations(tableDef)) {
       const derivedMutationDefs = makeDerivedMutationDefsForTable(tableDef)
-      mutations.set(derivedMutationDefs.insert.name, derivedMutationDefs.insert)
-      mutations.set(derivedMutationDefs.update.name, derivedMutationDefs.update)
-      mutations.set(derivedMutationDefs.delete.name, derivedMutationDefs.delete)
+      mutations.map.set(derivedMutationDefs.insert.name, derivedMutationDefs.insert)
+      mutations.map.set(derivedMutationDefs.update.name, derivedMutationDefs.update)
+      mutations.map.set(derivedMutationDefs.delete.name, derivedMutationDefs.delete)
     }
   }
 
@@ -114,6 +117,15 @@ export const makeSchema = <TInputSchema extends InputSchema>(
   } satisfies LiveStoreSchema
 }
 
+export const getMutationDef = <TSchema extends LiveStoreSchema>(schema: TSchema, mutationName: string) => {
+  const mutationDef = schema.mutations.map.get(mutationName)
+  if (mutationDef === undefined) {
+    const extraInfo = schema.mutations.wasProvided ? '' : ' Please provide \`mutations\` in the schema options.'
+    return shouldNeverHappen(`No mutation definition found for \`${mutationName}\`.${extraInfo}`)
+  }
+  return mutationDef
+}
+
 export namespace FromInputSchema {
   export type DeriveSchema<TInputSchema extends InputSchema> = LiveStoreSchema<
     DbSchemaFromInputSchemaTables<TInputSchema['tables']>,

package/src/schema-management/validate-mutation-defs.ts

@@ -11,7 +11,7 @@ export const validateSchema = (schema: LiveStoreSchema, schemaManager: SchemaMan
     const registeredMutationDefInfos = schemaManager.getMutationDefInfos()
 
     const missingMutationDefs = registeredMutationDefInfos.filter(
-      (registeredMutationDefInfo) => !schema.mutations.has(registeredMutationDefInfo.mutationName),
+      (registeredMutationDefInfo) => !schema.mutations.map.has(registeredMutationDefInfo.mutationName),
     )
 
     if (missingMutationDefs.length > 0) {
@@ -20,7 +20,7 @@ export const validateSchema = (schema: LiveStoreSchema, schemaManager: SchemaMan
       })
     }
 
-    for (const [, mutationDef] of schema.mutations) {
+    for (const [, mutationDef] of schema.mutations.map) {
       const registeredMutationDefInfo = registeredMutationDefInfos.find(
         (info) => info.mutationName === mutationDef.name,
       )

package/src/sync/ClientSessionSyncProcessor.ts

@@ -5,7 +5,7 @@ import * as otel from '@opentelemetry/api'
 
 import type { ClientSession, UnexpectedError } from '../adapter-types.js'
 import * as EventId from '../schema/EventId.js'
-import { type LiveStoreSchema } from '../schema/mod.js'
+import { getMutationDef, type LiveStoreSchema } from '../schema/mod.js'
 import * as MutationEvent from '../schema/MutationEvent.js'
 import * as SyncState from './syncstate.js'
 
@@ -58,10 +58,8 @@ export const makeClientSessionSyncProcessor = ({
   }
 
   const syncStateUpdateQueue = Queue.unbounded<SyncState.SyncState>().pipe(Effect.runSync)
-  const isLocalEvent = (mutationEventEncoded: MutationEvent.EncodedWithMeta) => {
-    const mutationDef = schema.mutations.get(mutationEventEncoded.mutation)!
-    return mutationDef.options.clientOnly
-  }
+  const isLocalEvent = (mutationEventEncoded: MutationEvent.EncodedWithMeta) =>
+    getMutationDef(schema, mutationEventEncoded.mutation).options.clientOnly
 
   /** We're queuing push requests to reduce the number of messages sent to the leader by batching them */
   const leaderPushQueue = BucketQueue.make<MutationEvent.EncodedWithMeta>().pipe(Effect.runSync)
@@ -71,7 +69,7 @@ export const makeClientSessionSyncProcessor = ({
 
     let baseEventId = syncStateRef.current.localHead
     const encodedMutationEvents = batch.map((mutationEvent) => {
-      const mutationDef = schema.mutations.get(mutationEvent.mutation)!
+      const mutationDef = getMutationDef(schema, mutationEvent.mutation)
       const nextIdPair = EventId.nextPair(baseEventId, mutationDef.options.clientOnly)
       baseEventId = nextIdPair.id
       return new MutationEvent.EncodedWithMeta(

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.3.0-dev.17' as const
+export const liveStoreVersion = '0.3.0-dev.18' as const
 
 /**
  * This version number is incremented whenever the internal storage format changes in a breaking way.