@livestore/adapter-node 0.4.0-dev.9 → 0.5.0-dev.0

package/src/devtools/devtools-server.ts

@@ -2,7 +2,7 @@ import http from 'node:http'
 import path from 'node:path'
 
 import type { Devtools } from '@livestore/common'
-import { isReadonlyArray, LS_DEV } from '@livestore/utils'
+import { LS_DEV } from '@livestore/utils'
 import type { HttpClient } from '@livestore/utils/effect'
 import {
   Deferred,
@@ -20,6 +20,16 @@ import { makeMeshNode, makeWebSocketEdge } from '@livestore/webmesh'
 
 import { makeViteMiddleware } from './vite-dev-server.ts'
 
+/**
+ * Determines if a request URL should be routed to the Vite middleware.
+ * Includes LiveStore devtools paths and Vite internal paths like `/@fs/`, `/@vite/`, etc.
+ */
+const shouldRouteToVite = (url: string): boolean =>
+  url.startsWith('/_livestore') ||
+  url.startsWith('/@fs') ||
+  url.startsWith('/@vite') ||
+  url.startsWith('/@react-refresh')
+
 /**
  * Starts a devtools HTTP/WS server which serves ...
  * - the Devtools UI via Vite
@@ -37,24 +47,28 @@ export const startDevtoolsServer = ({
   port: number
 }): Effect.Effect<never, never, HttpClient.HttpClient> =>
   Effect.gen(function* () {
-    const viteMiddleware = yield* makeViteMiddleware({
-      mode: { _tag: 'node', url: `http://${host}:${port}` },
-      schemaPath: isReadonlyArray(schemaPath)
-        ? schemaPath.map((schemaPath) => path.resolve(process.cwd(), schemaPath))
-        : path.resolve(process.cwd(), schemaPath),
-      viteConfig: (viteConfig) => {
-        if (LS_DEV) {
-          viteConfig.server ??= {}
-          viteConfig.server.fs ??= {}
-          viteConfig.server.fs.strict = false
-
-          viteConfig.optimizeDeps ??= {}
-          viteConfig.optimizeDeps.force = true
-        }
-
-        return viteConfig
-      },
-    }).pipe(Effect.acquireRelease((viteMiddleware) => Effect.promise(() => viteMiddleware.close())))
+    const viteMiddleware = yield* Effect.acquireRelease(
+      makeViteMiddleware({
+        mode: { _tag: 'node', url: `http://${host}:${port}` },
+        schemaPath:
+          typeof schemaPath === 'string'
+            ? path.resolve(process.cwd(), schemaPath)
+            : schemaPath.map((schemaPath) => path.resolve(process.cwd(), schemaPath)),
+        viteConfig: (viteConfig) => {
+          if (LS_DEV === true) {
+            viteConfig.server ??= {}
+            viteConfig.server.fs ??= {}
+            viteConfig.server.fs.strict = false
+
+            viteConfig.optimizeDeps ??= {}
+            viteConfig.optimizeDeps.force = true
+          }
+
+          return viteConfig
+        },
+      }),
+      (viteMiddleware) => Effect.promise(() => viteMiddleware.close()),
+    )
 
     const relayNodeName = 'ws'
 
@@ -63,7 +77,7 @@ export const startDevtoolsServer = ({
     const handler = Effect.gen(function* () {
       const req = yield* HttpServerRequest.HttpServerRequest
 
-      if (Headers.has(req.headers, 'upgrade')) {
+      if (Headers.has(req.headers, 'upgrade') === true) {
         // yield* Effect.logDebug(`WS Relay ${relayNodeName}: WS upgrade request ${req.url}`)
 
         const socket = yield* req.upgrade
@@ -77,11 +91,12 @@ export const startDevtoolsServer = ({
         // To handle websocket closing, we need to race the `webChannel.closedDeferred` to properly interrupt the handler
         yield* Effect.raceFirst(
           Effect.gen(function* () {
-            yield* node
-              .addEdge({ target: from, edgeChannel: webChannel, replaceIfExists: true })
-              .pipe(Effect.acquireRelease(() => node.removeEdge(from).pipe(Effect.orDie)))
+            yield* Effect.acquireRelease(
+              node.addEdge({ target: from, edgeChannel: webChannel, replaceIfExists: true }),
+              () => node.removeEdge(from).pipe(Effect.orDie),
+            )
 
-            if (LS_DEV) {
+            if (LS_DEV === true) {
               yield* Effect.log(`WS Relay ${relayNodeName}: added edge from '${from}'`)
               yield* Effect.addFinalizerLog(`WS Relay ${relayNodeName}: removed edge from '${from}'`)
             }
@@ -89,22 +104,22 @@ export const startDevtoolsServer = ({
             // We want to keep the websocket open until the client disconnects or the server shuts down
             return yield* Effect.never
           }),
-          webChannel.closedDeferred,
+          Deferred.await(webChannel.closedDeferred),
         )
 
         return HttpServerResponse.empty({ status: 101 })
       } else {
         if (req.url === '/' || req.url === '') {
           return HttpServerResponse.redirect('/_livestore/node')
-        } else if (req.url.startsWith('/_livestore')) {
+        } else if (shouldRouteToVite(req.url) === true) {
           // Here we're delegating to the Vite middleware
 
           // TODO replace this once @effect/platform-node supports Node HTTP middlewares
           const nodeReq = PlatformNode.NodeHttpServerRequest.toIncomingMessage(req)
           const nodeRes = PlatformNode.NodeHttpServerRequest.toServerResponse(req)
-          const deferred = yield* Deferred.make()
-          viteMiddleware.middlewares(nodeReq, nodeRes, () => Deferred.unsafeDone(deferred, Exit.void))
-          yield* deferred
+          const deferred = yield* Deferred.make<void>()
+          viteMiddleware.middlewares(nodeReq, nodeRes, () => Deferred.doneUnsafe(deferred, Exit.void))
+          yield* Deferred.await(deferred)
 
           // The response is already sent, so we need to return an empty response (which won't be sent)
           return HttpServerResponse.empty()
@@ -112,11 +127,12 @@ export const startDevtoolsServer = ({
       }
 
       return HttpServerResponse.text('Not found')
-    }).pipe(Effect.tapCauseLogPretty, Effect.interruptible)
+    }).pipe(Effect.tapCauseLogPretty, Effect.interruptible, HttpMiddleware.withLoggerDisabled)
 
-    const sessionSuffix = clientSessionInfo
-      ? `/${clientSessionInfo.storeId}/${clientSessionInfo.clientId}/${clientSessionInfo.sessionId}/${clientSessionInfo.schemaAlias}`
-      : '?autoconnect'
+    const sessionSuffix =
+      clientSessionInfo !== undefined
+        ? `/${clientSessionInfo.storeId}/${clientSessionInfo.clientId}/${clientSessionInfo.sessionId}/${clientSessionInfo.schemaAlias}`
+        : '?autoconnect'
 
     // Use `localhost` instead of `0.0.0.0` as it doesn't have the `navigator.locks` web adapter limitation (https://share.cleanshot.com/nHBnmk6S)
     const maybeLocalhost = host === '0.0.0.0' ? 'localhost' : host
@@ -129,8 +145,7 @@ export const startDevtoolsServer = ({
     Effect.withSpan('@livestore/adapter-node:startDevtoolsServer', {
       attributes: { clientSessionInfo, port, host, schemaPath },
     }),
-    HttpMiddleware.withLoggerDisabled,
-    Layer.unwrapScoped,
+    Layer.unwrap,
     Layer.provide(PlatformNode.NodeHttpServer.layer(() => http.createServer(), { port, host })),
     Layer.launch,
     Effect.orDie,

package/src/devtools/mod.ts

@@ -1,3 +1,3 @@
 export { startDevtoolsServer } from './devtools-server.ts'
 export type { ViteDevtoolsOptions } from './vite-dev-server.ts'
-export { makeViteMiddleware } from './vite-dev-server.ts'
+export { DevtoolsViteNotInstalledError, makeViteMiddleware } from './vite-dev-server.ts'

package/src/devtools/vite-dev-server.ts

@@ -1,12 +1,41 @@
 import path from 'node:path'
-
 import type { Devtools } from '@livestore/common'
-import { UnexpectedError } from '@livestore/common'
-import { livestoreDevtoolsPlugin } from '@livestore/devtools-vite'
-import { isReadonlyArray } from '@livestore/utils'
-import { Effect } from '@livestore/utils/effect'
+import { UnknownError } from '@livestore/common'
+import { Effect, Schema } from '@livestore/utils/effect'
 import { getFreePort } from '@livestore/utils/node'
-import * as Vite from 'vite'
+import type * as Vite from 'vite'
+
+/**
+ * Error thrown when @livestore/devtools-vite is not installed.
+ * This is a peer dependency that must be installed separately.
+ */
+export class DevtoolsViteNotInstalledError extends Schema.TaggedError<DevtoolsViteNotInstalledError>(
+  '~@livestore/adapter-node/DevtoolsViteNotInstalledError',
+)('DevtoolsViteNotInstalledError', {
+  cause: Schema.Defect(),
+}) {
+  override get message(): string {
+    return (
+      `@livestore/devtools-vite is required for devtools but not installed. ` +
+      `Install it with: pnpm add @livestore/devtools-vite@<version>. ` +
+      `Make sure to use the same version as @livestore/adapter-node.`
+    )
+  }
+}
+
+/** Error thrown when vite is not installed for the devtools server path. */
+export class ViteNotInstalledError extends Schema.TaggedError<ViteNotInstalledError>(
+  '~@livestore/adapter-node/ViteNotInstalledError',
+)('ViteNotInstalledError', {
+  cause: Schema.Defect(),
+}) {
+  override get message(): string {
+    return (
+      `vite is required for @livestore/adapter-node/devtools but not installed. ` +
+      `Install it with: pnpm add -D vite@<version>.`
+    )
+  }
+}
 
 export type ViteDevtoolsOptions = {
   viteConfig?: (config: Vite.UserConfig) => Vite.UserConfig
@@ -26,11 +55,16 @@ export type ViteDevtoolsOptions = {
 }
 
 // NOTE this is currently also used in @livestore/devtools-expo
-export const makeViteMiddleware = (options: ViteDevtoolsOptions): Effect.Effect<Vite.ViteDevServer, UnexpectedError> =>
+export const makeViteMiddleware = (
+  options: ViteDevtoolsOptions,
+): Effect.Effect<Vite.ViteDevServer, DevtoolsViteNotInstalledError | ViteNotInstalledError | UnknownError> =>
   Effect.gen(function* () {
+    const { livestoreDevtoolsPlugin } = yield* importDevtoolsVite()
+    const Vite = yield* importVite()
+
     const cwd = process.cwd()
 
-    const hmrPort = yield* getFreePort.pipe(UnexpectedError.mapToUnexpectedError)
+    const hmrPort = yield* getFreePort.pipe(UnknownError.mapToUnknownError)
 
     const defaultViteConfig = Vite.defineConfig({
       server: {
@@ -39,15 +73,16 @@ export const makeViteMiddleware = (options: ViteDevtoolsOptions): Effect.Effect<
           port: hmrPort,
         },
         // Relaxing fs access for monorepo setup
-        fs: { strict: process.env.LS_DEV ? false : true },
+        fs: { strict: process.env.LS_DEV !== undefined ? false : true },
       },
       appType: 'spa',
       base: '/_livestore/',
       plugins: [
         livestoreDevtoolsPlugin({
-          schemaPath: isReadonlyArray(options.schemaPath)
-            ? options.schemaPath.map((schemaPath) => path.resolve(cwd, schemaPath))
-            : path.resolve(cwd, options.schemaPath),
+          schemaPath:
+            typeof options.schemaPath === 'string'
+              ? path.resolve(cwd, options.schemaPath)
+              : options.schemaPath.map((schemaPath) => path.resolve(cwd, schemaPath)),
           mode: options.mode,
           path: '/',
         }),
@@ -58,9 +93,24 @@ export const makeViteMiddleware = (options: ViteDevtoolsOptions): Effect.Effect<
 
     const viteConfig = options.viteConfig?.(defaultViteConfig) ?? defaultViteConfig
 
-    const viteServer = yield* Effect.promise(() => Vite.createServer(viteConfig)).pipe(
-      UnexpectedError.mapToUnexpectedError,
-    )
+    const viteServer = yield* Effect.promise(() => Vite.createServer(viteConfig)).pipe(UnknownError.mapToUnknownError)
 
     return viteServer
   }).pipe(Effect.withSpan('@livestore/adapter-node:devtools:makeViteServer'))
+
+/**
+ * Dynamically imports @livestore/devtools-vite.
+ * This package is a peer dependency and may not be installed.
+ */
+const importDevtoolsVite = () =>
+  Effect.tryPromise({
+    try: () => import('@livestore/devtools-vite'),
+    catch: (cause) => new DevtoolsViteNotInstalledError({ cause }),
+  })
+
+/** Dynamically imports vite for the devtools-only server path. */
+const importVite = () =>
+  Effect.tryPromise({
+    try: () => import('vite'),
+    catch: (cause) => new ViteNotInstalledError({ cause }),
+  })

package/src/leader-thread-shared.ts

@@ -1,19 +1,20 @@
 import inspector from 'node:inspector'
 import path from 'node:path'
 
-if (process.execArgv.includes('--inspect')) {
+if (process.execArgv.includes('--inspect') === true) {
   inspector.open()
   inspector.waitForDebugger()
 }
 
 import type { ClientSessionLeaderThreadProxy, MakeSqliteDb, SqliteDb, SyncOptions } from '@livestore/common'
-import { Devtools, liveStoreStorageFormatVersion, migrateDb, UnexpectedError } from '@livestore/common'
+import { Devtools, liveStoreStorageFormatVersion, migrateDb, StateHead, UnknownError } from '@livestore/common'
 import type { DevtoolsOptions, LeaderSqliteDb, LeaderThreadCtx } from '@livestore/common/leader-thread'
 import { configureConnection, makeLeaderThreadLayer } from '@livestore/common/leader-thread'
 import type { LiveStoreSchema } from '@livestore/common/schema'
+import { getStateDbBaseName } from '@livestore/common/schema'
 import type { MakeNodeSqliteDb } from '@livestore/sqlite-wasm/node'
-import type { FileSystem, HttpClient, Layer, Schema, Scope } from '@livestore/utils/effect'
-import { Effect } from '@livestore/utils/effect'
+import type { FileSystem, HttpClient, Schema, Scope } from '@livestore/utils/effect'
+import { Effect, Layer } from '@livestore/utils/effect'
 import * as Webmesh from '@livestore/webmesh'
 
 import { makeShutdownChannel } from './shutdown-channel.ts'
@@ -30,7 +31,7 @@ export type TestingOverrides = {
       dbEventlog: SqliteDb
       dbState: SqliteDb
     },
-    UnexpectedError
+    UnknownError
   >
 }
 
@@ -40,9 +41,10 @@ export interface MakeLeaderThreadArgs {
   syncOptions: SyncOptions | undefined
   storage: WorkerSchema.StorageType
   makeSqliteDb: MakeNodeSqliteDb
-  devtools: WorkerSchema.LeaderWorkerInnerInitialMessage['devtools']
+  devtools: WorkerSchema.LeaderWorkerInnerInitialMessagePayload['devtools']
   schema: LiveStoreSchema
-  syncPayload: Schema.JsonValue | undefined
+  syncPayloadEncoded: Schema.Json | undefined
+  syncPayloadSchema: Schema.Schema<any> | undefined
   testing: TestingOverrides | undefined
 }
 
@@ -54,21 +56,19 @@ export const makeLeaderThread = ({
   storage,
   devtools,
   schema,
-  syncPayload,
+  syncPayloadEncoded,
+  syncPayloadSchema,
   testing,
 }: MakeLeaderThreadArgs): Effect.Effect<
-  Layer.Layer<LeaderThreadCtx, UnexpectedError, Scope.Scope | HttpClient.HttpClient | FileSystem.FileSystem>,
-  UnexpectedError,
+  Layer.Layer<LeaderThreadCtx, UnknownError, Scope.Scope | HttpClient.HttpClient | FileSystem.FileSystem>,
+  UnknownError,
   Scope.Scope
 > =>
   Effect.gen(function* () {
-    const runtime = yield* Effect.runtime<never>()
-
-    const schemaHashSuffix =
-      schema.state.sqlite.migrations.strategy === 'manual' ? 'fixed' : schema.state.sqlite.hash.toString()
+    const services = yield* Effect.context()
 
     const makeDb = (kind: 'state' | 'eventlog') => {
-      if (testing?.makeLeaderThread) {
+      if (testing?.makeLeaderThread !== undefined) {
         return testing
           .makeLeaderThread(makeSqliteDb)
           .pipe(Effect.map(({ dbEventlog, dbState }) => (kind === 'state' ? dbState : dbEventlog)))
@@ -77,18 +77,21 @@ export const makeLeaderThread = ({
       return storage.type === 'in-memory'
         ? makeSqliteDb({
             _tag: 'in-memory',
-            configureDb: (db) =>
-              configureConnection(db, { foreignKeys: true }).pipe(Effect.provide(runtime), Effect.runSync),
+            configureDb: (db) => configureConnection(db, { foreignKeys: true }).pipe(Effect.runSyncWith(services)),
           })
-        : makeSqliteDb({
-            _tag: 'fs',
-            directory: path.join(storage.baseDirectory ?? '', storeId),
-            fileName:
-              kind === 'state' ? getStateDbFileName(schemaHashSuffix) : `eventlog@${liveStoreStorageFormatVersion}.db`,
-            // TODO enable WAL for nodejs
-            configureDb: (db) =>
-              configureConnection(db, { foreignKeys: true }).pipe(Effect.provide(runtime), Effect.runSync),
-          }).pipe(Effect.acquireRelease((db) => Effect.sync(() => db.close())))
+        : Effect.acquireRelease(
+            makeSqliteDb({
+              _tag: 'fs',
+              directory: path.join(storage.baseDirectory ?? '', storeId),
+              fileName:
+                kind === 'state'
+                  ? `${getStateDbBaseName(schema)}@${liveStoreStorageFormatVersion}.db`
+                  : `eventlog@${liveStoreStorageFormatVersion}.db`,
+              // TODO enable WAL for nodejs
+              configureDb: (db) => configureConnection(db, { foreignKeys: true }).pipe(Effect.runSyncWith(services)),
+            }),
+            (db) => Effect.sync(() => db.close()),
+          )
     }
 
     // Might involve some async work, so we're running them concurrently
@@ -113,18 +116,17 @@ export const makeLeaderThread = ({
       dbEventlog,
       devtoolsOptions,
       shutdownChannel,
-      syncPayload,
-    })
+      syncPayloadEncoded,
+      syncPayloadSchema: syncPayloadSchema as Schema.Decoder<Schema.Json, never> | undefined,
+    }).pipe(Layer.provide(StateHead.layer({ dbState })))
   }).pipe(
     Effect.tapCauseLogPretty,
-    UnexpectedError.mapToUnexpectedError,
+    UnknownError.mapToUnknownError,
     Effect.withSpan('@livestore/adapter-node:makeLeaderThread', {
       attributes: { storeId, clientId, storage, devtools, syncOptions },
     }),
   )
 
-const getStateDbFileName = (suffix: string) => `state${suffix}@${liveStoreStorageFormatVersion}.db`
-
 const makeDevtoolsOptions = ({
   dbState,
   dbEventlog,
@@ -136,8 +138,8 @@ const makeDevtoolsOptions = ({
   dbEventlog: LeaderSqliteDb
   storeId: string
   clientId: string
-  devtools: WorkerSchema.LeaderWorkerInnerInitialMessage['devtools']
-}): Effect.Effect<DevtoolsOptions, UnexpectedError, Scope.Scope> =>
+  devtools: WorkerSchema.LeaderWorkerInnerInitialMessagePayload['devtools']
+}): Effect.Effect<DevtoolsOptions, UnknownError, Scope.Scope> =>
   Effect.gen(function* () {
     if (devtools.enabled === false) {
       return {
@@ -161,6 +163,7 @@ const makeDevtoolsOptions = ({
               sessionId: 'static', // TODO make this dynamic
               schemaAlias: devtools.schemaAlias,
               isLeader: true,
+              origin: undefined,
             }),
             port: devtools.port,
             host: devtools.host,
@@ -180,7 +183,7 @@ const makeDevtoolsOptions = ({
           eventlog: dbEventlog.metadata.persistenceInfo,
         }
 
-        return { node, persistenceInfo, mode: 'proxy' }
+        return { node, persistenceInfo, mode: 'proxy' as const }
       }),
     }
   })