@livestore/common 0.4.0-dev.21 → 0.4.0-dev.23

package/src/leader-thread/shutdown-channel.ts

@@ -2,10 +2,8 @@ import type { WebChannel } from '@livestore/utils/effect'
 import { Schema } from '@livestore/utils/effect'
 
 import {
+  BackendIdMismatchError,
   IntentionalShutdownCause,
-  InvalidPullError,
-  InvalidPushError,
-  IsOfflineError,
   MaterializeError,
   UnknownError,
 } from '../index.ts'
@@ -13,9 +11,7 @@ import {
 export class All extends Schema.Union(
   IntentionalShutdownCause,
   UnknownError,
-  IsOfflineError,
-  InvalidPushError,
-  InvalidPullError,
+  BackendIdMismatchError,
   MaterializeError,
 ) {}
 

package/src/leader-thread/stream-events.ts

@@ -1,5 +1,6 @@
 import type { Subscribable } from '@livestore/utils/effect'
 import { Chunk, Effect, Option, Queue, Stream } from '@livestore/utils/effect'
+
 import { EventSequenceNumber, type LiveStoreEvent } from '../schema/mod.ts'
 import type * as SyncState from '../sync/syncstate.ts'
 import * as Eventlog from './eventlog.ts'
@@ -109,7 +110,10 @@ export const streamEventsWithSyncState = ({
              * since === until : Prevent empty query
              * since > until : Incorrectly inverted interval
              */
-            if (options.until && EventSequenceNumber.Client.isGreaterThanOrEqual(cursor, options.until)) {
+            if (
+              options.until !== undefined &&
+              EventSequenceNumber.Client.isGreaterThanOrEqual(cursor, options.until) === true
+            ) {
               return [Chunk.empty(), Option.none()]
             }
 
@@ -144,9 +148,10 @@ export const streamEventsWithSyncState = ({
              * nextHead: The latest head from headQueue
              */
             const waitForHead = EventSequenceNumber.Client.isGreaterThanOrEqual(cursor, head)
-            const maybeHead = waitForHead
-              ? yield* Queue.take(headQueue).pipe(Effect.map(Option.some))
-              : yield* Queue.poll(headQueue)
+            const maybeHead =
+              waitForHead === true
+                ? yield* Queue.take(headQueue).pipe(Effect.map(Option.some))
+                : yield* Queue.poll(headQueue)
             const nextHead = Option.getOrElse(maybeHead, () => head)
             const hardStop = options.until?.global ?? Number.POSITIVE_INFINITY
             const target = EventSequenceNumber.Client.Composite.make({
@@ -181,7 +186,7 @@ export const streamEventsWithSyncState = ({
             const nextState: Option.Option<{
               cursor: EventSequenceNumber.Client.Composite
               head: EventSequenceNumber.Client.Composite
-            }> = reachedUntil ? Option.none() : Option.some({ cursor: target, head: nextHead })
+            }> = reachedUntil === true ? Option.none() : Option.some({ cursor: target, head: nextHead })
 
             const spanAttributes = {
               'livestore.streamEvents.cursor.global': cursor.global,

package/src/leader-thread/types.ts

@@ -17,13 +17,14 @@ import type { MaterializeError } from '../errors.ts'
 import type {
   BootStatus,
   Devtools,
-  LeaderAheadError,
   MakeSqliteDb,
   PersistenceInfo,
   SqliteDb,
   SyncBackend,
   UnknownError,
+  UnknownEventError,
 } from '../index.ts'
+import type { RejectedPushError } from './RejectedPushError.ts'
 import { EventSequenceNumber, type LiveStoreEvent, type LiveStoreSchema } from '../schema/mod.ts'
 import type * as SyncState from '../sync/syncstate.ts'
 import type { ShutdownChannel } from './shutdown-channel.ts'
@@ -186,11 +187,11 @@ export interface LeaderSyncProcessor {
   /** Used by client sessions to subscribe to upstream sync state changes */
   pull: (args: {
     cursor: EventSequenceNumber.Client.Composite
-  }) => Stream.Stream<{ payload: typeof SyncState.PayloadUpstream.Type }, UnknownError>
+  }) => Stream.Stream<{ payload: typeof SyncState.PayloadUpstream.Type }>
   /** The `pullQueue` API can be used instead of `pull` when more convenient */
   pullQueue: (args: {
     cursor: EventSequenceNumber.Client.Composite
-  }) => Effect.Effect<Queue.Queue<{ payload: typeof SyncState.PayloadUpstream.Type }>, UnknownError, Scope.Scope>
+  }) => Effect.Effect<Queue.Queue<{ payload: typeof SyncState.PayloadUpstream.Type }>, never, Scope.Scope>
 
   /** Used by client sessions to push events to the leader thread */
   push: (
@@ -204,18 +205,18 @@ export interface LeaderSyncProcessor {
        */
       waitForProcessing?: boolean
     },
-  ) => Effect.Effect<void, LeaderAheadError>
+  ) => Effect.Effect<void, RejectedPushError>
 
   /** Currently only used by devtools which don't provide their own event numbers */
   pushPartial: (args: {
     event: LiveStoreEvent.Input.Encoded
     clientId: string
     sessionId: string
-  }) => Effect.Effect<void, UnknownError>
+  }) => Effect.Effect<void, UnknownEventError>
 
   boot: Effect.Effect<
     { initialLeaderHead: EventSequenceNumber.Client.Composite },
-    UnknownError,
+    never,
     LeaderThreadCtx | Scope.Scope | HttpClient.HttpClient
   >
   syncState: Subscribable.Subscribable<SyncState.SyncState>

package/src/logging.ts

@@ -33,11 +33,11 @@ export type LoggerDefaults = {
  * Resolve the logger layer to provide to the Effect runtime.
  */
 export const resolveLoggerLayer = (config?: WithLoggerOptions, defaults?: LoggerDefaults): Layer.Layer<never> => {
-  if (config?.logger) return config.logger
-  if (defaults?.defaultLogger) return defaults.defaultLogger
+  if (config?.logger !== undefined) return config.logger
+  if (defaults?.defaultLogger !== undefined) return defaults.defaultLogger
   const threadName = defaults?.threadName ?? 'livestore'
   const mode = defaults?.mode
-  return Logger.prettyWithThread(threadName, mode ? { mode } : {})
+  return Logger.prettyWithThread(threadName, mode !== undefined ? { mode } : {})
 }
 
 /**
@@ -46,7 +46,7 @@ export const resolveLoggerLayer = (config?: WithLoggerOptions, defaults?: Logger
 export const resolveLogLevel = (config?: WithLoggerOptions, defaults?: LoggerDefaults): LogLevel.LogLevel => {
   if (config?.logLevel !== undefined) return config.logLevel
   if (defaults?.defaultLogLevel !== undefined) return defaults.defaultLogLevel
-  return isDevEnv() ? LogLevel.Debug : LogLevel.Info
+  return isDevEnv() === true ? LogLevel.Debug : LogLevel.Info
 }
 
 /**

package/src/make-client-session.ts

@@ -51,11 +51,11 @@ export const makeClientSession = <R>({
   origin: string | undefined
 }): Effect.Effect<ClientSession, never, Scope.Scope | R> =>
   Effect.gen(function* () {
-    const devtools: ClientSession['devtools'] = devtoolsEnabled
+    const devtools: ClientSession['devtools'] = devtoolsEnabled === true
       ? { enabled: true, pullLatch: yield* Effect.makeLatch(true), pushLatch: yield* Effect.makeLatch(true) }
       : { enabled: false }
 
-    if (devtoolsEnabled) {
+    if (devtoolsEnabled === true) {
       yield* Effect.gen(function* () {
         const webmeshNode = yield* Webmesh.makeMeshNode(
           Devtools.makeNodeName.client.session({ storeId, clientId, sessionId }),

package/src/materializer-helper.ts

@@ -34,14 +34,14 @@ export const getExecStatementsFromMaterializer = ({
   const eventDecoded =
     event.decoded === undefined
       ? {
-          ...event.encoded!,
-          args: Schema.decodeUnknownSync(eventDef.schema)(event.encoded!.args),
+          ...event.encoded,
+          args: Schema.decodeUnknownSync(eventDef.schema)(event.encoded.args),
         }
       : event.decoded
 
-  const eventArgsEncoded = isNil(event.decoded?.args)
+  const eventArgsEncoded = isNil(event.decoded?.args) === true
     ? undefined
-    : Schema.encodeUnknownSync(eventDef.schema)(event.decoded!.args)
+    : Schema.encodeUnknownSync(eventDef.schema)(event.decoded.args)
 
   const query: MaterializerContextQuery = (
     rawQueryOrQueryBuilder:
@@ -51,7 +51,7 @@ export const getExecStatementsFromMaterializer = ({
         }
       | QueryBuilder.Any,
   ) => {
-    if (isQueryBuilder(rawQueryOrQueryBuilder)) {
+    if (isQueryBuilder(rawQueryOrQueryBuilder) === true) {
       const { query, bindValues } = rawQueryOrQueryBuilder.asSql()
       const rawResults = dbState.select(query, prepareBindValues(bindValues, query))
       const resultSchema = getResultSchema(rawQueryOrQueryBuilder)
@@ -86,7 +86,7 @@ export const getExecStatementsFromMaterializer = ({
 export const makeMaterializerHash =
   ({ schema, dbState }: { schema: LiveStoreSchema; dbState: SqliteDb }) =>
   (event: LiveStoreEvent.Client.Encoded): Option.Option<number> => {
-    if (isDevEnv()) {
+    if (isDevEnv() === true) {
       // Hashing is only needed during dev-mode diagnostics. Skip work entirely for
       // unknown events (no definition/materializer) so we do not introduce noisy
       // warnings while still returning `Option.none()` to disable hash checks.
@@ -126,10 +126,10 @@ const fromMaterializerResult = (
   bindValues: BindValues
   writeTables: ReadonlySet<string> | undefined
 }> => {
-  if (isReadonlyArray(materializerResult)) {
+  if (isReadonlyArray(materializerResult) === true) {
     return materializerResult.flatMap(fromMaterializerResult)
   }
-  if (isQueryBuilder(materializerResult)) {
+  if (isQueryBuilder(materializerResult) === true) {
     const { query, bindValues, usedTables } = materializerResult.asSql()
     return [{ sql: query, bindValues: bindValues as BindValues, writeTables: usedTables }]
   } else if (typeof materializerResult === 'string') {
@@ -155,7 +155,7 @@ export const replaceSessionIdSymbol = (
 }
 
 const deepReplaceValue = <S, R>(input: any, searchValue: S, replaceValue: R): void => {
-  if (Array.isArray(input)) {
+  if (Array.isArray(input) === true) {
     for (const i in input) {
       if (input[i] === searchValue) {
         input[i] = replaceValue

package/src/otel.ts

@@ -1,6 +1,7 @@
+import * as otel from '@opentelemetry/api'
+
 import { makeNoopTracer } from '@livestore/utils'
 import { Effect, identity, Layer, OtelTracer } from '@livestore/utils/effect'
-import * as otel from '@opentelemetry/api'
 
 export const OtelLiveDummy: Layer.Layer<OtelTracer.OtelTracer> = Layer.suspend(() => {
   const OtelTracerLive = Layer.succeed(OtelTracer.OtelTracer, makeNoopTracer())
@@ -22,7 +23,7 @@ export const provideOtel =
     ) as any as Layer.Layer<OtelTracer.OtelTracer>
 
     return effect.pipe(
-      parentSpanContext
+      parentSpanContext !== undefined
         ? Effect.withParentSpan(OtelTracer.makeExternalSpan(otel.trace.getSpanContext(parentSpanContext)!))
         : identity,
       Effect.provide(TracingLive),

package/src/rematerialize-from-eventlog.ts

@@ -8,7 +8,10 @@ import { EventSequenceNumber, LiveStoreEvent, resolveEventDef, SystemTables } fr
 import type { PreparedBindValues } from './util.ts'
 import { sql } from './util.ts'
 
-export const rematerializeFromEventlog = ({
+/** Parse JSON string to unknown value */
+const jsonParse = Schema.decodeUnknownSync(Schema.parseJson())
+
+export const rematerializeFromEventlog = Effect.fn('@livestore/common:rematerializeFromEventlog')(function* ({
   dbEventlog,
   // TODO re-use this db when bringing back the boot in-memory db implementation
   // db,
@@ -21,69 +24,69 @@ export const rematerializeFromEventlog = ({
   schema: LiveStoreSchema
   onProgress: (_: { done: number; total: number }) => Effect.Effect<void>
   materializeEvent: MaterializeEvent
-}) =>
-  Effect.gen(function* () {
+}) {
     const eventsCount = dbEventlog.select<{ count: number }>(
       `SELECT COUNT(*) AS count FROM ${SystemTables.EVENTLOG_META_TABLE}`,
     )[0]!.count
 
     const hashEventDef = memoizeByRef((event: EventDef.AnyWithoutFn) => Schema.hash(event.schema))
 
-    const processEvent = (row: SystemTables.EventlogMetaRow) =>
-      Effect.gen(function* () {
-        const args = JSON.parse(row.argsJson)
-        const eventEncoded = LiveStoreEvent.Client.EncodedWithMeta.make({
-          name: row.name,
-          args,
-          seqNum: {
-            global: row.seqNumGlobal,
-            client: row.seqNumClient,
-            rebaseGeneration: row.seqNumRebaseGeneration,
-          },
-          parentSeqNum: {
-            global: row.parentSeqNumGlobal,
-            client: row.parentSeqNumClient,
-            rebaseGeneration: row.parentSeqNumRebaseGeneration,
-          },
-          clientId: row.clientId,
-          sessionId: row.sessionId,
-        })
-
-        const resolution = yield* resolveEventDef(schema, {
-          operation: '@livestore/common:rematerializeFromEventlog:processEvent',
-          event: eventEncoded,
-        }).pipe(UnknownError.mapToUnknownError)
-
-        if (resolution._tag === 'unknown') {
-          // Old snapshots can contain newer events. Skip until the runtime has
-          // been updated; the event stays in the log for future replays.
-          return
-        }
-
-        const { eventDef } = resolution
-
-        if (hashEventDef(eventDef) !== row.schemaHash) {
-          yield* Effect.logWarning(
-            `Schema hash mismatch for event definition ${row.name}. Trying to materialize event anyway.`,
-          )
-        }
-
-        // Checking whether the schema has changed in an incompatible way
-        yield* Schema.decodeUnknown(eventDef.schema)(args).pipe(
-          Effect.mapError((cause) =>
-            UnknownError.make({
-              cause,
-              note: `\
+    const processEvent = Effect.fn(`@livestore/common:rematerializeFromEventlog:processEvent`)(function* (
+      row: SystemTables.EventlogMetaRow,
+    ) {
+      const args = jsonParse(row.argsJson)
+      const eventEncoded = LiveStoreEvent.Client.EncodedWithMeta.make({
+        name: row.name,
+        args,
+        seqNum: {
+          global: row.seqNumGlobal,
+          client: row.seqNumClient,
+          rebaseGeneration: row.seqNumRebaseGeneration,
+        },
+        parentSeqNum: {
+          global: row.parentSeqNumGlobal,
+          client: row.parentSeqNumClient,
+          rebaseGeneration: row.parentSeqNumRebaseGeneration,
+        },
+        clientId: row.clientId,
+        sessionId: row.sessionId,
+      })
+
+      const resolution = yield* resolveEventDef(schema, {
+        operation: '@livestore/common:rematerializeFromEventlog:processEvent',
+        event: eventEncoded,
+      }).pipe(UnknownError.mapToUnknownError)
+
+      if (resolution._tag === 'unknown') {
+        // Old snapshots can contain newer events. Skip until the runtime has
+        // been updated; the event stays in the log for future replays.
+        return
+      }
+
+      const { eventDef } = resolution
+
+      if (hashEventDef(eventDef) !== row.schemaHash) {
+        yield* Effect.logWarning(
+          `Schema hash mismatch for event definition ${row.name}. Trying to materialize event anyway.`,
+        )
+      }
+
+      // Checking whether the schema has changed in an incompatible way
+      yield* Schema.decodeUnknown(eventDef.schema)(args).pipe(
+        Effect.mapError((cause) =>
+          UnknownError.make({
+            cause,
+            note: `\
 There was an error during rematerializing from the eventlog while decoding
 the persisted event args for event definition "${row.name}".
 This likely means the schema has changed in an incompatible way.
 `,
-            }),
-          ),
-        )
+          }),
+        ),
+      )
 
-        yield* materializeEvent(eventEncoded, { skipEventlog: true })
-      }).pipe(Effect.withSpan(`@livestore/common:rematerializeFromEventlog:processEvent`))
+      yield* materializeEvent(eventEncoded, { skipEventlog: true })
+    })
 
     const CHUNK_SIZE = 100
 
@@ -101,9 +104,9 @@ LIMIT ${CHUNK_SIZE}
       SystemTables.EventlogMetaRow
     >({ _tag: 'Initial' }, (item) => {
       // End stream if no more rows
-      if (Chunk.isChunk(item) && item.length === 0) return Option.none()
+      if (Chunk.isChunk(item) === true && item.length === 0) return Option.none()
 
-      const lastId = Chunk.isChunk(item)
+      const lastId = Chunk.isChunk(item) === true
         ? Chunk.last(item).pipe(
             Option.map((_) => ({ global: _.seqNumGlobal, client: _.seqNumClient })),
             Option.getOrElse(() => EventSequenceNumber.Client.ROOT),
@@ -115,7 +118,7 @@ LIMIT ${CHUNK_SIZE}
           $seqNumClient: lastId?.client,
         } as any as PreparedBindValues),
       )
-      const prevItem = Chunk.isChunk(item) ? item : Chunk.empty()
+      const prevItem = Chunk.isChunk(item) === true ? item : Chunk.empty()
       return Option.some([prevItem, nextItem])
     }).pipe(
       Stream.bufferChunks({ capacity: 2 }),
@@ -129,7 +132,4 @@ LIMIT ${CHUNK_SIZE}
       ),
       Stream.runDrain,
     )
-  }).pipe(
-    Effect.withPerformanceMeasure('@livestore/common:rematerializeFromEventlog'),
-    Effect.withSpan('@livestore/common:rematerializeFromEventlog'),
-  )
+}, Effect.withPerformanceMeasure('@livestore/common:rematerializeFromEventlog'))

package/src/schema/EventDef/define.ts

@@ -69,6 +69,21 @@ export type DefineEventOptions<TTo, TDerived extends boolean = false> = {
    * @default false
    */
   derived?: TDerived
+
+  /**
+   * Marks the entire event as deprecated with a reason message.
+   * When this event is committed, a warning will be logged.
+   *
+   * @example
+   * ```ts
+   * Events.synced({
+   *   name: 'v1.TodoRenamed',
+   *   schema: Schema.Struct({ id: Schema.String, name: Schema.String }),
+   *   deprecated: "Use 'v1.TodoUpdated' instead",
+   * })
+   * ```
+   */
+  deprecated?: string
 }
 
 /**
@@ -112,19 +127,20 @@ export const defineEvent = <TName extends string, TType, TEncoded = TType, TDeri
   Object.defineProperty(makePartialEvent, 'options', {
     value: {
       clientOnly: options?.clientOnly ?? false,
-      facts: options?.facts
+      facts: options?.facts !== undefined
         ? (args, currentFacts) => {
             const res = options.facts!(args, currentFacts)
             return {
               modify: {
-                set: res.modify?.set ? new Set(res.modify.set) : new Set(),
-                unset: res.modify?.unset ? new Set(res.modify.unset) : new Set(),
+                set: res.modify?.set !== undefined ? new Set(res.modify.set) : new Set(),
+                unset: res.modify?.unset !== undefined ? new Set(res.modify.unset) : new Set(),
               },
-              require: res.require ? new Set(res.require) : new Set(),
+              require: res.require !== undefined ? new Set(res.require) : new Set(),
             }
           }
         : undefined,
       derived: options?.derived ?? false,
+      deprecated: options?.deprecated,
     } satisfies EventDef.Any['options'],
   })
 
@@ -163,7 +179,7 @@ export const synced = <TName extends string, TType, TEncoded = TType>(
   args: {
     name: TName
     schema: Schema.Schema<TType, TEncoded>
-  } & Omit<DefineEventOptions<TType, false>, 'derived' | 'clientOnly'>,
+  } & Omit<DefineEventOptions<TType>, 'derived' | 'clientOnly'>,
 ): EventDef<TName, TType, TEncoded> => defineEvent({ ...args, clientOnly: false })
 
 /**
@@ -197,5 +213,5 @@ export const clientOnly = <TName extends string, TType, TEncoded = TType>(
   args: {
     name: TName
     schema: Schema.Schema<TType, TEncoded>
-  } & Omit<DefineEventOptions<TType, false>, 'derived' | 'clientOnly'>,
+  } & Omit<DefineEventOptions<TType>, 'derived' | 'clientOnly'>,
 ): EventDef<TName, TType, TEncoded> => defineEvent({ ...args, clientOnly: true })

package/src/schema/EventDef/deprecated.test.ts

@@ -0,0 +1,129 @@
+import { afterEach, beforeEach, describe, expect, test } from 'vitest'
+
+import { Effect, Logger, Schema } from '@livestore/utils/effect'
+
+import { synced } from './define.ts'
+import {
+  deprecated,
+  findDeprecatedFieldsWithValues,
+  getDeprecatedReason,
+  isDeprecated,
+  logDeprecationWarnings,
+  resetDeprecationWarnings,
+} from './deprecated.ts'
+
+describe('deprecated annotations', () => {
+  test('adds deprecation annotation to schema', () => {
+    const schema = Schema.String.pipe(deprecated('Use newField instead'))
+    expect(isDeprecated(schema)).toBe(true)
+    expect(getDeprecatedReason(schema)._tag).toBe('Some')
+  })
+
+  test('works with optional fields in Struct', () => {
+    const struct = Schema.Struct({
+      oldField: Schema.optional(Schema.String).pipe(deprecated('Legacy')),
+    })
+    expect(findDeprecatedFieldsWithValues(struct, { oldField: 'x' })).toEqual([{ field: 'oldField', reason: 'Legacy' }])
+  })
+
+  test('non-deprecated schemas return false', () => {
+    expect(isDeprecated(Schema.String)).toBe(false)
+  })
+
+  test('ignores deprecated fields without values', () => {
+    const schema = Schema.Struct({
+      id: Schema.String,
+      old: Schema.optional(Schema.String).pipe(deprecated('x')),
+    })
+    expect(findDeprecatedFieldsWithValues(schema, { id: '1' })).toEqual([])
+  })
+
+  test('finds multiple deprecated fields', () => {
+    const schema = Schema.Struct({
+      a: Schema.optional(Schema.String).pipe(deprecated('A')),
+      b: Schema.optional(Schema.String).pipe(deprecated('B')),
+    })
+    const result = findDeprecatedFieldsWithValues(schema, { a: '1', b: '2' })
+    expect(result).toHaveLength(2)
+  })
+})
+
+describe('logDeprecationWarnings', () => {
+  let logs: unknown[][]
+
+  beforeEach(() => {
+    resetDeprecationWarnings()
+    logs = []
+  })
+
+  afterEach(() => resetDeprecationWarnings())
+
+  const run = (effect: Effect.Effect<void>) =>
+    Effect.runSync(
+      effect.pipe(
+        Effect.provide(
+          Logger.replace(
+            Logger.defaultLogger,
+            Logger.make(({ message }) => logs.push(message as unknown[])),
+          ),
+        ),
+      ),
+    )
+
+  test('logs event deprecation warning', () => {
+    const event = synced({ name: 'Old', schema: Schema.Struct({ id: Schema.String }), deprecated: 'Use New' })
+    run(logDeprecationWarnings(event, { id: '1' }))
+    expect(logs).toEqual([['@livestore/schema:deprecated-event', { event: 'Old', reason: 'Use New' }]])
+  })
+
+  test('logs field deprecation warning', () => {
+    const event = synced({
+      name: 'Ev',
+      schema: Schema.Struct({ old: Schema.optional(Schema.String).pipe(deprecated('Use new')) }),
+    })
+    run(logDeprecationWarnings(event, { old: 'x' }))
+    expect(logs).toEqual([['@livestore/schema:deprecated-field', { event: 'Ev', field: 'old', reason: 'Use new' }]])
+  })
+
+  test('deduplicates event warnings', () => {
+    const event = synced({ name: 'Dup', schema: Schema.Struct({ id: Schema.String }), deprecated: 'x' })
+    run(logDeprecationWarnings(event, { id: '1' }))
+    run(logDeprecationWarnings(event, { id: '2' }))
+    expect(logs).toHaveLength(1)
+  })
+
+  test('deduplicates field warnings', () => {
+    const event = synced({
+      name: 'DupField',
+      schema: Schema.Struct({ old: Schema.optional(Schema.String).pipe(deprecated('x')) }),
+    })
+    run(logDeprecationWarnings(event, { old: 'a' }))
+    run(logDeprecationWarnings(event, { old: 'b' }))
+    expect(logs).toHaveLength(1)
+  })
+
+  test('no warning for non-deprecated event', () => {
+    const event = synced({ name: 'Normal', schema: Schema.Struct({ id: Schema.String }) })
+    run(logDeprecationWarnings(event, { id: '1' }))
+    expect(logs).toHaveLength(0)
+  })
+
+  test('no warning when deprecated field is undefined', () => {
+    const event = synced({
+      name: 'Unused',
+      schema: Schema.Struct({ old: Schema.optional(Schema.String).pipe(deprecated('x')) }),
+    })
+    run(logDeprecationWarnings(event, {}))
+    expect(logs).toHaveLength(0)
+  })
+
+  test('logs both event and field warnings', () => {
+    const event = synced({
+      name: 'Both',
+      schema: Schema.Struct({ old: Schema.optional(Schema.String).pipe(deprecated('F')) }),
+      deprecated: 'E',
+    })
+    run(logDeprecationWarnings(event, { old: 'x' }))
+    expect(logs).toHaveLength(2)
+  })
+})