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

package/src/devtools/devtools-messages-common.ts

@@ -1,13 +1,17 @@
 import { Schema } from '@livestore/utils/effect'
 
-import { liveStoreVersion as pkgVersion } from '../version.ts'
-
 export { NetworkStatus } from '../sync/sync-backend.ts'
 
 export const requestId = Schema.String
 export const clientId = Schema.String
 export const sessionId = Schema.String
-export const liveStoreVersion = Schema.Literal(pkgVersion)
+/**
+ * Version field for devtools messages.
+ * Uses Schema.String to accept messages from any version (backwards/forwards compatible).
+ * Version checking happens at the application layer after message parsing succeeds,
+ * allowing DevTools to respond with a proper VersionMismatch error instead of silent rejection.
+ */
+export const liveStoreVersion = Schema.String
 
 export const LSDMessage = <Tag extends string, Fields extends Schema.Struct.Fields>(tag: Tag, fields: Fields) =>
   Schema.TaggedStruct(tag, {
@@ -87,7 +91,7 @@ export const LeaderReqResMessage = <
     ...fields.success,
   }).annotations({ identifier: `${tag}.Response.Success` })
 
-  const Error = fields.error
+  const Error = fields.error !== undefined
     ? Schema.TaggedStruct(`${tag}.Response.Error`, {
         requestId,
         liveStoreVersion,

package/src/devtools/devtools-messages-leader.ts

@@ -111,6 +111,17 @@ export class Ping extends LSDReqResMessage('LSD.Leader.Ping', {}) {}
 
 export class Pong extends LSDReqResMessage('LSD.Leader.Pong', {}) {}
 
+/**
+ * Sent by the app when DevTools version doesn't match.
+ * Contains the app's actual version so DevTools can display a meaningful error.
+ */
+export class VersionMismatch extends LSDReqResMessage('LSD.Leader.VersionMismatch', {
+  /** The version running in the app */
+  appVersion: Schema.String,
+  /** The version that was sent by DevTools (that caused the mismatch) */
+  receivedVersion: Schema.String,
+}) {}
+
 export class Disconnect extends LSDReqResMessage('LSD.Leader.Disconnect', {}) {}
 
 export const SetSyncLatch = LeaderReqResMessage('LSD.Leader.SetSyncLatch', {
@@ -181,6 +192,7 @@ export const MessageFromApp = Schema.Union(
   NetworkStatusRes,
   CommitEventRes,
   Pong,
+  VersionMismatch,
   DatabaseFileInfoRes,
   SyncHistoryRes,
   SyncingInfoRes,

package/src/devtools/mod.ts

@@ -42,7 +42,7 @@ export const makeChannelName = {
    * publishers can pass `undefined` to use the legacy global channel name.
    */
   sessionInfo: ({ origin }: { origin: string | undefined }) =>
-    origin ? `session-info::${encodeURIComponent(origin)}` : `session-info`,
+    origin !== undefined ? `session-info::${encodeURIComponent(origin)}` : `session-info`,
   devtoolsClientSession: ({ storeId, clientId, sessionId }: { storeId: string; clientId: string; sessionId: string }) =>
     `devtools-channel(client-session-${storeId}-${clientId}-${sessionId})`,
   devtoolsClientLeader: ({ storeId, clientId, sessionId }: { storeId: string; clientId: string; sessionId: string }) =>

package/src/errors.ts

@@ -2,33 +2,33 @@ import { Cause, Effect, Layer, Schema, Stream } from '@livestore/utils/effect'
 
 import * as LiveStoreEvent from './schema/LiveStoreEvent/mod.ts'
 
-export class UnknownError extends Schema.TaggedError<UnknownError>()('LiveStore.UnknownError', {
+export class UnknownError extends Schema.TaggedError<UnknownError>('~@livestore/common/UnknownError')('UnknownError', {
   cause: Schema.Defect,
   note: Schema.optional(Schema.String),
   payload: Schema.optional(Schema.Any),
 }) {
   static mapToUnknownError = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
     effect.pipe(
-      Effect.mapError((cause) => (Schema.is(UnknownError)(cause) ? cause : new UnknownError({ cause }))),
+      Effect.mapError((cause) => (Schema.is(UnknownError)(cause) === true ? cause : new UnknownError({ cause }))),
       Effect.catchAllDefect((cause) => new UnknownError({ cause })),
     )
 
   static mapToUnknownErrorLayer = <A, E, R>(layer: Layer.Layer<A, E, R>) =>
     layer.pipe(
       Layer.catchAllCause((cause) =>
-        Cause.isFailType(cause) && Schema.is(UnknownError)(cause.error)
+        Cause.isFailType(cause) === true && Schema.is(UnknownError)(cause.error) === true
           ? Layer.fail(cause.error)
           : Layer.fail(new UnknownError({ cause: cause })),
       ),
     )
 
   static mapToUnknownErrorStream = <A, E, R>(stream: Stream.Stream<A, E, R>) =>
-    stream.pipe(Stream.mapError((cause) => (Schema.is(UnknownError)(cause) ? cause : new UnknownError({ cause }))))
+    stream.pipe(Stream.mapError((cause) => (Schema.is(UnknownError)(cause) === true ? cause : new UnknownError({ cause }))))
 }
 
-export class MaterializerHashMismatchError extends Schema.TaggedError<MaterializerHashMismatchError>()(
-  'LiveStore.MaterializerHashMismatchError',
-  {
+export class MaterializerHashMismatchError extends Schema.TaggedError<MaterializerHashMismatchError>(
+  '~@livestore/common/MaterializerHashMismatchError',
+)('MaterializerHashMismatchError', {
     eventName: Schema.String,
     note: Schema.optionalWith(Schema.String, {
       default: () => 'Please make sure your event materializer is a pure function without side effects.',
@@ -36,18 +36,19 @@ export class MaterializerHashMismatchError extends Schema.TaggedError<Materializ
   },
 ) {}
 
-export class IntentionalShutdownCause extends Schema.TaggedError<IntentionalShutdownCause>()(
-  'LiveStore.IntentionalShutdownCause',
-  {
-    reason: Schema.Literal('devtools-reset', 'devtools-import', 'adapter-reset', 'manual'),
-  },
-) {}
+export class IntentionalShutdownCause extends Schema.TaggedError<IntentionalShutdownCause>(
+  '~@livestore/common/IntentionalShutdownCause',
+)('IntentionalShutdownCause', {
+  reason: Schema.Literal('devtools-reset', 'devtools-import', 'adapter-reset', 'manual', 'backend-id-mismatch'),
+}) {}
 
-export class StoreInterrupted extends Schema.TaggedError<StoreInterrupted>()('LiveStore.StoreInterrupted', {
+export class StoreInterrupted extends Schema.TaggedError<StoreInterrupted>(
+  '~@livestore/common/StoreInterrupted',
+)('StoreInterrupted', {
   reason: Schema.String,
 }) {}
 
-export class SqliteError extends Schema.TaggedError<SqliteError>()('LiveStore.SqliteError', {
+export class SqliteError extends Schema.TaggedError<SqliteError>('~@livestore/common/SqliteError')('SqliteError', {
   query: Schema.optional(
     Schema.Struct({
       sql: Schema.String,
@@ -63,14 +64,14 @@ export class SqliteError extends Schema.TaggedError<SqliteError>()('LiveStore.Sq
   note: Schema.optional(Schema.String),
 }) {}
 
-export class UnknownEventError extends Schema.TaggedError<UnknownEventError>()('LiveStore.UnknownEventError', {
+export class UnknownEventError extends Schema.TaggedError<UnknownEventError>('~@livestore/common/UnknownEventError')('UnknownEventError', {
   event: LiveStoreEvent.Client.Encoded.pipe(Schema.pick('name', 'args', 'seqNum', 'clientId', 'sessionId')),
   reason: Schema.Literal('event-definition-missing', 'materializer-missing'),
   operation: Schema.String,
   note: Schema.optional(Schema.String),
 }) {}
 
-export class MaterializeError extends Schema.TaggedError<MaterializeError>()('LiveStore.MaterializeError', {
+export class MaterializeError extends Schema.TaggedError<MaterializeError>('~@livestore/common/MaterializeError')('MaterializeError', {
   cause: Schema.Union(MaterializerHashMismatchError, SqliteError, UnknownEventError),
   note: Schema.optional(Schema.String),
 }) {}

package/src/index.ts

@@ -11,7 +11,9 @@ export * from './schema/state/sqlite/query-builder/mod.ts'
 export * from './schema/state/sqlite/system-tables/mod.ts'
 export * from './schema-management/migrations.ts'
 export * as SqliteDbHelper from './sqlite-db-helper.ts'
+export * from './leader-thread/RejectedPushError.ts'
 export * from './sync/index.ts'
 export * as SyncState from './sync/syncstate.ts'
 export * from './util.ts'
 export * from './version.ts'
+export * from './WorkerTransportError.ts'