@livestore/adapter-node 0.0.0-snapshot-f5ece014485b5ab43795c218f7ba7cfa32c81707 → 0.0.0-snapshot-057a9e3a18ca69a310d4eb8cf35a34e94fa1841e

package/src/client-session/adapter.ts

@@ -1,16 +1,16 @@
 import { hostname } from 'node:os'
 import * as WT from 'node:worker_threads'
-
-import type {
-  Adapter,
-  BootStatus,
+import {
+  type Adapter,
+  type BootStatus,
   ClientSessionLeaderThreadProxy,
-  IntentionalShutdownCause,
-  LockStatus,
-  MakeSqliteDb,
-  SyncOptions,
+  type IntentionalShutdownCause,
+  type LockStatus,
+  type MakeSqliteDb,
+  makeClientSession,
+  type SyncOptions,
+  UnexpectedError,
 } from '@livestore/common'
-import { makeClientSession, UnexpectedError } from '@livestore/common'
 import { Eventlog, LeaderThreadCtx } from '@livestore/common/leader-thread'
 import type { LiveStoreSchema } from '@livestore/common/schema'
 import { LiveStoreEvent } from '@livestore/common/schema'
@@ -188,6 +188,7 @@ const makeAdapterImpl = ({
             })
 
       syncInMemoryDb.import(initialSnapshot)
+      syncInMemoryDb.debug.head = leaderThread.initialState.leaderHead
 
       const clientSession = yield* makeClientSession({
         ...adapterArgs,
@@ -214,7 +215,6 @@ const makeAdapterImpl = ({
       return clientSession
     }).pipe(
       Effect.withSpan('@livestore/adapter-node:adapter'),
-      Effect.parallelFinalizers,
       Effect.provide(PlatformNode.NodeFileSystem.layer),
       Effect.provide(FetchHttpClient.layer),
     )) satisfies Adapter
@@ -262,23 +262,24 @@ const makeLocalLeaderThread = ({
 
       const initialLeaderHead = Eventlog.getClientHeadFromDb(dbEventlog)
 
-      const leaderThread = {
-        events: {
-          pull:
-            testing?.overrides?.clientSession?.leaderThreadProxy?.events?.pull ??
-            (({ cursor }) => syncProcessor.pull({ cursor })),
-          push: (batch) =>
-            syncProcessor.push(
-              batch.map((item) => new LiveStoreEvent.EncodedWithMeta(item)),
-              { waitForProcessing: true },
-            ),
+      const leaderThread = ClientSessionLeaderThreadProxy.of(
+        {
+          events: {
+            pull: ({ cursor }) => syncProcessor.pull({ cursor }),
+            push: (batch) =>
+              syncProcessor.push(
+                batch.map((item) => new LiveStoreEvent.EncodedWithMeta(item)),
+                { waitForProcessing: true },
+              ),
+          },
+          initialState: { leaderHead: initialLeaderHead, migrationsReport: initialState.migrationsReport },
+          export: Effect.sync(() => dbState.export()),
+          getEventlogData: Effect.sync(() => dbEventlog.export()),
+          getSyncState: syncProcessor.syncState,
+          sendDevtoolsMessage: (message) => extraIncomingMessagesQueue.offer(message),
         },
-        initialState: { leaderHead: initialLeaderHead, migrationsReport: initialState.migrationsReport },
-        export: Effect.sync(() => dbState.export()),
-        getEventlogData: Effect.sync(() => dbEventlog.export()),
-        getSyncState: syncProcessor.syncState,
-        sendDevtoolsMessage: (message) => extraIncomingMessagesQueue.offer(message),
-      } satisfies ClientSessionLeaderThreadProxy
+        { overrides: testing?.overrides?.clientSession?.leaderThreadProxy },
+      )
 
       const initialSnapshot = dbState.export()
 
@@ -336,20 +337,6 @@ const makeWorkerLeaderThread = ({
       Effect.withSpan('@livestore/adapter-node:adapter:setupLeaderThread'),
     )
 
-    yield* Effect.addFinalizer(() =>
-      Effect.gen(function* () {
-        // We first try to gracefully shutdown the leader worker and then forcefully terminate it
-        yield* Effect.raceFirst(
-          runInWorker(new WorkerSchema.LeaderWorkerInner.Shutdown()).pipe(Effect.andThen(() => nodeWorker.terminate())),
-
-          Effect.sync(() => {
-            console.warn('[@livestore/adapter-node:adapter] Worker did not gracefully shutdown in time, terminating it')
-            nodeWorker.terminate()
-          }).pipe(Effect.delay(1000)),
-        ).pipe(Effect.exit) // The disconnect is to prevent the interrupt to bubble out
-      }).pipe(Effect.withSpan('@livestore/adapter-node:adapter:shutdown'), Effect.tapCauseLogPretty, Effect.orDie),
-    )
-
     const runInWorker = <TReq extends typeof WorkerSchema.LeaderWorkerInner.Request.Type>(
       req: TReq,
     ): TReq extends Schema.WithResult<infer A, infer _I, infer _E, infer _EI, infer R>
@@ -410,39 +397,42 @@ const makeWorkerLeaderThread = ({
       Effect.withSpan('@livestore/adapter-node:client-session:export'),
     )
 
-    const leaderThread = {
-      events: {
-        pull:
-          testing?.overrides?.clientSession?.leaderThreadProxy?.events?.pull ??
-          (({ cursor }) =>
-            runInWorkerStream(new WorkerSchema.LeaderWorkerInner.PullStream({ cursor })).pipe(Stream.orDie)),
-        push: (batch) =>
-          runInWorker(new WorkerSchema.LeaderWorkerInner.PushToLeader({ batch })).pipe(
-            Effect.withSpan('@livestore/adapter-node:client-session:pushToLeader', {
-              attributes: { batchSize: batch.length },
-            }),
+    const leaderThread = ClientSessionLeaderThreadProxy.of(
+      {
+        events: {
+          pull: ({ cursor }) =>
+            runInWorkerStream(new WorkerSchema.LeaderWorkerInner.PullStream({ cursor })).pipe(Stream.orDie),
+          push: (batch) =>
+            runInWorker(new WorkerSchema.LeaderWorkerInner.PushToLeader({ batch })).pipe(
+              Effect.withSpan('@livestore/adapter-node:client-session:pushToLeader', {
+                attributes: { batchSize: batch.length },
+              }),
+            ),
+        },
+        initialState: {
+          leaderHead: initialLeaderHead,
+          migrationsReport: bootResult.migrationsReport,
+        },
+        export: runInWorker(new WorkerSchema.LeaderWorkerInner.Export()).pipe(
+          Effect.timeout(10_000),
+          UnexpectedError.mapToUnexpectedError,
+          Effect.withSpan('@livestore/adapter-node:client-session:export'),
+        ),
+        getEventlogData: Effect.dieMessage('Not implemented'),
+        getSyncState: runInWorker(new WorkerSchema.LeaderWorkerInner.GetLeaderSyncState()).pipe(
+          UnexpectedError.mapToUnexpectedError,
+          Effect.withSpan('@livestore/adapter-node:client-session:getLeaderSyncState'),
+        ),
+        sendDevtoolsMessage: (message) =>
+          runInWorker(new WorkerSchema.LeaderWorkerInner.ExtraDevtoolsMessage({ message })).pipe(
+            UnexpectedError.mapToUnexpectedError,
+            Effect.withSpan('@livestore/adapter-node:client-session:devtoolsMessageForLeader'),
           ),
       },
-      initialState: {
-        leaderHead: initialLeaderHead,
-        migrationsReport: bootResult.migrationsReport,
+      {
+        overrides: testing?.overrides?.clientSession?.leaderThreadProxy,
       },
-      export: runInWorker(new WorkerSchema.LeaderWorkerInner.Export()).pipe(
-        Effect.timeout(10_000),
-        UnexpectedError.mapToUnexpectedError,
-        Effect.withSpan('@livestore/adapter-node:client-session:export'),
-      ),
-      getEventlogData: Effect.dieMessage('Not implemented'),
-      getSyncState: runInWorker(new WorkerSchema.LeaderWorkerInner.GetLeaderSyncState()).pipe(
-        UnexpectedError.mapToUnexpectedError,
-        Effect.withSpan('@livestore/adapter-node:client-session:getLeaderSyncState'),
-      ),
-      sendDevtoolsMessage: (message) =>
-        runInWorker(new WorkerSchema.LeaderWorkerInner.ExtraDevtoolsMessage({ message })).pipe(
-          UnexpectedError.mapToUnexpectedError,
-          Effect.withSpan('@livestore/adapter-node:client-session:devtoolsMessageForLeader'),
-        ),
-    } satisfies ClientSessionLeaderThreadProxy
+    )
 
     return { leaderThread, initialSnapshot: bootResult.snapshot }
   })

package/src/devtools/mod.ts

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

package/src/leader-thread-shared.ts

@@ -21,11 +21,17 @@ import type * as WorkerSchema from './worker-schema.js'
 
 export type TestingOverrides = {
   clientSession?: {
-    leaderThreadProxy?: Partial<ClientSessionLeaderThreadProxy>
-  }
-  makeLeaderThread?: {
-    dbEventlog?: (makeSqliteDb: MakeSqliteDb) => Effect.Effect<SqliteDb, UnexpectedError>
+    leaderThreadProxy?: (
+      original: ClientSessionLeaderThreadProxy.ClientSessionLeaderThreadProxy,
+    ) => Partial<ClientSessionLeaderThreadProxy.ClientSessionLeaderThreadProxy>
   }
+  makeLeaderThread?: (makeSqliteDb: MakeSqliteDb) => Effect.Effect<
+    {
+      dbEventlog: SqliteDb
+      dbState: SqliteDb
+    },
+    UnexpectedError
+  >
 }
 
 export interface MakeLeaderThreadArgs {
@@ -62,8 +68,10 @@ export const makeLeaderThread = ({
       schema.state.sqlite.migrations.strategy === 'manual' ? 'fixed' : schema.state.sqlite.hash.toString()
 
     const makeDb = (kind: 'state' | 'eventlog') => {
-      if (testing?.makeLeaderThread?.dbEventlog && kind === 'eventlog') {
-        return testing.makeLeaderThread.dbEventlog(makeSqliteDb)
+      if (testing?.makeLeaderThread) {
+        return testing
+          .makeLeaderThread(makeSqliteDb)
+          .pipe(Effect.map(({ dbEventlog, dbState }) => (kind === 'state' ? dbState : dbEventlog)))
       }
 
       return storage.type === 'in-memory'

package/src/make-leader-worker.ts

@@ -47,7 +47,7 @@ export type WorkerOptions = {
 export const getWorkerArgs = () => Schema.decodeSync(WorkerSchema.WorkerArgv)(process.argv[2]!)
 
 export const makeWorker = (options: WorkerOptions) => {
-  makeWorkerEffect(options).pipe(Effect.runFork)
+  makeWorkerEffect(options).pipe(PlatformNode.NodeRuntime.runMain)
 }
 
 export const makeWorkerEffect = (options: WorkerOptions) => {

package/src/webchannel.ts

@@ -1,4 +1,4 @@
-import { type BroadcastChannel as NodeBroadcastChannel } from 'node:worker_threads'
+import type { BroadcastChannel as NodeBroadcastChannel } from 'node:worker_threads'
 
 import type { Either, ParseResult } from '@livestore/utils/effect'
 import { Deferred, Effect, Exit, Schema, Scope, Stream, WebChannel } from '@livestore/utils/effect'
@@ -37,7 +37,6 @@ export const makeBroadcastChannel = <Msg, MsgEncoded>({
       const listen = Stream.asyncPush<Either.Either<Msg, ParseResult.ParseError>>((emit) =>
         Effect.acquireRelease(
           Effect.gen(function* () {
-            // eslint-disable-next-line unicorn/prefer-add-event-listener
             channel.onmessage = (event: any) => {
               return emit.single(Schema.decodeEither(schema)(event.data))
             }

package/src/worker-schema.ts

@@ -1,12 +1,4 @@
-import {
-  BootStatus,
-  Devtools,
-  LeaderAheadError,
-  LeaderPullCursor,
-  MigrationsReport,
-  SyncState,
-  UnexpectedError,
-} from '@livestore/common'
+import { BootStatus, Devtools, LeaderAheadError, MigrationsReport, SyncState, UnexpectedError } from '@livestore/common'
 import { EventSequenceNumber, LiveStoreEvent } from '@livestore/common/schema'
 import { Schema, Transferable } from '@livestore/utils/effect'
 
@@ -91,11 +83,10 @@ export namespace LeaderWorkerInner {
 
   export class PullStream extends Schema.TaggedRequest<PullStream>()('PullStream', {
     payload: {
-      cursor: LeaderPullCursor,
+      cursor: EventSequenceNumber.EventSequenceNumber,
     },
     success: Schema.Struct({
       payload: SyncState.PayloadUpstream,
-      mergeCounter: Schema.Number,
     }),
     failure: UnexpectedError,
   }) {}