@livestore/sync-cf 0.3.0-dev.5 → 0.3.0-dev.50

package/src/cf-worker/durable-object.ts

@@ -1,14 +1,14 @@
-import { makeColumnSpec } from '@livestore/common'
-import { DbSchema, EventId, type MutationEvent } from '@livestore/common/schema'
+import { makeColumnSpec, UnexpectedError } from '@livestore/common'
+import { EventSequenceNumber, type LiveStoreEvent, State } from '@livestore/common/schema'
 import { shouldNeverHappen } from '@livestore/utils'
 import { Effect, Logger, LogLevel, Option, Schema } from '@livestore/utils/effect'
 import { DurableObject } from 'cloudflare:workers'
 
-import { WSMessage } from '../common/index.js'
+import { WSMessage } from '../common/mod.js'
 import type { SyncMetadata } from '../common/ws-message-types.js'
 
 export interface Env {
-  WEBSOCKET_SERVER: DurableObjectNamespace<WebSocketServer>
+  WEBSOCKET_SERVER: DurableObjectNamespace
   DB: D1Database
   ADMIN_SECRET: string
 }
@@ -19,58 +19,88 @@ const encodeOutgoingMessage = Schema.encodeSync(Schema.parseJson(WSMessage.Backe
 const encodeIncomingMessage = Schema.encodeSync(Schema.parseJson(WSMessage.ClientToBackendMessage))
 const decodeIncomingMessage = Schema.decodeUnknownEither(Schema.parseJson(WSMessage.ClientToBackendMessage))
 
-// NOTE actual table name is determined at runtime by `WebSocketServer.dbName`
-export const mutationLogTable = DbSchema.table('__unused', {
-  id: DbSchema.integer({ primaryKey: true, schema: EventId.GlobalEventId }),
-  parentId: DbSchema.integer({ schema: EventId.GlobalEventId }),
-  mutation: DbSchema.text({}),
-  args: DbSchema.text({ schema: Schema.parseJson(Schema.Any) }),
-  /** ISO date format. Currently only used for debugging purposes. */
-  createdAt: DbSchema.text({}),
+export const eventlogTable = State.SQLite.table({
+  // NOTE actual table name is determined at runtime
+  name: 'eventlog_${PERSISTENCE_FORMAT_VERSION}_${storeId}',
+  columns: {
+    seqNum: State.SQLite.integer({ primaryKey: true, schema: EventSequenceNumber.GlobalEventSequenceNumber }),
+    parentSeqNum: State.SQLite.integer({ schema: EventSequenceNumber.GlobalEventSequenceNumber }),
+    name: State.SQLite.text({}),
+    args: State.SQLite.text({ schema: Schema.parseJson(Schema.Any), nullable: true }),
+    /** ISO date format. Currently only used for debugging purposes. */
+    createdAt: State.SQLite.text({}),
+    clientId: State.SQLite.text({}),
+    sessionId: State.SQLite.text({}),
+  },
 })
 
+const WebSocketAttachmentSchema = Schema.parseJson(
+  Schema.Struct({
+    storeId: Schema.String,
+  }),
+)
+
+export const PULL_CHUNK_SIZE = 100
+
 /**
- * Needs to be bumped when the storage format changes (e.g. mutationLogTable schema changes)
+ * Needs to be bumped when the storage format changes (e.g. eventlogTable schema changes)
  *
  * Changing this version number will lead to a "soft reset".
  */
-const PERSISTENCE_FORMAT_VERSION = 2
+export const PERSISTENCE_FORMAT_VERSION = 6
 
-// Durable Object
-export class WebSocketServer extends DurableObject<Env> {
-  dbName = `mutation_log_${PERSISTENCE_FORMAT_VERSION}_${this.ctx.id.toString()}`
-  storage = makeStorage(this.ctx, this.env, this.dbName)
+export type MakeDurableObjectClassOptions = {
+  onPush?: (message: WSMessage.PushReq) => Effect.Effect<void> | Promise<void>
+  onPushRes?: (message: WSMessage.PushAck | WSMessage.Error) => Effect.Effect<void> | Promise<void>
+  onPull?: (message: WSMessage.PullReq) => Effect.Effect<void> | Promise<void>
+  onPullRes?: (message: WSMessage.PullRes | WSMessage.Error) => Effect.Effect<void> | Promise<void>
+}
 
-  constructor(ctx: DurableObjectState, env: Env) {
-    super(ctx, env)
-  }
+export type MakeDurableObjectClass = (options?: MakeDurableObjectClassOptions) => {
+  new (ctx: DurableObjectState, env: Env): DurableObject<Env>
+}
 
-  fetch = async (_request: Request) =>
-    Effect.gen(this, function* () {
-      const { 0: client, 1: server } = new WebSocketPair()
+export const makeDurableObject: MakeDurableObjectClass = (options) => {
+  return class WebSocketServerBase extends DurableObject<Env> {
+    /** Needed to prevent concurrent pushes */
+    private pushSemaphore = Effect.makeSemaphore(1).pipe(Effect.runSync)
 
-      // See https://developers.cloudflare.com/durable-objects/examples/websocket-hibernation-server
+    constructor(ctx: DurableObjectState, env: Env) {
+      super(ctx, env)
+    }
 
-      this.ctx.acceptWebSocket(server)
+    fetch = async (request: Request) =>
+      Effect.gen(this, function* () {
+        const storeId = getStoreId(request)
+        const storage = makeStorage(this.ctx, this.env, storeId)
 
-      this.ctx.setWebSocketAutoResponse(
-        new WebSocketRequestResponsePair(
-          encodeIncomingMessage(WSMessage.Ping.make({ requestId: 'ping' })),
-          encodeOutgoingMessage(WSMessage.Pong.make({ requestId: 'ping' })),
-        ),
-      )
+        const { 0: client, 1: server } = new WebSocketPair()
+
+        // Since we're using websocket hibernation, we need to remember the storeId for subsequent `webSocketMessage` calls
+        server.serializeAttachment(Schema.encodeSync(WebSocketAttachmentSchema)({ storeId }))
+
+        // See https://developers.cloudflare.com/durable-objects/examples/websocket-hibernation-server
 
-      const colSpec = makeColumnSpec(mutationLogTable.sqliteDef.ast)
-      this.env.DB.exec(`CREATE TABLE IF NOT EXISTS ${this.dbName} (${colSpec}) strict`)
+        this.ctx.acceptWebSocket(server)
 
-      return new Response(null, {
-        status: 101,
-        webSocket: client,
-      })
-    }).pipe(Effect.tapCauseLogPretty, Effect.runPromise)
+        this.ctx.setWebSocketAutoResponse(
+          new WebSocketRequestResponsePair(
+            encodeIncomingMessage(WSMessage.Ping.make({ requestId: 'ping' })),
+            encodeOutgoingMessage(WSMessage.Pong.make({ requestId: 'ping' })),
+          ),
+        )
 
-  webSocketMessage = (ws: WebSocketClient, message: ArrayBuffer | string) =>
-    Effect.gen(this, function* () {
+        const colSpec = makeColumnSpec(eventlogTable.sqliteDef.ast)
+        this.env.DB.exec(`CREATE TABLE IF NOT EXISTS ${storage.dbName} (${colSpec}) strict`)
+
+        return new Response(null, {
+          status: 101,
+          webSocket: client,
+        })
+      }).pipe(Effect.tapCauseLogPretty, Effect.runPromise)
+
+    webSocketMessage = (ws: WebSocketClient, message: ArrayBuffer | string) => {
+      console.log('webSocketMessage', message)
       const decodedMessageRes = decodeIncomingMessage(message)
 
       if (decodedMessageRes._tag === 'Left') {
@@ -81,175 +111,291 @@ export class WebSocketServer extends DurableObject<Env> {
       const decodedMessage = decodedMessageRes.right
       const requestId = decodedMessage.requestId
 
-      try {
-        switch (decodedMessage._tag) {
-          case 'WSMessage.PullReq': {
-            const cursor = decodedMessage.cursor
-            const CHUNK_SIZE = 100
+      return Effect.gen(this, function* () {
+        const { storeId } = yield* Schema.decode(WebSocketAttachmentSchema)(ws.deserializeAttachment())
+        const storage = makeStorage(this.ctx, this.env, storeId)
 
-            // TODO use streaming
-            const remainingEvents = [...(yield* Effect.promise(() => this.storage.getEvents(cursor)))]
+        try {
+          switch (decodedMessage._tag) {
+            // TODO allow pulling concurrently to not block incoming push requests
+            case 'WSMessage.PullReq': {
+              if (options?.onPull) {
+                yield* Effect.tryAll(() => options.onPull!(decodedMessage))
+              }
 
-            // NOTE we want to make sure the WS server responds at least once with `InitRes` even if `events` is empty
-            while (true) {
-              const events = remainingEvents.splice(0, CHUNK_SIZE)
+              const respond = (message: WSMessage.PullRes) =>
+                Effect.gen(function* () {
+                  if (options?.onPullRes) {
+                    yield* Effect.tryAll(() => options.onPullRes!(message))
+                  }
+                  ws.send(encodeOutgoingMessage(message))
+                })
 
-              ws.send(
-                encodeOutgoingMessage(WSMessage.PullRes.make({ events, remaining: remainingEvents.length, requestId })),
-              )
+              const cursor = decodedMessage.cursor
+
+              // TODO use streaming
+              const remainingEvents = yield* storage.getEvents(cursor)
 
-              if (remainingEvents.length === 0) {
-                break
+              // Send at least one response, even if there are no events
+              const batches =
+                remainingEvents.length === 0
+                  ? [[]]
+                  : Array.from({ length: Math.ceil(remainingEvents.length / PULL_CHUNK_SIZE) }, (_, i) =>
+                      remainingEvents.slice(i * PULL_CHUNK_SIZE, (i + 1) * PULL_CHUNK_SIZE),
+                    )
+
+              for (const [index, batch] of batches.entries()) {
+                const remaining = Math.max(0, remainingEvents.length - (index + 1) * PULL_CHUNK_SIZE)
+                yield* respond(WSMessage.PullRes.make({ batch, remaining, requestId: { context: 'pull', requestId } }))
               }
+
+              break
             }
+            case 'WSMessage.PushReq': {
+              const respond = (message: WSMessage.PushAck | WSMessage.Error) =>
+                Effect.gen(function* () {
+                  if (options?.onPushRes) {
+                    yield* Effect.tryAll(() => options.onPushRes!(message))
+                  }
+                  ws.send(encodeOutgoingMessage(message))
+                })
 
-            break
-          }
-          case 'WSMessage.PushReq': {
-            // TODO check whether we could use the Durable Object storage for this to speed up the lookup
-            const latestEvent = yield* Effect.promise(() => this.storage.getLatestEvent())
-            const expectedParentId = latestEvent?.id ?? EventId.ROOT.global
-
-            let i = 0
-            for (const mutationEventEncoded of decodedMessage.batch) {
-              if (mutationEventEncoded.parentId !== expectedParentId + i) {
+              if (decodedMessage.batch.length === 0) {
+                yield* respond(WSMessage.PushAck.make({ requestId }))
+                return
+              }
+
+              yield* this.pushSemaphore.take(1)
+
+              if (options?.onPush) {
+                yield* Effect.tryAll(() => options.onPush!(decodedMessage))
+              }
+
+              // TODO check whether we could use the Durable Object storage for this to speed up the lookup
+              const expectedParentNum = yield* storage.getHead
+
+              // TODO handle clientId unique conflict
+              // Validate the batch
+              const firstEvent = decodedMessage.batch[0]!
+              if (firstEvent.parentSeqNum !== expectedParentNum) {
                 const err = WSMessage.Error.make({
-                  message: `Invalid parent id. Received ${mutationEventEncoded.parentId} but expected ${expectedParentId}`,
+                  message: `Invalid parent event number. Received e${firstEvent.parentSeqNum} but expected e${expectedParentNum}`,
                   requestId,
                 })
 
-                yield* Effect.fail(err).pipe(Effect.ignoreLogged)
+                yield* Effect.logError(err)
 
-                ws.send(encodeOutgoingMessage(err))
+                yield* respond(err)
+                yield* this.pushSemaphore.release(1)
                 return
               }
 
-              // TODO handle clientId unique conflict
-
-              const createdAt = new Date().toISOString()
+              yield* respond(WSMessage.PushAck.make({ requestId }))
 
-              // NOTE we're currently not blocking on this to allow broadcasting right away
-              const storePromise = this.storage.appendEvent(mutationEventEncoded, createdAt)
+              yield* this.pushSemaphore.release(1)
 
-              ws.send(encodeOutgoingMessage(WSMessage.PushAck.make({ mutationId: mutationEventEncoded.id, requestId })))
+              const createdAt = new Date().toISOString()
 
-              // console.debug(`Broadcasting mutation event to ${this.subscribedWebSockets.size} clients`)
+              // NOTE we're not waiting for this to complete yet to allow the broadcast to happen right away
+              // while letting the async storage write happen in the background
+              const storeFiber = yield* storage.appendEvents(decodedMessage.batch, createdAt).pipe(Effect.fork)
 
               const connectedClients = this.ctx.getWebSockets()
 
+              // console.debug(`Broadcasting push batch to ${this.subscribedWebSockets.size} clients`)
               if (connectedClients.length > 0) {
-                const broadcastMessage = encodeOutgoingMessage(
-                  // TODO refactor to batch api
-                  WSMessage.PushBroadcast.make({
-                    mutationEventEncoded,
+                // TODO refactor to batch api
+                const pullRes = WSMessage.PullRes.make({
+                  batch: decodedMessage.batch.map((eventEncoded) => ({
+                    eventEncoded,
                     metadata: Option.some({ createdAt }),
-                  }),
-                )
+                  })),
+                  remaining: 0,
+                  requestId: { context: 'push', requestId },
+                })
+                const pullResEnc = encodeOutgoingMessage(pullRes)
 
+                // Only calling once for now.
+                if (options?.onPullRes) {
+                  yield* Effect.tryAll(() => options.onPullRes!(pullRes))
+                }
+
+                // NOTE we're also sending the pullRes to the pushing ws client as a confirmation
                 for (const conn of connectedClients) {
-                  console.log('Broadcasting to client', conn === ws ? 'self' : 'other')
-                  // if (conn !== ws) {
-                  conn.send(broadcastMessage)
-                  // }
+                  conn.send(pullResEnc)
                 }
               }
 
-              yield* Effect.promise(() => storePromise)
-
-              i++
-            }
+              // Wait for the storage write to complete before finishing this request
+              yield* storeFiber
 
-            break
-          }
-          case 'WSMessage.AdminResetRoomReq': {
-            if (decodedMessage.adminSecret !== this.env.ADMIN_SECRET) {
-              ws.send(encodeOutgoingMessage(WSMessage.Error.make({ message: 'Invalid admin secret', requestId })))
-              return
+              break
             }
+            case 'WSMessage.AdminResetRoomReq': {
+              if (decodedMessage.adminSecret !== this.env.ADMIN_SECRET) {
+                ws.send(encodeOutgoingMessage(WSMessage.Error.make({ message: 'Invalid admin secret', requestId })))
+                return
+              }
 
-            yield* Effect.promise(() => this.storage.resetRoom())
-            ws.send(encodeOutgoingMessage(WSMessage.AdminResetRoomRes.make({ requestId })))
+              yield* storage.resetStore
+              ws.send(encodeOutgoingMessage(WSMessage.AdminResetRoomRes.make({ requestId })))
 
-            break
-          }
-          case 'WSMessage.AdminInfoReq': {
-            if (decodedMessage.adminSecret !== this.env.ADMIN_SECRET) {
-              ws.send(encodeOutgoingMessage(WSMessage.Error.make({ message: 'Invalid admin secret', requestId })))
-              return
+              break
             }
+            case 'WSMessage.AdminInfoReq': {
+              if (decodedMessage.adminSecret !== this.env.ADMIN_SECRET) {
+                ws.send(encodeOutgoingMessage(WSMessage.Error.make({ message: 'Invalid admin secret', requestId })))
+                return
+              }
 
-            ws.send(
-              encodeOutgoingMessage(
-                WSMessage.AdminInfoRes.make({ requestId, info: { durableObjectId: this.ctx.id.toString() } }),
-              ),
-            )
+              ws.send(
+                encodeOutgoingMessage(
+                  WSMessage.AdminInfoRes.make({ requestId, info: { durableObjectId: this.ctx.id.toString() } }),
+                ),
+              )
 
-            break
-          }
-          default: {
-            console.error('unsupported message', decodedMessage)
-            return shouldNeverHappen()
+              break
+            }
+            default: {
+              console.error('unsupported message', decodedMessage)
+              return shouldNeverHappen()
+            }
           }
+        } catch (error: any) {
+          ws.send(encodeOutgoingMessage(WSMessage.Error.make({ message: error.message, requestId })))
         }
-      } catch (error: any) {
-        ws.send(encodeOutgoingMessage(WSMessage.Error.make({ message: error.message, requestId })))
-      }
-    }).pipe(
-      Effect.withSpan('@livestore/sync-cf:durable-object:webSocketMessage'),
-      Effect.tapCauseLogPretty,
-      Logger.withMinimumLogLevel(LogLevel.Debug),
-      Effect.provide(Logger.pretty),
-      Effect.runPromise,
-    )
+      }).pipe(
+        Effect.withSpan(`@livestore/sync-cf:durable-object:webSocketMessage:${decodedMessage._tag}`, {
+          attributes: { requestId },
+        }),
+        Effect.tapCauseLogPretty,
+        Effect.tapErrorCause((cause) =>
+          Effect.sync(() =>
+            ws.send(encodeOutgoingMessage(WSMessage.Error.make({ message: cause.toString(), requestId }))),
+          ),
+        ),
+        Logger.withMinimumLogLevel(LogLevel.Debug),
+        Effect.provide(Logger.prettyWithThread('durable-object')),
+        Effect.runPromise,
+      )
+    }
 
-  webSocketClose = async (ws: WebSocketClient, code: number, _reason: string, _wasClean: boolean) => {
-    // If the client closes the connection, the runtime will invoke the webSocketClose() handler.
-    ws.close(code, 'Durable Object is closing WebSocket')
+    webSocketClose = async (ws: WebSocketClient, code: number, _reason: string, _wasClean: boolean) => {
+      // If the client closes the connection, the runtime will invoke the webSocketClose() handler.
+      ws.close(code, 'Durable Object is closing WebSocket')
+    }
   }
 }
 
-const makeStorage = (ctx: DurableObjectState, env: Env, dbName: string) => {
-  const getLatestEvent = async (): Promise<MutationEvent.AnyEncodedGlobal | undefined> => {
-    const rawEvents = await env.DB.prepare(`SELECT * FROM ${dbName} ORDER BY id DESC LIMIT 1`).all()
-    if (rawEvents.error) {
-      throw new Error(rawEvents.error)
-    }
-    const events = Schema.decodeUnknownSync(Schema.Array(mutationLogTable.schema))(rawEvents.results)
+type SyncStorage = {
+  dbName: string
+  getHead: Effect.Effect<EventSequenceNumber.GlobalEventSequenceNumber, UnexpectedError>
+  getEvents: (
+    cursor: number | undefined,
+  ) => Effect.Effect<
+    ReadonlyArray<{ eventEncoded: LiveStoreEvent.AnyEncodedGlobal; metadata: Option.Option<SyncMetadata> }>,
+    UnexpectedError
+  >
+  appendEvents: (
+    batch: ReadonlyArray<LiveStoreEvent.AnyEncodedGlobal>,
+    createdAt: string,
+  ) => Effect.Effect<void, UnexpectedError>
+  resetStore: Effect.Effect<void, UnexpectedError>
+}
 
-    return events[0]
-  }
+const makeStorage = (ctx: DurableObjectState, env: Env, storeId: string): SyncStorage => {
+  const dbName = `eventlog_${PERSISTENCE_FORMAT_VERSION}_${toValidTableName(storeId)}`
 
-  const getEvents = async (
-    cursor: number | undefined,
-  ): Promise<
-    ReadonlyArray<{ mutationEventEncoded: MutationEvent.AnyEncodedGlobal; metadata: Option.Option<SyncMetadata> }>
-  > => {
-    const whereClause = cursor === undefined ? '' : `WHERE id > ${cursor}`
-    const sql = `SELECT * FROM ${dbName} ${whereClause} ORDER BY id ASC`
-    // TODO handle case where `cursor` was not found
-    const rawEvents = await env.DB.prepare(sql).all()
-    if (rawEvents.error) {
-      throw new Error(rawEvents.error)
-    }
-    const events = Schema.decodeUnknownSync(Schema.Array(mutationLogTable.schema))(rawEvents.results).map(
-      ({ createdAt, ...mutationEventEncoded }) => ({
-        mutationEventEncoded,
-        metadata: Option.some({ createdAt }),
-      }),
+  const execDb = <T>(cb: (db: D1Database) => Promise<D1Result<T>>) =>
+    Effect.tryPromise({
+      try: () => cb(env.DB),
+      catch: (error) => new UnexpectedError({ cause: error, payload: { dbName } }),
+    }).pipe(
+      Effect.map((_) => _.results),
+      Effect.withSpan('@livestore/sync-cf:durable-object:execDb'),
     )
-    return events
-  }
 
-  const appendEvent = async (event: MutationEvent.AnyEncodedGlobal, createdAt: string) => {
-    const sql = `INSERT INTO ${dbName} (id, parentId, args, mutation, createdAt) VALUES (?, ?, ?, ?, ?)`
-    await env.DB.prepare(sql)
-      .bind(event.id, event.parentId, JSON.stringify(event.args), event.mutation, createdAt)
-      .run()
-  }
+  const getHead: Effect.Effect<EventSequenceNumber.GlobalEventSequenceNumber, UnexpectedError> = Effect.gen(
+    function* () {
+      const result = yield* execDb<{ seqNum: EventSequenceNumber.GlobalEventSequenceNumber }>((db) =>
+        db.prepare(`SELECT seqNum FROM ${dbName} ORDER BY seqNum DESC LIMIT 1`).all(),
+      )
 
-  const resetRoom = async () => {
-    await ctx.storage.deleteAll()
-  }
+      return result[0]?.seqNum ?? EventSequenceNumber.ROOT.global
+    },
+  ).pipe(UnexpectedError.mapToUnexpectedError)
 
-  return { getLatestEvent, getEvents, appendEvent, resetRoom }
+  const getEvents = (
+    cursor: number | undefined,
+  ): Effect.Effect<
+    ReadonlyArray<{ eventEncoded: LiveStoreEvent.AnyEncodedGlobal; metadata: Option.Option<SyncMetadata> }>,
+    UnexpectedError
+  > =>
+    Effect.gen(function* () {
+      const whereClause = cursor === undefined ? '' : `WHERE seqNum > ${cursor}`
+      const sql = `SELECT * FROM ${dbName} ${whereClause} ORDER BY seqNum ASC`
+      // TODO handle case where `cursor` was not found
+      const rawEvents = yield* execDb((db) => db.prepare(sql).all())
+      const events = Schema.decodeUnknownSync(Schema.Array(eventlogTable.rowSchema))(rawEvents).map(
+        ({ createdAt, ...eventEncoded }) => ({
+          eventEncoded,
+          metadata: Option.some({ createdAt }),
+        }),
+      )
+      return events
+    }).pipe(UnexpectedError.mapToUnexpectedError)
+
+  const appendEvents: SyncStorage['appendEvents'] = (batch, createdAt) =>
+    Effect.gen(function* () {
+      // If there are no events, do nothing.
+      if (batch.length === 0) return
+
+      // CF D1 limits:
+      // Maximum bound parameters per query	100, Maximum arguments per SQL function	32
+      // Thus we need to split the batch into chunks of max (100/7=)14 events each.
+      const CHUNK_SIZE = 14
+
+      for (let i = 0; i < batch.length; i += CHUNK_SIZE) {
+        const chunk = batch.slice(i, i + CHUNK_SIZE)
+
+        // Create a list of placeholders ("(?, ?, ?, ?, ?, ?, ?)"), corresponding to each event.
+        const valuesPlaceholders = chunk.map(() => '(?, ?, ?, ?, ?, ?, ?)').join(', ')
+        const sql = `INSERT INTO ${dbName} (seqNum, parentSeqNum, args, name, createdAt, clientId, sessionId) VALUES ${valuesPlaceholders}`
+        // Flatten the event properties into a parameters array.
+        const params = chunk.flatMap((event) => [
+          event.seqNum,
+          event.parentSeqNum,
+          event.args === undefined ? null : JSON.stringify(event.args),
+          event.name,
+          createdAt,
+          event.clientId,
+          event.sessionId,
+        ])
+
+        yield* execDb((db) =>
+          db
+            .prepare(sql)
+            .bind(...params)
+            .run(),
+        )
+      }
+    }).pipe(UnexpectedError.mapToUnexpectedError)
+
+  const resetStore = Effect.gen(function* () {
+    yield* Effect.promise(() => ctx.storage.deleteAll())
+  }).pipe(UnexpectedError.mapToUnexpectedError)
+
+  return { dbName, getHead, getEvents, appendEvents, resetStore }
 }
+
+const getStoreId = (request: Request) => {
+  const url = new URL(request.url)
+  const searchParams = url.searchParams
+  const storeId = searchParams.get('storeId')
+  if (storeId === null) {
+    throw new Error('storeId search param is required')
+  }
+  return storeId
+}
+
+const toValidTableName = (str: string) => str.replaceAll(/[^a-zA-Z0-9]/g, '_')

package/src/cf-worker/mod.ts

@@ -0,0 +1,2 @@
+export * from './durable-object.js'
+export * from './worker.js'

package/src/cf-worker/worker.ts

@@ -0,0 +1,85 @@
+import { UnexpectedError } from '@livestore/common'
+import type { Schema } from '@livestore/utils/effect'
+import { Effect, UrlParams } from '@livestore/utils/effect'
+
+import { SearchParamsSchema } from '../common/mod.js'
+import type { Env } from './durable-object.js'
+
+export type CFWorker = {
+  fetch: (request: Request, env: Env, ctx: ExecutionContext) => Promise<Response>
+}
+
+export type MakeWorkerOptions = {
+  validatePayload?: (payload: Schema.JsonValue | undefined) => void | Promise<void>
+  /** @default false */
+  enableCORS?: boolean
+}
+
+export const makeWorker = (options: MakeWorkerOptions = {}): CFWorker => {
+  return {
+    fetch: async (request, env, _ctx) =>
+      Effect.gen(function* () {
+        const url = new URL(request.url)
+        const urlParams = UrlParams.fromInput(url.searchParams)
+        const paramsResult = yield* UrlParams.schemaStruct(SearchParamsSchema)(urlParams).pipe(Effect.either)
+
+        const corsHeaders: HeadersInit = options.enableCORS
+          ? {
+              'Access-Control-Allow-Origin': '*',
+              'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+              'Access-Control-Allow-Headers': request.headers.get('Access-Control-Request-Headers') ?? '*',
+            }
+          : {}
+
+        if (request.method === 'OPTIONS' && options.enableCORS) {
+          return new Response(null, {
+            status: 204,
+            headers: corsHeaders,
+          })
+        }
+
+        if (paramsResult._tag === 'Left') {
+          return new Response(`Invalid search params: ${paramsResult.left.toString()}`, {
+            status: 500,
+            headers: corsHeaders,
+          })
+        }
+
+        const { storeId, payload } = paramsResult.right
+
+        if (options.validatePayload !== undefined) {
+          const result = yield* Effect.promise(async () => options.validatePayload!(payload)).pipe(
+            UnexpectedError.mapToUnexpectedError,
+            Effect.either,
+          )
+
+          if (result._tag === 'Left') {
+            console.error('Invalid payload', result.left)
+            return new Response(result.left.toString(), { status: 400, headers: corsHeaders })
+          }
+        }
+
+        const id = env.WEBSOCKET_SERVER.idFromName(storeId)
+        const durableObject = env.WEBSOCKET_SERVER.get(id)
+
+        if (url.pathname.endsWith('/websocket')) {
+          const upgradeHeader = request.headers.get('Upgrade')
+          if (!upgradeHeader || upgradeHeader !== 'websocket') {
+            return new Response('Durable Object expected Upgrade: websocket', { status: 426, headers: corsHeaders })
+          }
+
+          return durableObject.fetch(request)
+        }
+
+        console.error('Invalid path', url.pathname)
+        return new Response(null, {
+          status: 400,
+          statusText: 'Bad Request',
+          headers: {
+            ...corsHeaders,
+            'Content-Type': 'text/plain',
+          },
+        })
+      }).pipe(Effect.tapCauseLogPretty, Effect.runPromise),
+  }
+}

package/src/common/mod.ts

@@ -0,0 +1,8 @@
+import { Schema } from '@livestore/utils/effect'
+
+export * as WSMessage from './ws-message-types.js'
+
+export const SearchParamsSchema = Schema.Struct({
+  storeId: Schema.String,
+  payload: Schema.compose(Schema.StringFromUriComponent, Schema.parseJson(Schema.JsonValue)).pipe(Schema.UndefinedOr),
+})