@livestore/common 0.3.0-dev.19 → 0.3.0-dev.21

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

@@ -1,16 +1,10 @@
 import { Schema, Transferable } from '@livestore/utils/effect'
 
-import { NetworkStatus, UnexpectedError } from '../adapter-types.js'
+import { NetworkStatus } from '../adapter-types.js'
 import { EventId } from '../schema/mod.js'
 import * as MutationEvent from '../schema/MutationEvent.js'
 import * as SyncState from '../sync/syncstate.js'
-import {
-  LeaderReqResMessage,
-  liveStoreVersion,
-  LSDMessage,
-  LSDReqResMessage,
-  requestId,
-} from './devtools-messages-common.js'
+import { LeaderReqResMessage, LSDMessage, LSDReqResMessage } from './devtools-messages-common.js'
 
 export class ResetAllDataReq extends LSDReqResMessage('LSD.Leader.ResetAllDataReq', {
   mode: Schema.Literal('all-data', 'only-app-db'),
@@ -28,11 +22,16 @@ export class DatabaseFileInfoRes extends LSDReqResMessage('LSD.Leader.DatabaseFi
   mutationLog: DatabaseFileInfo,
 }) {}
 
-export class NetworkStatusSubscribe extends LSDReqResMessage('LSD.Leader.NetworkStatusSubscribe', {}) {}
-export class NetworkStatusUnsubscribe extends LSDReqResMessage('LSD.Leader.NetworkStatusUnsubscribe', {}) {}
+export class NetworkStatusSubscribe extends LSDReqResMessage('LSD.Leader.NetworkStatusSubscribe', {
+  subscriptionId: Schema.String,
+}) {}
+export class NetworkStatusUnsubscribe extends LSDReqResMessage('LSD.Leader.NetworkStatusUnsubscribe', {
+  subscriptionId: Schema.String,
+}) {}
 
 export class NetworkStatusRes extends LSDReqResMessage('LSD.Leader.NetworkStatusRes', {
   networkStatus: NetworkStatus,
+  subscriptionId: Schema.String,
 }) {}
 
 export class SyncingInfoReq extends LSDReqResMessage('LSD.Leader.SyncingInfoReq', {}) {}
@@ -46,18 +45,28 @@ export class SyncingInfoRes extends LSDReqResMessage('LSD.Leader.SyncingInfoRes'
   syncingInfo: SyncingInfo,
 }) {}
 
-export class SyncHistorySubscribe extends LSDReqResMessage('LSD.Leader.SyncHistorySubscribe', {}) {}
-export class SyncHistoryUnsubscribe extends LSDReqResMessage('LSD.Leader.SyncHistoryUnsubscribe', {}) {}
+export class SyncHistorySubscribe extends LSDReqResMessage('LSD.Leader.SyncHistorySubscribe', {
+  subscriptionId: Schema.String,
+}) {}
+export class SyncHistoryUnsubscribe extends LSDReqResMessage('LSD.Leader.SyncHistoryUnsubscribe', {
+  subscriptionId: Schema.String,
+}) {}
 export class SyncHistoryRes extends LSDReqResMessage('LSD.Leader.SyncHistoryRes', {
   mutationEventEncoded: MutationEvent.AnyEncodedGlobal,
   metadata: Schema.Option(Schema.JsonValue),
+  subscriptionId: Schema.String,
 }) {}
 
-export class SyncHeadSubscribe extends LSDReqResMessage('LSD.Leader.SyncHeadSubscribe', {}) {}
-export class SyncHeadUnsubscribe extends LSDReqResMessage('LSD.Leader.SyncHeadUnsubscribe', {}) {}
+export class SyncHeadSubscribe extends LSDReqResMessage('LSD.Leader.SyncHeadSubscribe', {
+  subscriptionId: Schema.String,
+}) {}
+export class SyncHeadUnsubscribe extends LSDReqResMessage('LSD.Leader.SyncHeadUnsubscribe', {
+  subscriptionId: Schema.String,
+}) {}
 export class SyncHeadRes extends LSDReqResMessage('LSD.Leader.SyncHeadRes', {
   local: EventId.EventId,
   upstream: EventId.EventId,
+  subscriptionId: Schema.String,
 }) {}
 
 export class SnapshotReq extends LSDReqResMessage('LSD.Leader.SnapshotReq', {}) {}
@@ -66,13 +75,19 @@ export class SnapshotRes extends LSDReqResMessage('LSD.Leader.SnapshotRes', {
   snapshot: Transferable.Uint8Array,
 }) {}
 
-export class LoadDatabaseFileReq extends LSDReqResMessage('LSD.Leader.LoadDatabaseFileReq', {
-  data: Transferable.Uint8Array,
-}) {}
-
-export class LoadDatabaseFileRes extends LSDReqResMessage('LSD.Leader.LoadDatabaseFileRes', {
-  status: Schema.Literal('ok', 'unsupported-file', 'unsupported-database'),
-}) {}
+export const LoadDatabaseFile = LeaderReqResMessage('LSD.Leader.LoadDatabaseFile', {
+  payload: {
+    data: Transferable.Uint8Array,
+  },
+  success: {},
+  error: {
+    cause: Schema.Union(
+      Schema.TaggedStruct('unsupported-file', {}),
+      Schema.TaggedStruct('unsupported-database', {}),
+      Schema.TaggedStruct('unexpected-error', { cause: Schema.Defect }),
+    ),
+  },
+})
 
 // TODO refactor this to use push/pull semantics
 export class SyncPull extends LSDMessage('LSD.Leader.SyncPull', {
@@ -113,32 +128,32 @@ export const ResetAllData = LeaderReqResMessage('LSD.Leader.ResetAllData', {
 })
 
 // TODO move to `Schema.TaggedRequest` once new RPC is ready https://github.com/Effect-TS/effect/pull/4362
-export class DatabaseFileInfo_ extends Schema.TaggedRequest<DatabaseFileInfo_>()('LSD.Leader.DatabaseFileInfo', {
-  payload: {
-    requestId,
-    liveStoreVersion,
-  },
-  success: DatabaseFileInfo,
-  failure: UnexpectedError,
-}) {}
-
-export class NetworkStatus_ extends Schema.TaggedRequest<NetworkStatus_>()('LSD.Leader.NetworkStatus', {
-  payload: {
-    requestId,
-    liveStoreVersion,
-  },
-  success: NetworkStatus,
-  failure: UnexpectedError,
-}) {}
-
-export const MessageToApp_ = Schema.Union(DatabaseFileInfo_, NetworkStatus_)
-
-export type MessageToApp_ = typeof MessageToApp_.Type
+// export class DatabaseFileInfo_ extends Schema.TaggedRequest<DatabaseFileInfo_>()('LSD.Leader.DatabaseFileInfo', {
+//   payload: {
+//     requestId,
+//     liveStoreVersion,
+//   },
+//   success: DatabaseFileInfo,
+//   failure: UnexpectedError,
+// }) {}
+
+// export class NetworkStatus_ extends Schema.TaggedRequest<NetworkStatus_>()('LSD.Leader.NetworkStatus', {
+//   payload: {
+//     requestId,
+//     liveStoreVersion,
+//   },
+//   success: NetworkStatus,
+//   failure: UnexpectedError,
+// }) {}
+
+// export const MessageToApp_ = Schema.Union(DatabaseFileInfo_, NetworkStatus_)
+
+// export type MessageToApp_ = typeof MessageToApp_.Type
 //
 
 export const MessageToApp = Schema.Union(
   SnapshotReq,
-  LoadDatabaseFileReq,
+  LoadDatabaseFile.Request,
   MutationLogReq,
   ResetAllData.Request,
   NetworkStatusSubscribe,
@@ -159,7 +174,7 @@ export type MessageToApp = typeof MessageToApp.Type
 
 export const MessageFromApp = Schema.Union(
   SnapshotRes,
-  LoadDatabaseFileRes,
+  LoadDatabaseFile.Response,
   MutationLogRes,
   Disconnect,
   SyncPull,
@@ -170,8 +185,8 @@ export const MessageFromApp = Schema.Union(
   SyncHistoryRes,
   SyncingInfoRes,
   SyncHeadRes,
-  ResetAllData.Response,
-  SetSyncLatch.Response,
+  ResetAllData.Success,
+  SetSyncLatch.Success,
 ).annotations({ identifier: 'LSD.Leader.MessageFromApp' })
 
 export type MessageFromApp = typeof MessageFromApp.Type

package/src/devtools/devtools-sessioninfo.ts

@@ -0,0 +1,99 @@
+import type { ParseResult, Scope, WebChannel } from '@livestore/utils/effect'
+import {
+  Data,
+  Duration,
+  Effect,
+  FiberMap,
+  HashSet,
+  Schedule,
+  Schema,
+  Stream,
+  Subscribable,
+  SubscriptionRef,
+} from '@livestore/utils/effect'
+
+export const RequestSessions = Schema.TaggedStruct('RequestSessions', {})
+export type RequestSessions = typeof RequestSessions.Type
+
+export const SessionInfo = Schema.TaggedStruct('SessionInfo', {
+  storeId: Schema.String,
+  clientId: Schema.String,
+  sessionId: Schema.String,
+})
+export type SessionInfo = typeof SessionInfo.Type
+
+export const Message = Schema.Union(RequestSessions, SessionInfo)
+export type Message = typeof Message.Type
+
+/** Usually called in client session */
+export const provideSessionInfo = ({
+  webChannel,
+  sessionInfo,
+}: {
+  webChannel: WebChannel.WebChannel<Message, Message>
+  sessionInfo: SessionInfo
+}): Effect.Effect<void, ParseResult.ParseError> =>
+  Effect.gen(function* () {
+    yield* webChannel.send(sessionInfo)
+
+    yield* webChannel.listen.pipe(
+      Stream.flatten(),
+      Stream.filter(Schema.is(RequestSessions)),
+      Stream.tap(() => webChannel.send(sessionInfo)),
+      Stream.runDrain,
+    )
+  })
+
+/** Usually called in devtools */
+export const requestSessionInfoSubscription = ({
+  webChannel,
+  pollInterval = Duration.seconds(1),
+  staleTimeout = Duration.seconds(5),
+}: {
+  webChannel: WebChannel.WebChannel<Message, Message>
+  pollInterval?: Duration.DurationInput
+  staleTimeout?: Duration.DurationInput
+}): Effect.Effect<Subscribable.Subscribable<Set<SessionInfo>>, ParseResult.ParseError, Scope.Scope> =>
+  Effect.gen(function* () {
+    yield* webChannel
+      .send(RequestSessions.make({}))
+      .pipe(
+        Effect.repeat(Schedule.spaced(pollInterval)),
+        Effect.interruptible,
+        Effect.tapCauseLogPretty,
+        Effect.forkScoped,
+      )
+
+    const timeoutFiberMap = yield* FiberMap.make<SessionInfo>()
+
+    const sessionInfoSubRef = yield* SubscriptionRef.make<HashSet.HashSet<SessionInfo>>(HashSet.empty())
+
+    yield* webChannel.listen.pipe(
+      Stream.flatten(),
+      Stream.filter(Schema.is(SessionInfo)),
+      Stream.map(Data.struct),
+      Stream.tap(
+        Effect.fn(function* (sessionInfo) {
+          yield* SubscriptionRef.getAndUpdate(sessionInfoSubRef, HashSet.add(sessionInfo))
+
+          // Remove sessionInfo from cache after staleTimeout (unless a new identical item resets the timeout)
+          yield* FiberMap.run(
+            timeoutFiberMap,
+            sessionInfo,
+            Effect.gen(function* () {
+              yield* Effect.sleep(staleTimeout)
+              yield* SubscriptionRef.getAndUpdate(sessionInfoSubRef, HashSet.remove(sessionInfo))
+            }),
+          )
+        }),
+      ),
+      Stream.runDrain,
+      Effect.tapCauseLogPretty,
+      Effect.forkScoped,
+    )
+
+    return Subscribable.make({
+      get: sessionInfoSubRef.get.pipe(Effect.map((sessionInfos) => new Set(sessionInfos))),
+      changes: sessionInfoSubRef.changes.pipe(Stream.map((sessionInfos) => new Set(sessionInfos))),
+    })
+  })

package/src/devtools/mod.ts

@@ -0,0 +1,36 @@
+import { Schema } from '@livestore/utils/effect'
+
+export * from './devtools-messages.js'
+export * from './devtools-window-message.js'
+export * as SessionInfo from './devtools-sessioninfo.js'
+export const ClientSessionInfo = Schema.Struct({
+  storeId: Schema.String,
+  clientId: Schema.String,
+  sessionId: Schema.String,
+})
+
+export const DevtoolsMode = Schema.Union(
+  Schema.TaggedStruct('expo', {
+    // TODO get rid of embedded `clientSessionInfo`
+    clientSessionInfo: Schema.optional(ClientSessionInfo),
+  }),
+  // TODO add storeId, clientId and sessionId for Node
+  Schema.TaggedStruct('node', {
+    // TODO get rid of embedded `clientSessionInfo`
+    clientSessionInfo: Schema.UndefinedOr(ClientSessionInfo),
+    url: Schema.String,
+  }),
+  Schema.TaggedStruct('web', {
+    // TODO get rid of embedded `clientSessionInfo`
+    clientSessionInfo: Schema.UndefinedOr(ClientSessionInfo),
+  }),
+  Schema.TaggedStruct('browser-extension', {
+    // TODO get rid of embedded `clientSessionInfo`
+    clientSessionInfo: Schema.UndefinedOr(ClientSessionInfo),
+  }),
+)
+
+export type DevtoolsMode = typeof DevtoolsMode.Type
+
+export const DevtoolsModeTag = DevtoolsMode.pipe(Schema.pluck('_tag'), Schema.typeSchema)
+export type DevtoolsModeTag = typeof DevtoolsModeTag.Type

package/src/index.ts

@@ -8,7 +8,7 @@ export * from './rehydrate-from-mutationlog.js'
 export * from './query-info.js'
 export * from './derived-mutations.js'
 export * from './sync/index.js'
-export * as Devtools from './devtools/index.js'
+export * as Devtools from './devtools/mod.js'
 export * from './debug-info.js'
 export * from './bounded-collections.js'
 export * from './version.js'

package/src/leader-thread/leader-worker-devtools.ts

@@ -1,4 +1,5 @@
 import { Effect, FiberMap, Option, Stream, SubscriptionRef } from '@livestore/utils/effect'
+import { nanoid } from '@livestore/utils/nanoid'
 
 import { Devtools, IntentionalShutdownCause, liveStoreVersion, UnexpectedError } from '../index.js'
 import { MUTATION_LOG_META_TABLE, SCHEMA_META_TABLE, SCHEMA_MUTATIONS_META_TABLE } from '../schema/mod.js'
@@ -72,20 +73,37 @@ const listenToDevtools = ({
       devtools,
     } = yield* LeaderThreadCtx
 
+    type SubscriptionId = string
+    const subscriptionFiberMap = yield* FiberMap.make<SubscriptionId>()
+
     type RequestId = string
-    const subscriptionFiberMap = yield* FiberMap.make<RequestId>()
+    const handledRequestIds = new Set<RequestId>()
 
     yield* incomingMessages.pipe(
       Stream.tap((decodedEvent) =>
         Effect.gen(function* () {
-          // yield* Effect.logDebug('[@livestore/common:leader-thread:devtools] incomingMessage', decodedEvent)
+          const { requestId } = decodedEvent
+          const reqPayload = { requestId, liveStoreVersion, clientId }
+
+          // yield* Effect.logDebug(
+          //   `[@livestore/common:leader-thread:devtools] incomingMessage: ${decodedEvent._tag} (${requestId})`,
+          //   decodedEvent,
+          // )
 
           if (decodedEvent._tag === 'LSD.Leader.Disconnect') {
             return
           }
 
-          const { requestId } = decodedEvent
-          const reqPayload = { requestId, liveStoreVersion, clientId }
+          // TODO we should try to move the duplicate message handling on the webmesh layer
+          // So far I could only observe this problem with webmesh proxy channels (e.g. for Expo)
+          // Proof: https://share.cleanshot.com/V9G87B0B
+          // Also see `store/devtools.ts` for same problem
+          if (handledRequestIds.has(requestId)) {
+            // yield* Effect.logWarning(`Duplicate message`, decodedEvent)
+            return
+          }
+
+          handledRequestIds.add(requestId)
 
           switch (decodedEvent._tag) {
             case 'LSD.Leader.Ping': {
@@ -99,7 +117,7 @@ const listenToDevtools = ({
 
               return
             }
-            case 'LSD.Leader.LoadDatabaseFileReq': {
+            case 'LSD.Leader.LoadDatabaseFile.Request': {
               const { data } = decodedEvent
 
               let tableNames: Set<string>
@@ -114,39 +132,57 @@ const listenToDevtools = ({
                 tableNames = new Set(tableNameResults.map((_) => _.name))
 
                 tmpDb.close()
-              } catch (e) {
-                yield* Effect.logError(`Error importing database file`, e)
+              } catch (cause) {
+                yield* Effect.logError(`Error importing database file`, cause)
                 yield* sendMessage(
-                  Devtools.Leader.LoadDatabaseFileRes.make({ ...reqPayload, status: 'unsupported-file' }),
+                  Devtools.Leader.LoadDatabaseFile.Error.make({
+                    ...reqPayload,
+                    cause: { _tag: 'unexpected-error', cause },
+                  }),
                 )
 
                 return
               }
 
-              if (tableNames.has(MUTATION_LOG_META_TABLE)) {
-                yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
+              try {
+                if (tableNames.has(MUTATION_LOG_META_TABLE)) {
+                  // Is mutation log
+                  yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
 
-                dbMutationLog.import(data)
+                  dbMutationLog.import(data)
 
-                dbReadModel.destroy()
-              } else if (tableNames.has(SCHEMA_META_TABLE) && tableNames.has(SCHEMA_MUTATIONS_META_TABLE)) {
-                yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
+                  dbReadModel.destroy()
+                } else if (tableNames.has(SCHEMA_META_TABLE) && tableNames.has(SCHEMA_MUTATIONS_META_TABLE)) {
+                  // Is read model
+                  yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
 
-                dbReadModel.import(data)
+                  dbReadModel.import(data)
 
-                dbMutationLog.destroy()
-              } else {
+                  dbMutationLog.destroy()
+                } else {
+                  yield* sendMessage(
+                    Devtools.Leader.LoadDatabaseFile.Error.make({
+                      ...reqPayload,
+                      cause: { _tag: 'unsupported-database' },
+                    }),
+                  )
+                  return
+                }
+
+                yield* sendMessage(Devtools.Leader.LoadDatabaseFile.Success.make({ ...reqPayload }))
+                yield* shutdownChannel.send(IntentionalShutdownCause.make({ reason: 'devtools-import' })) ?? Effect.void
+
+                return
+              } catch (cause) {
+                yield* Effect.logError(`Error importing database file`, cause)
                 yield* sendMessage(
-                  Devtools.Leader.LoadDatabaseFileRes.make({ ...reqPayload, status: 'unsupported-database' }),
+                  Devtools.Leader.LoadDatabaseFile.Error.make({
+                    ...reqPayload,
+                    cause: { _tag: 'unexpected-error', cause },
+                  }),
                 )
                 return
               }
-
-              yield* sendMessage(Devtools.Leader.LoadDatabaseFileRes.make({ ...reqPayload, status: 'ok' }))
-
-              yield* shutdownChannel.send(IntentionalShutdownCause.make({ reason: 'devtools-import' })) ?? Effect.void
-
-              return
             }
             case 'LSD.Leader.ResetAllData.Request': {
               const { mode } = decodedEvent
@@ -159,7 +195,7 @@ const listenToDevtools = ({
                 dbMutationLog.destroy()
               }
 
-              yield* sendMessage(Devtools.Leader.ResetAllData.Response.make({ ...reqPayload }))
+              yield* sendMessage(Devtools.Leader.ResetAllData.Success.make({ ...reqPayload }))
 
               yield* shutdownChannel.send(IntentionalShutdownCause.make({ reason: 'devtools-reset' })) ?? Effect.void
 
@@ -204,7 +240,7 @@ const listenToDevtools = ({
               return
             }
             case 'LSD.Leader.SyncHistorySubscribe': {
-              const { requestId } = decodedEvent
+              const { subscriptionId } = decodedEvent
 
               if (syncBackend !== undefined) {
                 // TODO consider piggybacking on the existing leader-thread sync-pulling
@@ -212,13 +248,20 @@ const listenToDevtools = ({
                   Stream.map((_) => _.batch),
                   Stream.flattenIterables,
                   Stream.tap(({ mutationEventEncoded, metadata }) =>
-                    sendMessage(Devtools.Leader.SyncHistoryRes.make({ mutationEventEncoded, metadata, ...reqPayload })),
+                    sendMessage(
+                      Devtools.Leader.SyncHistoryRes.make({
+                        mutationEventEncoded,
+                        metadata,
+                        subscriptionId,
+                        ...reqPayload,
+                        requestId: nanoid(10),
+                      }),
+                    ),
                   ),
                   Stream.runDrain,
-                  Effect.acquireRelease(() => Effect.log('syncHistorySubscribe done')),
                   Effect.interruptible,
                   Effect.tapCauseLogPretty,
-                  FiberMap.run(subscriptionFiberMap, requestId),
+                  FiberMap.run(subscriptionFiberMap, subscriptionId),
                 )
               }
 
@@ -244,7 +287,7 @@ const listenToDevtools = ({
             }
             case 'LSD.Leader.NetworkStatusSubscribe': {
               if (syncBackend !== undefined) {
-                const { requestId } = decodedEvent
+                const { subscriptionId } = decodedEvent
 
                 // TODO investigate and fix bug. seems that when sending messages right after
                 // the devtools have connected get sometimes lost
@@ -259,14 +302,16 @@ const listenToDevtools = ({
                     sendMessage(
                       Devtools.Leader.NetworkStatusRes.make({
                         networkStatus: { isConnected, timestampMs: Date.now(), latchClosed },
+                        subscriptionId,
                         ...reqPayload,
+                        requestId: nanoid(10),
                       }),
                     ),
                   ),
                   Stream.runDrain,
                   Effect.interruptible,
                   Effect.tapCauseLogPretty,
-                  FiberMap.run(subscriptionFiberMap, requestId),
+                  FiberMap.run(subscriptionFiberMap, subscriptionId),
                 )
               }
 
@@ -280,7 +325,7 @@ const listenToDevtools = ({
               return
             }
             case 'LSD.Leader.SyncHeadSubscribe': {
-              const { requestId } = decodedEvent
+              const { subscriptionId } = decodedEvent
 
               yield* syncProcessor.syncState.changes.pipe(
                 Stream.tap((syncState) =>
@@ -288,22 +333,24 @@ const listenToDevtools = ({
                     Devtools.Leader.SyncHeadRes.make({
                       local: syncState.localHead,
                       upstream: syncState.upstreamHead,
+                      subscriptionId,
                       ...reqPayload,
+                      requestId: nanoid(10),
                     }),
                   ),
                 ),
                 Stream.runDrain,
                 Effect.interruptible,
                 Effect.tapCauseLogPretty,
-                FiberMap.run(subscriptionFiberMap, requestId),
+                FiberMap.run(subscriptionFiberMap, subscriptionId),
               )
 
               return
             }
             case 'LSD.Leader.SyncHeadUnsubscribe': {
-              const { requestId } = decodedEvent
+              const { subscriptionId } = decodedEvent
 
-              yield* FiberMap.remove(subscriptionFiberMap, requestId)
+              yield* FiberMap.remove(subscriptionFiberMap, subscriptionId)
 
               return
             }
@@ -320,7 +367,7 @@ const listenToDevtools = ({
 
               yield* SubscriptionRef.set(devtools.syncBackendLatchState, { latchClosed: closeLatch })
 
-              yield* sendMessage(Devtools.Leader.SetSyncLatch.Response.make({ ...reqPayload }))
+              yield* sendMessage(Devtools.Leader.SetSyncLatch.Success.make({ ...reqPayload }))
 
               return
             }

package/src/leader-thread/make-leader-thread-layer.ts

@@ -3,7 +3,7 @@ import { Deferred, Effect, Layer, Queue, SubscriptionRef } from '@livestore/util
 
 import type { BootStatus, MakeSqliteDb, MigrationsReport, SqliteError } from '../adapter-types.js'
 import { UnexpectedError } from '../adapter-types.js'
-import type * as Devtools from '../devtools/index.js'
+import type * as Devtools from '../devtools/mod.js'
 import type { LiveStoreSchema } from '../schema/mod.js'
 import { EventId, MutationEvent, mutationLogMetaTable, SYNC_STATUS_TABLE, syncStatusTable } from '../schema/mod.js'
 import { migrateTable } from '../schema-management/migrations.js'

package/src/otel.ts

@@ -18,3 +18,11 @@ export const provideOtel =
       Effect.provide(TracingLive),
     )
   }
+
+export const getDurationMsFromSpan = (span: otel.Span): number => {
+  const durationHr: [seconds: number, nanos: number] = (span as any)._duration
+  return durationHr[0] * 1000 + durationHr[1] / 1_000_000
+}
+
+export const getStartTimeHighResFromSpan = (span: otel.Span): DOMHighResTimeStamp =>
+  (span as any)._performanceStartTime as DOMHighResTimeStamp

package/src/rehydrate-from-mutationlog.ts

@@ -1,4 +1,4 @@
-import { memoizeByRef, shouldNeverHappen } from '@livestore/utils'
+import { memoizeByRef } from '@livestore/utils'
 import { Chunk, Effect, Option, Schema, Stream } from '@livestore/utils/effect'
 
 import { type MigrationOptionsFromMutationLog, type SqliteDb, UnexpectedError } from './adapter-types.js'

package/src/schema/db-schema/dsl/field-defs.ts

@@ -53,7 +53,8 @@ export type ColDefFn<TColumnType extends FieldColumnType> = {
     const TNullable extends boolean = false,
     const TDefault extends TDecoded | SqlDefaultValue | NoDefault | (TNullable extends true ? null : never) = NoDefault,
     const TPrimaryKey extends boolean = false,
-  >(args: {    schema?: Schema.Schema<TDecoded, TEncoded>
+  >(args: {
+    schema?: Schema.Schema<TDecoded, TEncoded>
     default?: TDefault
     nullable?: TNullable
     primaryKey?: TPrimaryKey

package/src/schema/db-schema/dsl/mod.ts

@@ -30,7 +30,7 @@ export type DbSchemaFromInputSchema<TSchemaInput extends DbSchemaInput> =
 export const makeDbSchema = <TDbSchemaInput extends DbSchemaInput>(
   schema: TDbSchemaInput,
 ): DbSchemaFromInputSchema<TDbSchemaInput> => {
-  return Array.isArray(schema) ? Object.fromEntries(schema.map((_) => [_.name, _])) : schema as any
+  return Array.isArray(schema) ? Object.fromEntries(schema.map((_) => [_.name, _])) : (schema as any)
 }
 
 export const table = <TTableName extends string, TColumns extends Columns, TIndexes extends Index[]>(

package/src/sync/ClientSessionSyncProcessor.ts

@@ -27,6 +27,7 @@ export const makeClientSessionSyncProcessor = ({
   refreshTables,
   span,
   params,
+  confirmUnsavedChanges,
 }: {
   schema: LiveStoreSchema
   clientSession: ClientSession
@@ -44,6 +45,11 @@ export const makeClientSessionSyncProcessor = ({
   params: {
     leaderPushBatchSize: number
   }
+  /**
+   * Currently only used in the web adapter:
+   * If true, registers a beforeunload event listener to confirm unsaved changes.
+   */
+  confirmUnsavedChanges: boolean
 }): ClientSessionSyncProcessor => {
   const mutationEventSchema = MutationEvent.makeMutationEventSchemaMemo(schema)
 
@@ -132,7 +138,7 @@ export const makeClientSessionSyncProcessor = ({
 
   const boot: ClientSessionSyncProcessor['boot'] = Effect.gen(function* () {
     // eslint-disable-next-line unicorn/prefer-global-this
-    if (typeof window !== 'undefined' && typeof window.addEventListener === 'function') {
+    if (confirmUnsavedChanges && typeof window !== 'undefined' && typeof window.addEventListener === 'function') {
       const onBeforeUnload = (event: BeforeUnloadEvent) => {
         if (syncStateRef.current.pending.length > 0) {
           // Trigger the default browser dialog

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

package/dist/devtools/devtools-bridge.d.ts

@@ -1,16 +0,0 @@
-import type { Effect, WebChannel } from '@livestore/utils/effect';
-import type * as Devtools from './devtools-messages.js';
-export type PrepareDevtoolsBridge = {
-    webchannels: {
-        leader: WebChannel.WebChannel<Devtools.Leader.MessageFromApp, Devtools.Leader.MessageToApp>;
-        clientSession: WebChannel.WebChannel<Devtools.ClientSession.MessageFromApp, Devtools.ClientSession.MessageToApp>;
-    };
-    clientInfo: {
-        clientId: string;
-        sessionId: string;
-        isLeader: boolean;
-    };
-    copyToClipboard: (text: string) => Effect.Effect<void>;
-    sendEscapeKey?: Effect.Effect<void>;
-};
-//# sourceMappingURL=devtools-bridge.d.ts.map