@livestore/common 0.3.0-dev.4 → 0.3.0-dev.41

package/src/devtools/devtools-sessioninfo.ts

@@ -0,0 +1,101 @@
+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,
+  schemaAlias: Schema.String,
+  isLeader: Schema.Boolean,
+})
+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,59 @@
+import type { Effect, Scope, WebChannel } from '@livestore/utils/effect'
+import { Schema } from '@livestore/utils/effect'
+import { nanoid } from '@livestore/utils/nanoid'
+import type { MeshNode } from '@livestore/webmesh'
+
+import * as SessionInfo from './devtools-sessioninfo.js'
+
+export * from './devtools-messages.js'
+export * as SessionInfo from './devtools-sessioninfo.js'
+
+export const DevtoolsMode = Schema.Union(
+  Schema.TaggedStruct('node', {
+    /** WebSocket URL */
+    url: Schema.String,
+  }),
+  Schema.TaggedStruct('web', {}),
+  Schema.TaggedStruct('browser-extension', {}),
+)
+
+export type DevtoolsMode = typeof DevtoolsMode.Type
+
+export const DevtoolsModeTag = DevtoolsMode.pipe(Schema.pluck('_tag'), Schema.typeSchema)
+export type DevtoolsModeTag = typeof DevtoolsModeTag.Type
+
+export const makeNodeName = {
+  devtools: {
+    random: () => `devtools-session-info-${nanoid()}`,
+  },
+  client: {
+    session: ({ storeId, clientId, sessionId }: { storeId: string; clientId: string; sessionId: string }) =>
+      `client-session-${storeId}-${clientId}-${sessionId}`,
+    leader: ({ storeId, clientId }: { storeId: string; clientId: string }) => `client-leader-${storeId}-${clientId}`,
+  },
+}
+
+export const makeChannelName = {
+  sessionInfo: () => `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 }) =>
+    `devtools-channel(client-leader-${storeId}-${clientId}-${sessionId})`,
+}
+
+export const isChannelName = {
+  devtoolsClientSession: (
+    channelName: string,
+    { storeId, clientId, sessionId }: { storeId: string; clientId: string; sessionId: string },
+  ) => channelName === makeChannelName.devtoolsClientSession({ storeId, clientId, sessionId }),
+  devtoolsClientLeader: (channelName: string, { storeId, clientId }: { storeId: string; clientId: string }) =>
+    channelName.startsWith(`devtools-channel(client-leader-${storeId}-${clientId}`),
+}
+
+export const makeSessionInfoBroadcastChannel = (
+  webmeshNode: MeshNode,
+): Effect.Effect<WebChannel.WebChannel<SessionInfo.Message, SessionInfo.Message>, never, Scope.Scope> =>
+  webmeshNode.makeBroadcastChannel({
+    channelName: makeChannelName.sessionInfo(),
+    schema: SessionInfo.Message,
+  })

package/src/index.ts

@@ -1,23 +1,15 @@
-export * from './schema/system-tables.js'
+export * from './schema/state/sqlite/system-tables.js'
 export * from './util.js'
 export * from './adapter-types.js'
 export * from './schema-management/migrations.js'
-export * from './mutation.js'
-export * from './init-singleton-tables.js'
-export * from './rehydrate-from-mutationlog.js'
-export * from './query-info.js'
-export * from './derived-mutations.js'
+export * from './materializer-helper.js'
+export * from './rematerialize-from-eventlog.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 * from './schema/state/sqlite/query-builder/mod.js'
+export * as SyncState from './sync/syncstate.js'
 export * from './otel.js'
-
-declare global {
-  interface LiveStoreGlobal {
-    // syncBackend: never
-  }
-}
+export * from './make-client-session.js'