@livestore/adapter-web 0.4.0 → 0.5.0-dev.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (73) hide show
  1. package/dist/.tsbuildinfo +1 -1
  2. package/dist/common/connection.d.ts.map +1 -1
  3. package/dist/in-memory/in-memory-adapter.d.ts +7 -8
  4. package/dist/in-memory/in-memory-adapter.d.ts.map +1 -1
  5. package/dist/in-memory/in-memory-adapter.js +37 -30
  6. package/dist/in-memory/in-memory-adapter.js.map +1 -1
  7. package/dist/index.js +4 -4
  8. package/dist/single-tab/mod.js +1 -1
  9. package/dist/single-tab/single-tab-adapter.d.ts.map +1 -1
  10. package/dist/single-tab/single-tab-adapter.js +63 -83
  11. package/dist/single-tab/single-tab-adapter.js.map +1 -1
  12. package/dist/web-worker/client-session/client-session-devtools.d.ts +3 -4
  13. package/dist/web-worker/client-session/client-session-devtools.d.ts.map +1 -1
  14. package/dist/web-worker/client-session/client-session-devtools.js +7 -5
  15. package/dist/web-worker/client-session/client-session-devtools.js.map +1 -1
  16. package/dist/web-worker/client-session/devtools-web-channel.d.ts +20 -0
  17. package/dist/web-worker/client-session/devtools-web-channel.d.ts.map +1 -0
  18. package/dist/web-worker/client-session/devtools-web-channel.js +34 -0
  19. package/dist/web-worker/client-session/devtools-web-channel.js.map +1 -0
  20. package/dist/web-worker/client-session/persisted-adapter.d.ts.map +1 -1
  21. package/dist/web-worker/client-session/persisted-adapter.js +76 -85
  22. package/dist/web-worker/client-session/persisted-adapter.js.map +1 -1
  23. package/dist/web-worker/client-session/sqlite-loader.js.map +1 -1
  24. package/dist/web-worker/common/persisted-sqlite.d.ts +23 -10
  25. package/dist/web-worker/common/persisted-sqlite.d.ts.map +1 -1
  26. package/dist/web-worker/common/persisted-sqlite.js +29 -25
  27. package/dist/web-worker/common/persisted-sqlite.js.map +1 -1
  28. package/dist/web-worker/common/persisted-sqlite.test-fixture.d.ts +2 -0
  29. package/dist/web-worker/common/persisted-sqlite.test-fixture.d.ts.map +1 -0
  30. package/dist/web-worker/common/persisted-sqlite.test-fixture.js +57 -0
  31. package/dist/web-worker/common/persisted-sqlite.test-fixture.js.map +1 -0
  32. package/dist/web-worker/common/rpc-worker.d.ts +14 -0
  33. package/dist/web-worker/common/rpc-worker.d.ts.map +1 -0
  34. package/dist/web-worker/common/rpc-worker.js +8 -0
  35. package/dist/web-worker/common/rpc-worker.js.map +1 -0
  36. package/dist/web-worker/common/shutdown-channel.d.ts.map +1 -1
  37. package/dist/web-worker/common/webmesh-node-names.d.ts +4 -0
  38. package/dist/web-worker/common/webmesh-node-names.d.ts.map +1 -0
  39. package/dist/web-worker/common/webmesh-node-names.js +2 -0
  40. package/dist/web-worker/common/webmesh-node-names.js.map +1 -0
  41. package/dist/web-worker/common/worker-disconnect-channel.d.ts +1 -4
  42. package/dist/web-worker/common/worker-disconnect-channel.d.ts.map +1 -1
  43. package/dist/web-worker/common/worker-disconnect-channel.js +1 -2
  44. package/dist/web-worker/common/worker-disconnect-channel.js.map +1 -1
  45. package/dist/web-worker/common/worker-schema.d.ts +275 -211
  46. package/dist/web-worker/common/worker-schema.d.ts.map +1 -1
  47. package/dist/web-worker/common/worker-schema.js +71 -52
  48. package/dist/web-worker/common/worker-schema.js.map +1 -1
  49. package/dist/web-worker/leader-worker/make-leader-worker.d.ts +6 -8
  50. package/dist/web-worker/leader-worker/make-leader-worker.d.ts.map +1 -1
  51. package/dist/web-worker/leader-worker/make-leader-worker.js +147 -94
  52. package/dist/web-worker/leader-worker/make-leader-worker.js.map +1 -1
  53. package/dist/web-worker/shared-worker/make-shared-worker.d.ts +2 -2
  54. package/dist/web-worker/shared-worker/make-shared-worker.d.ts.map +1 -1
  55. package/dist/web-worker/shared-worker/make-shared-worker.js +54 -66
  56. package/dist/web-worker/shared-worker/make-shared-worker.js.map +1 -1
  57. package/dist/web-worker/vite-dev-polyfill.js +1 -2
  58. package/dist/web-worker/vite-dev-polyfill.js.map +1 -1
  59. package/package.json +38 -48
  60. package/src/in-memory/in-memory-adapter.ts +73 -58
  61. package/src/single-tab/single-tab-adapter.ts +112 -114
  62. package/src/web-worker/client-session/client-session-devtools.ts +16 -8
  63. package/src/web-worker/client-session/devtools-web-channel.ts +57 -0
  64. package/src/web-worker/client-session/persisted-adapter.ts +122 -124
  65. package/src/web-worker/common/persisted-sqlite.test-fixture.ts +68 -0
  66. package/src/web-worker/common/persisted-sqlite.ts +72 -50
  67. package/src/web-worker/common/rpc-worker.ts +39 -0
  68. package/src/web-worker/common/webmesh-node-names.ts +1 -0
  69. package/src/web-worker/common/worker-disconnect-channel.ts +1 -1
  70. package/src/web-worker/common/worker-schema.ts +132 -162
  71. package/src/web-worker/leader-worker/make-leader-worker.ts +347 -219
  72. package/src/web-worker/shared-worker/make-shared-worker.ts +95 -85
  73. package/src/web-worker/vite-dev-polyfill.ts +1 -2
@@ -1,7 +1,7 @@
1
1
  import type * as otel from '@opentelemetry/api'
2
2
 
3
- import type { BootStatus, BootWarningReason, SqliteDb, SyncOptions } from '@livestore/common'
4
- import { Devtools, LogConfig, UnknownError } from '@livestore/common'
3
+ import type { BootStatus, BootWarningReason, LogConfig, SqliteDb, SyncOptions } from '@livestore/common'
4
+ import { Devtools, StateHead, UnknownError } from '@livestore/common'
5
5
  import type { DevtoolsOptions, StreamEventsOptions } from '@livestore/common/leader-thread'
6
6
  import {
7
7
  configureConnection,
@@ -10,26 +10,30 @@ import {
10
10
  makeLeaderThreadLayer,
11
11
  streamEventsWithSyncState,
12
12
  } from '@livestore/common/leader-thread'
13
- import type { LiveStoreSchema } from '@livestore/common/schema'
14
- import { LiveStoreEvent } from '@livestore/common/schema'
15
- import * as WebmeshWorker from '@livestore/devtools-web-common/worker'
13
+ import { LiveStoreEvent, type LiveStoreSchema } from '@livestore/common/schema'
16
14
  import { sqliteDbFactory } from '@livestore/sqlite-wasm/browser'
17
15
  import { loadSqlite3Wasm } from '@livestore/sqlite-wasm/load-wasm'
18
16
  import { isDevEnv, LS_DEV } from '@livestore/utils'
19
- import type { HttpClient, Scope, WorkerError } from '@livestore/utils/effect'
20
17
  import {
18
+ Cause,
19
+ Deferred,
21
20
  Effect,
22
21
  FetchHttpClient,
23
22
  identity,
24
23
  Layer,
25
24
  OtelTracer,
26
- Scheduler,
25
+ Queue,
26
+ References,
27
+ RpcSerialization,
28
+ RpcServer,
29
+ RpcWorker,
27
30
  Schema,
31
+ Scope,
28
32
  Stream,
29
33
  TaskTracing,
30
- WorkerRunner,
31
34
  } from '@livestore/utils/effect'
32
35
  import { BrowserWorkerRunner, Opfs, WebError } from '@livestore/utils/effect/browser'
36
+ import * as WebmeshWorker from '@livestore/webmesh/worker'
33
37
 
34
38
  import { cleanupOldStateDbFiles, getStateDbFileName, sanitizeOpfsDir } from '../common/persisted-sqlite.ts'
35
39
  import { makeShutdownChannel } from '../common/shutdown-channel.ts'
@@ -38,11 +42,11 @@ import * as WorkerSchema from '../common/worker-schema.ts'
38
42
  export type WorkerOptions = {
39
43
  schema: LiveStoreSchema
40
44
  sync?: SyncOptions
41
- syncPayloadSchema?: Schema.Schema<any>
45
+ syncPayloadSchema?: Schema.Top
42
46
  otelOptions?: {
43
47
  tracer?: otel.Tracer
44
48
  }
45
- } & LogConfig.WithLoggerOptions
49
+ } & LogConfig.LoggerOptions
46
50
 
47
51
  if (isDevEnv() === true) {
48
52
  globalThis.__debugLiveStoreUtils = {
@@ -55,239 +59,363 @@ if (isDevEnv() === true) {
55
59
  }
56
60
 
57
61
  export const makeWorker = (options: WorkerOptions) => {
58
- makeWorkerEffect(options).pipe(Effect.runFork)
62
+ Effect.runFork(makeWorkerEffect(options))
59
63
  }
60
64
 
61
65
  export const makeWorkerEffect = (options: WorkerOptions) => {
62
- const TracingLive = options.otelOptions?.tracer !== undefined
63
- ? Layer.unwrapEffect(Effect.map(OtelTracer.make, Layer.setTracer)).pipe(
64
- Layer.provideMerge(Layer.succeed(OtelTracer.OtelTracer, options.otelOptions.tracer)),
65
- )
66
- : undefined
66
+ const TracingLive =
67
+ options.otelOptions?.tracer !== undefined
68
+ ? OtelTracer.layerWithoutOtelTracer.pipe(
69
+ Layer.provideMerge(Layer.succeed(OtelTracer.OtelTracer, options.otelOptions.tracer)),
70
+ )
71
+ : Layer.empty
67
72
 
68
- const runtimeLayer = Layer.mergeAll(FetchHttpClient.layer, TracingLive ?? Layer.empty)
73
+ const runtimeLayer = Layer.mergeAll(
74
+ FetchHttpClient.layer,
75
+ TracingLive,
76
+ Layer.succeed(References.MaxOpsBeforeYield, 4096),
77
+ )
69
78
 
70
79
  return makeWorkerRunnerOuter(options).pipe(
71
- Layer.provide(BrowserWorkerRunner.layer),
72
- WorkerRunner.launch,
80
+ Effect.provide(Layer.provideMerge(RpcServer.layerProtocolWorkerRunner, BrowserWorkerRunner.layer)),
73
81
  Effect.scoped,
74
82
  Effect.tapCauseLogPretty,
75
83
  Effect.annotateLogs({ thread: self.name }),
76
84
  Effect.provide(runtimeLayer),
77
85
  LS_DEV === true ? TaskTracing.withAsyncTaggingTracing((name) => (console as any).createTask(name)) : identity,
78
- // We're using this custom scheduler to improve op batching behaviour and reduce the overhead
79
- // of the Effect fiber runtime given we have different tradeoffs on a worker thread.
80
- // Despite the "message channel" name, is has nothing to do with the `incomingRequestsPort` above.
81
- Effect.withScheduler(Scheduler.messageChannel()),
82
- // We're increasing the Effect ops limit here to allow for larger chunks of operations at a time
83
- Effect.withMaxOpsBeforeYield(4096),
84
- LogConfig.withLoggerConfig({ logger: options.logger, logLevel: options.logLevel }, { threadName: self.name }),
86
+ Effect.provide(
87
+ Layer.mergeAll(
88
+ options.logger ?? Layer.empty,
89
+ Layer.succeed(References.MinimumLogLevel, options.logLevel ?? (isDevEnv() === true ? 'Debug' : 'Info')),
90
+ ),
91
+ ),
85
92
  )
86
93
  }
87
94
 
88
- const makeWorkerRunnerOuter = (
95
+ const makeWorkerRunnerOuter = Effect.fn('@livestore/adapter-web:worker:wrapper:InitialMessage')(function* (
89
96
  workerOptions: WorkerOptions,
90
- ): Layer.Layer<never, WorkerError.WorkerError, WorkerRunner.PlatformRunner | HttpClient.HttpClient> =>
91
- WorkerRunner.layerSerialized(WorkerSchema.LeaderWorkerOuterInitialMessage, {
92
- // Port coming from client session and forwarded via the shared worker
93
- InitialMessage: ({ port: incomingRequestsPort, storeId, clientId }) =>
94
- Effect.gen(function* () {
95
- yield* makeWorkerRunnerInner(workerOptions).pipe(
96
- Layer.provide(BrowserWorkerRunner.layerMessagePort(incomingRequestsPort)),
97
- WorkerRunner.launch,
98
- Effect.scoped,
99
- Effect.withSpan('@livestore/adapter-web:worker:wrapper:InitialMessage:innerFiber'),
100
- Effect.tapCauseLogPretty,
101
- Effect.provide(
102
- Layer.mergeAll(
103
- Opfs.Opfs.Default,
104
- WebmeshWorker.CacheService.layer({
105
- nodeName: Devtools.makeNodeName.client.leader({ storeId, clientId }),
106
- }),
107
- ),
108
- ),
109
- Effect.forkScoped,
110
- )
97
+ ) {
98
+ // Port coming from client session and forwarded via the shared worker.
99
+ const {
100
+ port: incomingRequestsPort,
101
+ storeId,
102
+ clientId,
103
+ } = yield* RpcWorker.initialMessage(WorkerSchema.LeaderWorkerOuterInitialMessage.payloadSchema)
111
104
 
112
- return Layer.empty
113
- }).pipe(Effect.withSpan('@livestore/adapter-web:worker:wrapper:InitialMessage'), Layer.unwrapScoped),
114
- })
105
+ return yield* RpcServer.make(WorkerSchema.LeaderWorkerInnerRpcs).pipe(
106
+ Effect.provide(
107
+ Layer.provideMerge(makeWorkerRunnerInner(workerOptions), makeMessagePortRpcServerProtocol(incomingRequestsPort)),
108
+ ),
109
+ Effect.withSpan('@livestore/adapter-web:worker:wrapper:InitialMessage:innerFiber'),
110
+ Effect.tapCauseLogPretty,
111
+ Effect.provide(
112
+ Layer.mergeAll(
113
+ Opfs.layer,
114
+ WebmeshWorker.CacheService.layer({
115
+ nodeName: Devtools.makeNodeName.client.leader({ storeId, clientId }),
116
+ }),
117
+ ),
118
+ ),
119
+ )
120
+ })
121
+
122
+ const makeMessagePortRpcServerProtocol = (port: MessagePort): Layer.Layer<RpcServer.Protocol> =>
123
+ Layer.effect(
124
+ RpcServer.Protocol,
125
+ Effect.gen(function* () {
126
+ const disconnects = yield* Queue.unbounded<number>()
127
+ const initialMessage = yield* Deferred.make<unknown>()
128
+ const closed = yield* Deferred.make<void>()
129
+ const clientIds = new Set<number>()
130
+
131
+ return RpcServer.Protocol.of({
132
+ disconnects,
133
+ send: (_clientId, response, transferables) =>
134
+ Effect.sync(() => port.postMessage([1, response], { transfer: (transferables ?? []) as Transferable[] })),
135
+ end: () => Effect.void,
136
+ clientIds: Effect.succeed(clientIds),
137
+ initialMessage: Effect.asSome(Deferred.await(initialMessage)),
138
+ supportsAck: true,
139
+ supportsTransferables: true,
140
+ supportsSpanPropagation: true,
141
+ supportsNotifications: true,
142
+ codecFor: RpcSerialization.json.codecFor,
143
+ run: (writeRequest) =>
144
+ Effect.gen(function* () {
145
+ const context = yield* Effect.context<never>()
146
+ const runFork = Effect.runForkWith(context)
147
+ const onMessage = (event: MessageEvent) => {
148
+ const message = event.data as readonly [0 | 1, unknown?]
149
+ if (message[0] === 1) {
150
+ runFork(
151
+ Effect.gen(function* () {
152
+ yield* Queue.offer(disconnects, 0)
153
+ yield* Deferred.succeed(closed, undefined)
154
+ }),
155
+ )
156
+ return
157
+ }
158
+
159
+ const request = message[1] as { readonly _tag?: string; readonly value?: unknown }
160
+ clientIds.add(0)
161
+ if (request._tag === 'InitialMessage') {
162
+ runFork(Deferred.succeed(initialMessage, request.value))
163
+ } else {
164
+ runFork(writeRequest(0, request as never))
165
+ }
166
+ }
167
+
168
+ port.addEventListener('message', onMessage)
169
+ port.start()
170
+ port.postMessage([0])
171
+
172
+ return yield* Deferred.await(closed).pipe(
173
+ Effect.andThen(Effect.interrupt),
174
+ Effect.ensuring(
175
+ Effect.sync(() => {
176
+ port.removeEventListener('message', onMessage)
177
+ port.close()
178
+ }),
179
+ ),
180
+ )
181
+ }),
182
+ })
183
+ }),
184
+ )
115
185
 
116
186
  const makeWorkerRunnerInner = ({ schema, sync: syncOptions, syncPayloadSchema }: WorkerOptions) =>
117
- WorkerRunner.layerSerialized(WorkerSchema.LeaderWorkerInnerRequest, {
118
- InitialMessage: ({ storageOptions, storeId, clientId, devtoolsEnabled, debugInstanceId, syncPayloadEncoded }) =>
119
- Effect.gen(function* () {
120
- const sqlite3 = yield* Effect.promise(() => loadSqlite3Wasm())
121
- const makeSqliteDb = sqliteDbFactory({ sqlite3 })
122
- const runtime = yield* Effect.runtime()
123
-
124
- // Check OPFS availability and determine storage mode
125
- const opfsCheck = yield* checkOpfsAvailability
126
- const useOpfs = opfsCheck === undefined
127
-
128
- // Track boot warning to emit later
129
- let bootWarning: BootStatus | undefined
130
- if (useOpfs === false) {
131
- yield* Effect.logWarning(
132
- '[@livestore/adapter-web:worker] OPFS unavailable, using in-memory storage',
133
- opfsCheck,
187
+ WorkerSchema.LeaderWorkerInnerRpcs.toLayer(
188
+ Effect.gen(function* () {
189
+ const leaderThreadScope = yield* Scope.make()
190
+ yield* Effect.addFinalizer((exit) => Scope.close(leaderThreadScope, exit))
191
+
192
+ const leaderThreadContextOnce = yield* Effect.cached(
193
+ Effect.gen(function* () {
194
+ const { storageOptions, storeId, clientId, devtoolsEnabled, debugInstanceId, syncPayloadEncoded, params } =
195
+ yield* RpcWorker.initialMessage(WorkerSchema.LeaderWorkerInnerInitialMessage.payloadSchema)
196
+
197
+ const sqlite3 = yield* Effect.promise(() => loadSqlite3Wasm())
198
+ const makeSqliteDb = sqliteDbFactory({ sqlite3 })
199
+ const services = yield* Effect.context()
200
+
201
+ // Check OPFS availability and determine storage mode
202
+ const opfsCheck = yield* checkOpfsAvailability
203
+ const useOpfs = opfsCheck === undefined
204
+
205
+ // Track boot warning to emit later
206
+ let bootWarning: BootStatus | undefined
207
+ if (useOpfs === false) {
208
+ yield* Effect.logWarning(
209
+ '[@livestore/adapter-web:worker] OPFS unavailable, using in-memory storage',
210
+ opfsCheck,
211
+ )
212
+ bootWarning = { stage: 'warning', ...opfsCheck }
213
+ }
214
+
215
+ const opfsDirectory = useOpfs === true ? yield* sanitizeOpfsDir(storageOptions.directory, storeId) : undefined
216
+
217
+ const makeOpfsDb = (kind: 'state' | 'eventlog') =>
218
+ Effect.acquireRelease(
219
+ makeSqliteDb({
220
+ _tag: 'opfs',
221
+ opfsDirectory: opfsDirectory!,
222
+ fileName: kind === 'state' ? getStateDbFileName(schema) : 'eventlog.db',
223
+ configureDb: (db) =>
224
+ configureConnection(db, {
225
+ // The persisted databases use the AccessHandlePoolVFS which always uses a single database connection.
226
+ // Multiple connections are not supported. This means that we can use the exclusive locking mode to
227
+ // avoid unnecessary system calls and enable the use of the WAL journal mode without the use of shared memory.
228
+ // TODO bring back exclusive locking mode when `WAL` is working properly
229
+ // lockingMode: 'EXCLUSIVE',
230
+ foreignKeys: true,
231
+ }).pipe(Effect.runSyncWith(services)),
232
+ }),
233
+ (db) =>
234
+ Effect.try({
235
+ try: () => db.close(),
236
+ catch: (cause) => new Cause.UnknownError(cause),
237
+ }).pipe(Effect.ignore),
238
+ )
239
+
240
+ const makeInMemoryDb = () =>
241
+ Effect.acquireRelease(
242
+ makeSqliteDb({
243
+ _tag: 'in-memory',
244
+ configureDb: (db) => configureConnection(db, { foreignKeys: true }).pipe(Effect.runSyncWith(services)),
245
+ }),
246
+ (db) =>
247
+ Effect.try({
248
+ try: () => db.close(),
249
+ catch: (cause) => new Cause.UnknownError(cause),
250
+ }).pipe(Effect.ignore),
251
+ )
252
+
253
+ // Use OPFS if available, otherwise fall back to in-memory
254
+ const [dbState, dbEventlog] =
255
+ useOpfs === true
256
+ ? yield* Effect.all([makeOpfsDb('state'), makeOpfsDb('eventlog')], { concurrency: 2 })
257
+ : yield* Effect.all([makeInMemoryDb(), makeInMemoryDb()], { concurrency: 2 })
258
+
259
+ // Clean up old state database files after successful database creation
260
+ // This prevents OPFS file pool capacity exhaustion from accumulated state db files after schema changes/migrations
261
+ if (dbState.metadata._tag === 'opfs') {
262
+ yield* cleanupOldStateDbFiles({
263
+ vfs: dbState.metadata.vfs,
264
+ currentSchema: schema,
265
+ opfsDirectory: dbState.metadata.persistenceInfo.opfsDirectory,
266
+ })
267
+ }
268
+
269
+ const devtoolsOptions = yield* makeDevtoolsOptions({ devtoolsEnabled, dbState, dbEventlog })
270
+ const shutdownChannel = yield* makeShutdownChannel(storeId)
271
+
272
+ return yield* Layer.buildWithScope(
273
+ makeLeaderThreadLayer({
274
+ schema,
275
+ storeId,
276
+ clientId,
277
+ makeSqliteDb,
278
+ syncOptions,
279
+ dbState,
280
+ dbEventlog,
281
+ devtoolsOptions,
282
+ shutdownChannel,
283
+ syncPayloadEncoded,
284
+ syncPayloadSchema: syncPayloadSchema as Schema.Decoder<Schema.Json, never> | undefined,
285
+ params,
286
+ ...(bootWarning !== undefined ? { bootWarning } : {}),
287
+ }).pipe(Layer.provide(StateHead.layer({ dbState }))),
288
+ leaderThreadScope,
134
289
  )
135
- bootWarning = { stage: 'warning', ...opfsCheck }
136
- }
137
-
138
- const opfsDirectory = useOpfs === true ? yield* sanitizeOpfsDir(storageOptions.directory, storeId) : undefined
139
-
140
- const makeOpfsDb = (kind: 'state' | 'eventlog') =>
141
- makeSqliteDb({
142
- _tag: 'opfs',
143
- opfsDirectory: opfsDirectory!,
144
- fileName: kind === 'state' ? getStateDbFileName(schema) : 'eventlog.db',
145
- configureDb: (db) =>
146
- configureConnection(db, {
147
- // The persisted databases use the AccessHandlePoolVFS which always uses a single database connection.
148
- // Multiple connections are not supported. This means that we can use the exclusive locking mode to
149
- // avoid unnecessary system calls and enable the use of the WAL journal mode without the use of shared memory.
150
- // TODO bring back exclusive locking mode when `WAL` is working properly
151
- // lockingMode: 'EXCLUSIVE',
152
- foreignKeys: true,
153
- }).pipe(Effect.provide(runtime), Effect.runSync),
154
- }).pipe(Effect.acquireRelease((db) => Effect.try(() => db.close()).pipe(Effect.ignoreLogged)))
155
-
156
- const makeInMemoryDb = () =>
157
- makeSqliteDb({
158
- _tag: 'in-memory',
159
- configureDb: (db) =>
160
- configureConnection(db, { foreignKeys: true }).pipe(Effect.provide(runtime), Effect.runSync),
161
- }).pipe(Effect.acquireRelease((db) => Effect.try(() => db.close()).pipe(Effect.ignoreLogged)))
162
-
163
- // Use OPFS if available, otherwise fall back to in-memory
164
- const [dbState, dbEventlog] = useOpfs === true
165
- ? yield* Effect.all([makeOpfsDb('state'), makeOpfsDb('eventlog')], { concurrency: 2 })
166
- : yield* Effect.all([makeInMemoryDb(), makeInMemoryDb()], { concurrency: 2 })
167
-
168
- // Clean up old state database files after successful database creation
169
- // This prevents OPFS file pool capacity exhaustion from accumulated state db files after schema changes/migrations
170
- if (dbState.metadata._tag === 'opfs') {
171
- yield* cleanupOldStateDbFiles({
172
- vfs: dbState.metadata.vfs,
173
- currentSchema: schema,
174
- opfsDirectory: dbState.metadata.persistenceInfo.opfsDirectory,
175
- })
176
- }
177
-
178
- const devtoolsOptions = yield* makeDevtoolsOptions({ devtoolsEnabled, dbState, dbEventlog })
179
- const shutdownChannel = yield* makeShutdownChannel(storeId)
180
-
181
- return makeLeaderThreadLayer({
182
- schema,
183
- storeId,
184
- clientId,
185
- makeSqliteDb,
186
- syncOptions,
187
- dbState,
188
- dbEventlog,
189
- devtoolsOptions,
190
- shutdownChannel,
191
- syncPayloadEncoded,
192
- syncPayloadSchema,
193
- ...(bootWarning !== undefined ? { bootWarning } : {}),
290
+ }).pipe(
291
+ Scope.provide(leaderThreadScope),
292
+ Effect.tapCauseLogPretty,
293
+ UnknownError.mapToUnknownError,
294
+ Effect.withPerformanceMeasure('@livestore/adapter-web:worker:InitialMessage'),
295
+ Effect.withSpan('@livestore/adapter-web:worker:InitialMessage'),
296
+ Effect.orDie,
297
+ ),
298
+ )
299
+
300
+ const provideLeaderThread = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
301
+ Effect.gen(function* () {
302
+ const leaderThreadContext = yield* leaderThreadContextOnce
303
+ return yield* effect.pipe(Effect.provide(leaderThreadContext))
194
304
  })
195
- }).pipe(
196
- Effect.tapCauseLogPretty,
197
- UnknownError.mapToUnknownError,
198
- Effect.withPerformanceMeasure('@livestore/adapter-web:worker:InitialMessage'),
199
- Effect.withSpan('@livestore/adapter-web:worker:InitialMessage'),
200
- Effect.annotateSpans({ debugInstanceId }),
201
- Layer.unwrapScoped,
202
- ),
203
- GetRecreateSnapshot: Effect.fn('@livestore/adapter-web:worker:GetRecreateSnapshot')(function* () {
204
- const workerCtx = yield* LeaderThreadCtx
305
+ const provideLeaderThreadStream = <A, E, R>(stream: Stream.Stream<A, E, R>) =>
306
+ Stream.unwrap(
307
+ Effect.gen(function* () {
308
+ const leaderThreadContext = yield* leaderThreadContextOnce
309
+ return stream.pipe(Stream.provide(leaderThreadContext))
310
+ }),
311
+ )
205
312
 
206
- // NOTE we can only return the cached snapshot once as it's transferred (i.e. disposed), so we need to set it to undefined
207
- // const cachedSnapshot =
208
- // result._tag === 'Recreate' ? yield* Ref.getAndSet(result.snapshotRef, undefined) : undefined
313
+ return WorkerSchema.LeaderWorkerInnerRpcs.of({
314
+ GetRecreateSnapshot: () =>
315
+ Effect.gen(function* () {
316
+ const workerCtx = yield* LeaderThreadCtx
209
317
 
210
- // return cachedSnapshot ?? workerCtx.db.export()
318
+ // NOTE we can only return the cached snapshot once as it's transferred (i.e. disposed), so we need to set it to undefined
319
+ // const cachedSnapshot =
320
+ // result._tag === 'Recreate' ? yield* Ref.getAndSet(result.snapshotRef, undefined) : undefined
211
321
 
212
- const snapshot = workerCtx.dbState.export()
213
- return { snapshot, migrationsReport: workerCtx.initialState.migrationsReport }
214
- }),
215
- PullStream: ({ cursor }) =>
216
- Effect.gen(function* () {
217
- const { syncProcessor } = yield* LeaderThreadCtx // <- syncState comes from here
218
- return syncProcessor.pull({ cursor })
219
- }).pipe(
220
- Stream.unwrapScoped,
221
- // For debugging purposes
222
- // Stream.tapLogWithLabel('@livestore/adapter-web:worker:PullStream'),
223
- ),
224
- PushToLeader: ({ batch }) =>
225
- Effect.andThen(LeaderThreadCtx, ({ syncProcessor }) =>
226
- syncProcessor.push(
227
- batch.map((event) => new LiveStoreEvent.Client.EncodedWithMeta(event)),
228
- // We'll wait in order to keep back pressure on the client session
229
- { waitForProcessing: true },
230
- ),
231
- ).pipe(Effect.uninterruptible, Effect.withSpan('@livestore/adapter-web:worker:PushToLeader')),
232
- StreamEvents: (options) =>
233
- LeaderThreadCtx.pipe(
234
- Effect.map(({ dbEventlog, syncProcessor }) => {
235
- const { _tag: _ignored, ...payload } = options as any
236
- const streamOptions = payload as StreamEventsOptions
237
- return streamEventsWithSyncState({
238
- dbEventlog,
239
- syncState: syncProcessor.syncState,
240
- options: streamOptions,
241
- })
322
+ // return cachedSnapshot ?? workerCtx.db.export()
323
+
324
+ const snapshot = workerCtx.dbState.export()
325
+ return { snapshot, migrationsReport: workerCtx.initialState.migrationsReport }
326
+ }).pipe(provideLeaderThread),
327
+ PullStream: ({ cursor }) =>
328
+ Effect.gen(function* () {
329
+ const { syncProcessor } = yield* LeaderThreadCtx // <- syncState comes from here
330
+ return syncProcessor.pull({ cursor })
331
+ }).pipe(
332
+ provideLeaderThread,
333
+ Stream.unwrap,
334
+ // For debugging purposes
335
+ // Stream.tapLogWithLabel('@livestore/adapter-web:worker:PullStream'),
336
+ ),
337
+ PushToLeader: ({ batch }) =>
338
+ Effect.andThen(LeaderThreadCtx, ({ syncProcessor }) =>
339
+ syncProcessor.push(batch.map((event) => new LiveStoreEvent.Client.EncodedWithMeta(event))),
340
+ ).pipe(
341
+ provideLeaderThread,
342
+ Effect.uninterruptible,
343
+ Effect.withSpan('@livestore/adapter-web:worker:PushToLeader'),
344
+ ),
345
+ StreamEvents: (options) =>
346
+ LeaderThreadCtx.pipe(
347
+ Effect.map(({ dbEventlog, syncProcessor }) =>
348
+ streamEventsWithSyncState({
349
+ dbEventlog,
350
+ syncState: syncProcessor.syncState,
351
+ options: options as StreamEventsOptions,
352
+ }),
353
+ ),
354
+ provideLeaderThread,
355
+ Stream.unwrap,
356
+ Stream.withSpan('@livestore/adapter-web:worker:StreamEvents'),
357
+ ),
358
+ Export: () =>
359
+ LeaderThreadCtx.pipe(
360
+ Effect.flatMap((_) => Effect.sync(() => _.dbState.export())),
361
+ provideLeaderThread,
362
+ Effect.withSpan('@livestore/adapter-web:worker:Export'),
363
+ ),
364
+ ExportEventlog: () =>
365
+ LeaderThreadCtx.pipe(
366
+ Effect.flatMap((_) => Effect.sync(() => _.dbEventlog.export())),
367
+ provideLeaderThread,
368
+ Effect.withSpan('@livestore/adapter-web:worker:ExportEventlog'),
369
+ ),
370
+ BootStatusStream: () =>
371
+ LeaderThreadCtx.pipe(
372
+ Effect.map((_) => Stream.fromQueue(_.bootStatusQueue)),
373
+ provideLeaderThread,
374
+ Stream.unwrap,
375
+ ),
376
+ GetLeaderHead: () =>
377
+ Effect.gen(function* () {
378
+ const workerCtx = yield* LeaderThreadCtx
379
+ return Eventlog.getClientHeadFromDb(workerCtx.dbEventlog)
380
+ }).pipe(provideLeaderThread),
381
+ GetLeaderSyncState: () =>
382
+ Effect.gen(function* () {
383
+ const workerCtx = yield* LeaderThreadCtx
384
+ return yield* workerCtx.syncProcessor.syncState
385
+ }).pipe(provideLeaderThread),
386
+ SyncStateStream: () =>
387
+ Effect.gen(function* () {
388
+ const workerCtx = yield* LeaderThreadCtx
389
+ return workerCtx.syncProcessor.syncState.changes
390
+ }).pipe(provideLeaderThread, Stream.unwrap),
391
+ GetNetworkStatus: () =>
392
+ Effect.gen(function* () {
393
+ const workerCtx = yield* LeaderThreadCtx
394
+ return yield* workerCtx.networkStatus
395
+ }).pipe(provideLeaderThread),
396
+ NetworkStatusStream: () =>
397
+ Effect.gen(function* () {
398
+ const workerCtx = yield* LeaderThreadCtx
399
+ return workerCtx.networkStatus.changes
400
+ }).pipe(provideLeaderThread, Stream.unwrap),
401
+ Shutdown: Effect.fn('@livestore/adapter-web:worker:Shutdown')(function* () {
402
+ yield* Effect.logDebug('[@livestore/adapter-web:worker] Shutdown')
403
+
404
+ // Buy some time for Otel to flush
405
+ // TODO find a cleaner way to do this
406
+ yield* Effect.sleep(300)
242
407
  }),
243
- Stream.unwrapScoped,
244
- Stream.withSpan('@livestore/adapter-web:worker:StreamEvents'),
245
- ),
246
- Export: () =>
247
- Effect.andThen(LeaderThreadCtx, (_) => _.dbState.export()).pipe(
248
- Effect.withSpan('@livestore/adapter-web:worker:Export'),
249
- ),
250
- ExportEventlog: () =>
251
- Effect.andThen(LeaderThreadCtx, (_) => _.dbEventlog.export()).pipe(
252
- Effect.withSpan('@livestore/adapter-web:worker:ExportEventlog'),
253
- ),
254
- BootStatusStream: () =>
255
- Effect.andThen(LeaderThreadCtx, (_) => Stream.fromQueue(_.bootStatusQueue)).pipe(Stream.unwrap),
256
- GetLeaderHead: Effect.fn('@livestore/adapter-web:worker:GetLeaderHead')(function* () {
257
- const workerCtx = yield* LeaderThreadCtx
258
- return Eventlog.getClientHeadFromDb(workerCtx.dbEventlog)
259
- }),
260
- GetLeaderSyncState: Effect.fn('@livestore/adapter-web:worker:GetLeaderSyncState')(function* () {
261
- const workerCtx = yield* LeaderThreadCtx
262
- return yield* workerCtx.syncProcessor.syncState
263
- }),
264
- SyncStateStream: () =>
265
- Effect.gen(function* () {
266
- const workerCtx = yield* LeaderThreadCtx
267
- return workerCtx.syncProcessor.syncState.changes
268
- }).pipe(Stream.unwrapScoped),
269
- GetNetworkStatus: Effect.fn('@livestore/adapter-web:worker:GetNetworkStatus')(function* () {
270
- const workerCtx = yield* LeaderThreadCtx
271
- return yield* workerCtx.networkStatus
272
- }),
273
- NetworkStatusStream: () =>
274
- Effect.gen(function* () {
275
- const workerCtx = yield* LeaderThreadCtx
276
- return workerCtx.networkStatus.changes
277
- }).pipe(Stream.unwrapScoped),
278
- Shutdown: Effect.fn('@livestore/adapter-web:worker:Shutdown')(function* () {
279
- yield* Effect.logDebug('[@livestore/adapter-web:worker] Shutdown')
280
-
281
- // Buy some time for Otel to flush
282
- // TODO find a cleaner way to do this
283
- yield* Effect.sleep(300)
408
+ ExtraDevtoolsMessage: ({ message }) =>
409
+ Effect.andThen(LeaderThreadCtx, (_) => Queue.offer(_.extraIncomingMessagesQueue, message)).pipe(
410
+ provideLeaderThread,
411
+ Effect.asVoid,
412
+ Effect.withSpan('@livestore/adapter-web:worker:ExtraDevtoolsMessage'),
413
+ ),
414
+ 'WebmeshWorker.CreateConnection': (payload) =>
415
+ WebmeshWorker.CreateConnection(payload).pipe(provideLeaderThreadStream),
416
+ })
284
417
  }),
285
- ExtraDevtoolsMessage: ({ message }) =>
286
- Effect.andThen(LeaderThreadCtx, (_) => _.extraIncomingMessagesQueue.offer(message)).pipe(
287
- Effect.withSpan('@livestore/adapter-web:worker:ExtraDevtoolsMessage'),
288
- ),
289
- 'DevtoolsWebCommon.CreateConnection': WebmeshWorker.CreateConnection,
290
- })
418
+ )
291
419
 
292
420
  const makeDevtoolsOptions = ({
293
421
  devtoolsEnabled,
@@ -330,7 +458,7 @@ const checkOpfsAvailability = Effect.gen(function* () {
330
458
  const opfs = yield* Opfs.Opfs
331
459
  return yield* opfs.getRootDirectoryHandle.pipe(
332
460
  Effect.as(undefined),
333
- Effect.catchAll((error) => {
461
+ Effect.catch((error) => {
334
462
  const reason: BootWarningReason =
335
463
  Schema.is(WebError.SecurityError)(error) === true || Schema.is(WebError.NotAllowedError)(error) === true
336
464
  ? 'private-browsing'