@livestore/adapter-node 0.0.0-snapshot-057a9e3a18ca69a310d4eb8cf35a34e94fa1841e → 0.0.0-snapshot-8fd59846e2580d37bdd37ae607e9db2a458a8b63

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,
-  type BootStatus,
+
+import type {
+  Adapter,
+  BootStatus,
   ClientSessionLeaderThreadProxy,
-  type IntentionalShutdownCause,
-  type LockStatus,
-  type MakeSqliteDb,
-  makeClientSession,
-  type SyncOptions,
-  UnexpectedError,
+  IntentionalShutdownCause,
+  LockStatus,
+  MakeSqliteDb,
+  SyncOptions,
 } 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,7 +188,6 @@ const makeAdapterImpl = ({
             })
 
       syncInMemoryDb.import(initialSnapshot)
-      syncInMemoryDb.debug.head = leaderThread.initialState.leaderHead
 
       const clientSession = yield* makeClientSession({
         ...adapterArgs,
@@ -215,6 +214,7 @@ 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,24 +262,23 @@ const makeLocalLeaderThread = ({
 
       const initialLeaderHead = Eventlog.getClientHeadFromDb(dbEventlog)
 
-      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),
+      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 },
+            ),
         },
-        { overrides: testing?.overrides?.clientSession?.leaderThreadProxy },
-      )
+        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
 
       const initialSnapshot = dbState.export()
 
@@ -337,6 +336,20 @@ 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>
@@ -397,42 +410,39 @@ const makeWorkerLeaderThread = ({
       Effect.withSpan('@livestore/adapter-node:client-session:export'),
     )
 
-    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'),
+    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 },
+            }),
           ),
       },
-      {
-        overrides: testing?.overrides?.clientSession?.leaderThreadProxy,
+      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'),
+        ),
+    } satisfies ClientSessionLeaderThreadProxy
 
     return { leaderThread, initialSnapshot: bootResult.snapshot }
   })

package/src/devtools/mod.ts

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

package/src/leader-thread-shared.ts

@@ -21,17 +21,11 @@ import type * as WorkerSchema from './worker-schema.js'
 
 export type TestingOverrides = {
   clientSession?: {
-    leaderThreadProxy?: (
-      original: ClientSessionLeaderThreadProxy.ClientSessionLeaderThreadProxy,
-    ) => Partial<ClientSessionLeaderThreadProxy.ClientSessionLeaderThreadProxy>
+    leaderThreadProxy?: Partial<ClientSessionLeaderThreadProxy>
+  }
+  makeLeaderThread?: {
+    dbEventlog?: (makeSqliteDb: MakeSqliteDb) => Effect.Effect<SqliteDb, UnexpectedError>
   }
-  makeLeaderThread?: (makeSqliteDb: MakeSqliteDb) => Effect.Effect<
-    {
-      dbEventlog: SqliteDb
-      dbState: SqliteDb
-    },
-    UnexpectedError
-  >
 }
 
 export interface MakeLeaderThreadArgs {
@@ -68,10 +62,8 @@ export const makeLeaderThread = ({
       schema.state.sqlite.migrations.strategy === 'manual' ? 'fixed' : schema.state.sqlite.hash.toString()
 
     const makeDb = (kind: 'state' | 'eventlog') => {
-      if (testing?.makeLeaderThread) {
-        return testing
-          .makeLeaderThread(makeSqliteDb)
-          .pipe(Effect.map(({ dbEventlog, dbState }) => (kind === 'state' ? dbState : dbEventlog)))
+      if (testing?.makeLeaderThread?.dbEventlog && kind === 'eventlog') {
+        return testing.makeLeaderThread.dbEventlog(makeSqliteDb)
       }
 
       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(PlatformNode.NodeRuntime.runMain)
+  makeWorkerEffect(options).pipe(Effect.runFork)
 }
 
 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,6 +37,7 @@ 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,4 +1,12 @@
-import { BootStatus, Devtools, LeaderAheadError, MigrationsReport, SyncState, UnexpectedError } from '@livestore/common'
+import {
+  BootStatus,
+  Devtools,
+  LeaderAheadError,
+  LeaderPullCursor,
+  MigrationsReport,
+  SyncState,
+  UnexpectedError,
+} from '@livestore/common'
 import { EventSequenceNumber, LiveStoreEvent } from '@livestore/common/schema'
 import { Schema, Transferable } from '@livestore/utils/effect'
 
@@ -83,10 +91,11 @@ export namespace LeaderWorkerInner {
 
   export class PullStream extends Schema.TaggedRequest<PullStream>()('PullStream', {
     payload: {
-      cursor: EventSequenceNumber.EventSequenceNumber,
+      cursor: LeaderPullCursor,
     },
     success: Schema.Struct({
       payload: SyncState.PayloadUpstream,
+      mergeCounter: Schema.Number,
     }),
     failure: UnexpectedError,
   }) {}