@livestore/adapter-node 0.3.0-dev.18 → 0.3.0-dev.21

package/src/client-session/index.ts

@@ -3,6 +3,7 @@ import * as WT from 'node:worker_threads'
 
 import type {
   Adapter,
+  BootStatus,
   ClientSession,
   ClientSessionLeaderThreadProxy,
   IntentionalShutdownCause,
@@ -10,7 +11,7 @@ import type {
   NetworkStatus,
 } from '@livestore/common'
 import { Devtools, UnexpectedError } from '@livestore/common'
-import { makeNodeDevtoolsChannel } from '@livestore/devtools-node-common/web-channel'
+import * as DevtoolsNode from '@livestore/devtools-node-common/web-channel'
 import { loadSqlite3Wasm } from '@livestore/sqlite-wasm/load-wasm'
 import { sqliteDbFactory } from '@livestore/sqlite-wasm/node'
 import {
@@ -18,6 +19,7 @@ import {
   Effect,
   Fiber,
   ParseResult,
+  Queue,
   Schema,
   Stream,
   SubscriptionRef,
@@ -40,6 +42,8 @@ export interface NodeAdapterOptions {
   baseDirectory?: string
   /** The default is the hostname of the current machine */
   clientId?: string
+  /** @default 'static' */
+  sessionId?: string
   devtools?: {
     /**
      * Where to run the devtools server (via Vite)
@@ -47,20 +51,28 @@ export interface NodeAdapterOptions {
      * @default 4242
      */
     port: number
+    /**
+     * @default 'localhost'
+     */
+    host: string
   }
 }
 
+/**
+ * Warning: This adapter doesn't currently support multiple client sessions for the same client (i.e. same storeId + clientId)
+ */
 export const makeNodeAdapter = ({
   workerUrl,
   schemaPath,
   baseDirectory,
-  devtools: devtoolsOptions = { port: 4242 },
+  devtools: devtoolsOptions = { port: 4242, host: 'localhost' },
   clientId = hostname(),
+  // TODO make this dynamic and actually support multiple sessions
+  sessionId = 'static',
 }: NodeAdapterOptions): Adapter =>
-  (({ storeId, devtoolsEnabled, shutdown, connectDevtoolsToStore }) =>
+  (({ storeId, devtoolsEnabled, shutdown, connectDevtoolsToStore, bootStatusQueue }) =>
     Effect.gen(function* () {
-      // TODO make this dynamic and actually support multiple sessions
-      const sessionId = 'static'
+      yield* Queue.offer(bootStatusQueue, { stage: 'loading' })
 
       const sqlite3 = yield* Effect.promise(() => loadSqlite3Wasm())
       const makeSqliteDb = yield* sqliteDbFactory({ sqlite3 })
@@ -99,20 +111,34 @@ export const makeNodeAdapter = ({
         devtoolsEnabled,
         devtoolsOptions,
         schemaPath,
+        bootStatusQueue,
       })
 
       syncInMemoryDb.import(initialSnapshot)
 
       if (devtoolsEnabled) {
         yield* Effect.gen(function* () {
-          const storeDevtoolsChannel = yield* makeNodeDevtoolsChannel({
+          const webmeshNode = yield* DevtoolsNode.makeNodeDevtoolsConnectedMeshNode({
+            url: `ws://${devtoolsOptions.host}:${devtoolsOptions.port}`,
             nodeName: `client-session-${storeId}-${clientId}-${sessionId}`,
-            target: `devtools`,
-            url: `ws://localhost:${devtoolsOptions.port}`,
-            schema: {
-              listen: Devtools.ClientSession.MessageToApp,
-              send: Devtools.ClientSession.MessageFromApp,
-            },
+          })
+
+          const sessionsChannel = yield* webmeshNode.makeBroadcastChannel({
+            channelName: 'session-info',
+            schema: Devtools.SessionInfo.Message,
+          })
+
+          yield* Devtools.SessionInfo.provideSessionInfo({
+            webChannel: sessionsChannel,
+            sessionInfo: Devtools.SessionInfo.SessionInfo.make({ storeId, clientId, sessionId }),
+          }).pipe(Effect.tapCauseLogPretty, Effect.forkScoped)
+
+          webmeshNode.debug.print()
+
+          const storeDevtoolsChannel = yield* DevtoolsNode.makeChannelForConnectedMeshNode({
+            node: webmeshNode,
+            target: `devtools-${storeId}-${clientId}-${sessionId}`,
+            schema: { listen: Devtools.ClientSession.MessageToApp, send: Devtools.ClientSession.MessageFromApp },
           })
 
           yield* connectDevtoolsToStore(storeDevtoolsChannel)
@@ -150,6 +176,7 @@ const makeLeaderThread = ({
   devtoolsEnabled,
   devtoolsOptions,
   schemaPath,
+  // bootStatusQueue,
 }: {
   shutdown: (cause: Cause.Cause<UnexpectedError | IntentionalShutdownCause>) => void
   storeId: string
@@ -158,8 +185,9 @@ const makeLeaderThread = ({
   workerUrl: URL
   baseDirectory: string | undefined
   devtoolsEnabled: boolean
-  devtoolsOptions: { port: number }
+  devtoolsOptions: { port: number; host: string }
   schemaPath: string
+  bootStatusQueue: Queue.Queue<BootStatus>
 }) =>
   Effect.gen(function* () {
     const nodeWorker = new WT.Worker(workerUrl, {
@@ -175,7 +203,7 @@ const makeLeaderThread = ({
           storeId,
           clientId,
           baseDirectory,
-          devtools: { enabled: devtoolsEnabled, port: devtoolsOptions.port },
+          devtools: { enabled: devtoolsEnabled, port: devtoolsOptions.port, host: devtoolsOptions.host },
           schemaPath,
         }),
     }).pipe(
@@ -242,6 +270,39 @@ const makeLeaderThread = ({
         )
       }).pipe(Stream.unwrap) as any
 
+    const _bootStatusFiber = yield* runInWorkerStream(new WorkerSchema.LeaderWorkerInner.BootStatusStream()).pipe(
+      // TODO bring back when fixed https://github.com/Effect-TS/effect/issues/4576
+      // Stream.tap((bootStatus) => Queue.offer(bootStatusQueue, bootStatus)),
+      // TODO remove when fixed https://github.com/Effect-TS/effect/issues/4576
+      // Stream.tap(
+      //   Effect.fn(function* (_) {
+      //     if (yield* Queue.isShutdown(bootStatusQueue)) {
+      //       return
+      //     } else {
+      //       console.log('offering boot status', _)
+      //       // yield* Queue.offer(bootStatusQueue, _).pipe(
+      //       //   Effect.onInterrupt(() => Effect.log('boot status stream interrupted')),
+      //       //   // Effect.tapErrorCause((cause) => Effect.logError('error offering boot status', cause)),
+      //       // )
+      //     }
+      //   }),
+      // ),
+      Stream.runDrain,
+      Effect.tapErrorCause((cause) =>
+        Cause.isInterruptedOnly(cause) ? Effect.void : Effect.sync(() => shutdown(cause)),
+      ),
+      Effect.interruptible,
+      Effect.tapCauseLogPretty,
+      Effect.forkScoped,
+    )
+
+    // TODO bring back when fixed https://github.com/Effect-TS/effect/issues/4576
+    // yield* Queue.awaitShutdown(bootStatusQueue).pipe(
+    //   Effect.andThen(Fiber.interrupt(bootStatusFiber)),
+    //   Effect.tapCauseLogPretty,
+    //   Effect.forkScoped,
+    // )
+
     const initialLeaderHead = yield* runInWorker(new WorkerSchema.LeaderWorkerInner.GetLeaderHead())
 
     const networkStatus = yield* SubscriptionRef.make<NetworkStatus>({

package/src/devtools/devtools-server.ts

@@ -20,11 +20,13 @@ export const startDevtoolsServer = ({
   clientId,
   sessionId,
   port,
+  host,
 }: {
   schemaPath: string
   storeId: string
   clientId: string
   sessionId: string
+  host: string
   port: number
 }): Effect.Effect<void, UnexpectedError, Scope.Scope> =>
   Effect.gen(function* () {
@@ -59,7 +61,7 @@ export const startDevtoolsServer = ({
           cb(UnexpectedError.make({ cause: err }))
         })
 
-        httpServer.listen(port, '0.0.0.0', () => {
+        httpServer.listen(port, host, () => {
           cb(Effect.succeed(undefined))
         })
       })
@@ -67,11 +69,12 @@ export const startDevtoolsServer = ({
     yield* startServer(port)
 
     yield* Effect.logDebug(
-      `[@livestore/adapter-node:devtools] LiveStore devtools are available at http://localhost:${port}/_livestore`,
+      `[@livestore/adapter-node:devtools] LiveStore devtools are available at http://${host}:${port}/_livestore/node/${storeId}/${clientId}/${sessionId}`,
     )
 
+    const clientSessionInfo = { storeId, clientId, sessionId }
     const viteServer = yield* makeViteServer({
-      mode: { _tag: 'node', storeId, clientId, sessionId, url: `ws://localhost:${port}` },
+      mode: { _tag: 'node', clientSessionInfo, url: `ws://localhost:${port}` },
       schemaPath: path.resolve(process.cwd(), schemaPath),
       viteConfig: (viteConfig) => {
         if (LS_DEV) {
@@ -91,7 +94,7 @@ export const startDevtoolsServer = ({
 
     httpServer.on('request', (req, res) => {
       if (req.url === '/' || req.url === '') {
-        res.writeHead(302, { Location: '/_livestore' })
+        res.writeHead(302, { Location: '/_livestore/node' })
         res.end()
       } else if (req.url?.startsWith('/_livestore')) {
         return viteServer.middlewares(req, res as any)

package/src/in-memory/index.ts

@@ -25,11 +25,15 @@ export interface InMemoryAdapterOptions {
    * @default 'in-memory'
    */
   clientId?: string
+  /**
+   * @default nanoid(6)
+   */
+  sessionId?: string
 }
 
 /** NOTE: This adapter is currently only used for testing */
 export const makeInMemoryAdapter =
-  ({ sync: syncOptions, clientId = 'in-memory' }: InMemoryAdapterOptions): Adapter =>
+  ({ sync: syncOptions, clientId = 'in-memory', sessionId = nanoid(6) }: InMemoryAdapterOptions): Adapter =>
   ({
     schema,
     storeId,
@@ -42,9 +46,7 @@ export const makeInMemoryAdapter =
       const makeSqliteDb = sqliteDbFactory({ sqlite3 })
       const sqliteDb = yield* makeSqliteDb({ _tag: 'in-memory' })
 
-      const lockStatus = SubscriptionRef.make<LockStatus>('has-lock').pipe(Effect.runSync)
-
-      const sessionId = nanoid(6)
+      const lockStatus = yield* SubscriptionRef.make<LockStatus>('has-lock')
 
       const shutdownChannel = yield* makeShutdownChannel(storeId)
 

package/src/make-leader-worker.ts

@@ -207,6 +207,7 @@ const makeLeaderThread = ({
     const devtoolsOptions = yield* makeDevtoolsOptions({
       devtoolsEnabled: devtools.enabled,
       devtoolsPort: devtools.port,
+      devtoolsHost: devtools.host,
       dbReadModel,
       dbMutationLog,
       storeId,
@@ -243,6 +244,7 @@ const makeDevtoolsOptions = ({
   storeId,
   clientId,
   devtoolsPort,
+  devtoolsHost,
   schemaPath,
 }: {
   devtoolsEnabled: boolean
@@ -251,6 +253,7 @@ const makeDevtoolsOptions = ({
   storeId: string
   clientId: string
   devtoolsPort: number
+  devtoolsHost: string
   schemaPath: string
 }): Effect.Effect<DevtoolsOptions, UnexpectedError, Scope.Scope> =>
   Effect.gen(function* () {
@@ -270,18 +273,18 @@ const makeDevtoolsOptions = ({
           clientId,
           sessionId: 'static', // TODO make this dynamic
           port: devtoolsPort,
+          host: devtoolsHost,
+        })
+
+        const devtoolsWebChannel = yield* makeNodeDevtoolsChannel({
+          nodeName: `leader-${storeId}-${clientId}`,
+          target: `devtools-${storeId}-${clientId}-static`,
+          url: `ws://localhost:${devtoolsPort}`,
+          schema: { listen: Devtools.Leader.MessageToApp, send: Devtools.Leader.MessageFromApp },
         })
 
         return {
-          devtoolsWebChannel: yield* makeNodeDevtoolsChannel({
-            nodeName: `leader-${storeId}-${clientId}`,
-            target: `devtools`,
-            url: `ws://localhost:${devtoolsPort}`,
-            schema: {
-              listen: Devtools.Leader.MessageToApp,
-              send: Devtools.Leader.MessageFromApp,
-            },
-          }),
+          devtoolsWebChannel,
           persistenceInfo: {
             readModel: dbReadModel.metadata.persistenceInfo,
             mutationLog: dbMutationLog.metadata.persistenceInfo,

package/src/worker-schema.ts

@@ -67,6 +67,7 @@ export namespace LeaderWorkerInner {
       schemaPath: Schema.String,
       devtools: Schema.Struct({
         port: Schema.Number,
+        host: Schema.String,
         enabled: Schema.Boolean,
       }),
     },

package/tmp/test-effect.ts

@@ -0,0 +1,30 @@
+import { Effect, Queue, Stream } from '@livestore/utils/effect'
+import { PlatformNode } from '@livestore/utils/node'
+
+const main = Effect.gen(function* () {
+  const queue = yield* Queue.unbounded<number>()
+
+  yield* Queue.shutdown(queue)
+
+  // yield* Effect.gen(function* () {
+  //   yield* Queue.offer(queue, 1)
+  //   yield* Queue.shutdown(queue)
+  // }).pipe(Effect.delay(200), Effect.forkScoped)
+
+  yield* Effect.addFinalizer((exit) => Effect.log('finalizer', exit))
+
+  // const exit = yield* Stream.fromQueue(queue).pipe(
+  //   Stream.tap((n) => Effect.log(n)),
+  //   Stream.runDrain,
+  //   Effect.exit,
+  // )
+
+  const exit = yield* Effect.andThen(Effect.void, () => Stream.fromQueue(queue)).pipe(
+    Stream.unwrap,
+    Stream.tap((n) => Effect.log(n)),
+    Stream.runDrain,
+    Effect.exit,
+  )
+
+  console.log('exit', exit)
+}).pipe(Effect.scoped, PlatformNode.NodeRuntime.runMain)