@livestore/common 0.3.0-dev.2 → 0.3.0-dev.22

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,16 +8,10 @@ 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'
 export * from './query-builder/mod.js'
-export * from './sync/syncstate.js'
+export * as SyncState from './sync/syncstate.js'
 export * from './otel.js'
-
-declare global {
-  interface LiveStoreGlobal {
-    // syncBackend: never
-  }
-}

package/src/init-singleton-tables.ts

@@ -1,9 +1,9 @@
-import type { SynchronousDatabase } from './adapter-types.js'
+import type { SqliteDb } from './adapter-types.js'
 import type { LiveStoreSchema } from './schema/mod.js'
 import { getDefaultValuesEncoded } from './schema/schema-helpers.js'
 import { prepareBindValues, sql } from './util.js'
 
-export const initializeSingletonTables = (schema: LiveStoreSchema, db: SynchronousDatabase) => {
+export const initializeSingletonTables = (schema: LiveStoreSchema, db: SqliteDb) => {
   for (const [, tableDef] of schema.tables) {
     if (tableDef.options.isSingleton) {
       const defaultValues = getDefaultValuesEncoded(tableDef, undefined)