@livestore/sync-cf 0.3.0-dev.1 → 0.3.0-dev.11

package/package.json

@@ -1,33 +1,35 @@
 {
   "name": "@livestore/sync-cf",
-  "version": "0.3.0-dev.1",
+  "version": "0.3.0-dev.11",
   "type": "module",
+  "sideEffects": false,
   "exports": {
     ".": {
-      "types": "./dist/sync-impl/index.d.ts",
-      "default": "./dist/sync-impl/index.js"
+      "types": "./dist/sync-impl/mod.d.ts",
+      "default": "./dist/sync-impl/mod.js"
+    },
+    "./cf-worker": {
+      "types": "./dist/cf-worker/mod.d.ts",
+      "default": "./dist/cf-worker/mod.js"
     }
   },
+  "dependencies": {
+    "@livestore/common": "0.3.0-dev.11",
+    "@livestore/utils": "0.3.0-dev.11"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20241022.0"
+  },
   "files": [
     "dist",
     "src",
     "package.json",
     "README.md"
   ],
-  "dependencies": {
-    "@livestore/common": "0.3.0-dev.1",
-    "@livestore/utils": "0.3.0-dev.1"
-  },
-  "devDependencies": {
-    "@cloudflare/workers-types": "4.20241022.0",
-    "wrangler": "^3.84.0"
-  },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "dev": "wrangler dev --inspector-port 9230",
-    "deploy": "wrangler publish",
     "test": "echo 'No tests yet'"
   }
 }

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

@@ -4,11 +4,11 @@ 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
 }
@@ -21,235 +21,277 @@ const decodeIncomingMessage = Schema.decodeUnknownEither(Schema.parseJson(WSMess
 
 // NOTE actual table name is determined at runtime by `WebSocketServer.dbName`
 export const mutationLogTable = DbSchema.table('__unused', {
-  idGlobal: DbSchema.integer({ primaryKey: true }),
-  parentIdGlobal: DbSchema.integer({}),
+  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 */
+  /** ISO date format. Currently only used for debugging purposes. */
   createdAt: DbSchema.text({}),
 })
 
-// Durable Object
-export class WebSocketServer extends DurableObject<Env> {
-  dbName = `mutation_log_${this.ctx.id.toString()}`
-  storage = makeStorage(this.ctx, this.env, this.dbName)
+const WebSocketAttachmentSchema = Schema.parseJson(
+  Schema.Struct({
+    storeId: Schema.String,
+  }),
+)
+
+/**
+ * Needs to be bumped when the storage format changes (e.g. mutationLogTable schema changes)
+ *
+ * Changing this version number will lead to a "soft reset".
+ */
+export const PERSISTENCE_FORMAT_VERSION = 2
+
+export type MakeDurableObjectClassOptions = {
+  onPush?: (message: WSMessage.PushReq) => Effect.Effect<void> | Promise<void>
+  onPull?: (message: WSMessage.PullReq) => 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> {
+    constructor(ctx: DurableObjectState, env: Env) {
+      super(ctx, env)
+    }
 
-      // See https://developers.cloudflare.com/durable-objects/examples/websocket-hibernation-server
+    fetch = async (request: Request) =>
+      Effect.gen(this, function* () {
+        const storeId = getStoreId(request)
+        const storage = makeStorage(this.ctx, this.env, storeId)
 
-      this.ctx.acceptWebSocket(server)
+        const { 0: client, 1: server } = new WebSocketPair()
 
-      this.ctx.setWebSocketAutoResponse(
-        new WebSocketRequestResponsePair(
-          encodeIncomingMessage(WSMessage.Ping.make({ requestId: 'ping' })),
-          encodeOutgoingMessage(WSMessage.Pong.make({ requestId: 'ping' })),
-        ),
-      )
+        // Since we're using websocket hibernation, we need to remember the storeId for subsequent `webSocketMessage` calls
+        server.serializeAttachment(Schema.encodeSync(WebSocketAttachmentSchema)({ storeId }))
 
-      const colSpec = makeColumnSpec(mutationLogTable.sqliteDef.ast)
-      this.env.DB.exec(`CREATE TABLE IF NOT EXISTS ${this.dbName} (${colSpec}) strict`)
+        // See https://developers.cloudflare.com/durable-objects/examples/websocket-hibernation-server
 
-      return new Response(null, {
-        status: 101,
-        webSocket: client,
-      })
-    }).pipe(Effect.tapCauseLogPretty, Effect.runPromise)
+        this.ctx.acceptWebSocket(server)
 
-  webSocketMessage = (ws: WebSocketClient, message: ArrayBuffer | string) =>
-    Effect.gen(this, function* () {
-      const decodedMessageRes = decodeIncomingMessage(message)
+        this.ctx.setWebSocketAutoResponse(
+          new WebSocketRequestResponsePair(
+            encodeIncomingMessage(WSMessage.Ping.make({ requestId: 'ping' })),
+            encodeOutgoingMessage(WSMessage.Pong.make({ requestId: 'ping' })),
+          ),
+        )
 
-      if (decodedMessageRes._tag === 'Left') {
-        console.error('Invalid message received', decodedMessageRes.left)
-        return
-      }
+        const colSpec = makeColumnSpec(mutationLogTable.sqliteDef.ast)
+        this.env.DB.exec(`CREATE TABLE IF NOT EXISTS ${storage.dbName} (${colSpec}) strict`)
 
-      const decodedMessage = decodedMessageRes.right
-      const requestId = decodedMessage.requestId
+        return new Response(null, {
+          status: 101,
+          webSocket: client,
+        })
+      }).pipe(Effect.tapCauseLogPretty, Effect.runPromise)
 
-      try {
-        switch (decodedMessage._tag) {
-          case 'WSMessage.PullReq': {
-            const cursor = decodedMessage.cursor
-            const CHUNK_SIZE = 100
+    webSocketMessage = (ws: WebSocketClient, message: ArrayBuffer | string) =>
+      Effect.gen(this, function* () {
+        const decodedMessageRes = decodeIncomingMessage(message)
 
-            // TODO use streaming
-            const remainingEvents = [...(yield* Effect.promise(() => this.storage.getEvents(cursor)))]
+        if (decodedMessageRes._tag === 'Left') {
+          console.error('Invalid message received', decodedMessageRes.left)
+          return
+        }
 
-            // 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 { storeId } = yield* Schema.decode(WebSocketAttachmentSchema)(ws.deserializeAttachment())
+        const storage = makeStorage(this.ctx, this.env, storeId)
 
-              ws.send(
-                encodeOutgoingMessage(WSMessage.PullRes.make({ events, remaining: remainingEvents.length, requestId })),
-              )
+        const decodedMessage = decodedMessageRes.right
+        const requestId = decodedMessage.requestId
 
-              if (remainingEvents.length === 0) {
-                break
+        try {
+          switch (decodedMessage._tag) {
+            case 'WSMessage.PullReq': {
+              if (options?.onPull) {
+                yield* Effect.tryAll(() => options.onPull!(decodedMessage))
               }
-            }
 
-            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
-
-            let i = 0
-            for (const mutationEventEncoded of decodedMessage.batch) {
-              if (mutationEventEncoded.parentId.global !== expectedParentId.global + i) {
-                const err = WSMessage.Error.make({
-                  message: `Invalid parent id. Received ${mutationEventEncoded.parentId.global} but expected ${expectedParentId.global}`,
-                  requestId,
-                })
-
-                yield* Effect.fail(err).pipe(Effect.ignoreLogged)
-
-                ws.send(encodeOutgoingMessage(err))
-                return
+              const cursor = decodedMessage.cursor
+              const CHUNK_SIZE = 100
+
+              // TODO use streaming
+              const remainingEvents = [...(yield* Effect.promise(() => storage.getEvents(cursor)))]
+
+              // 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)
+
+                ws.send(
+                  encodeOutgoingMessage(
+                    WSMessage.PullRes.make({ events, remaining: remainingEvents.length, requestId }),
+                  ),
+                )
+
+                if (remainingEvents.length === 0) {
+                  break
+                }
               }
 
-              // TODO handle clientId unique conflict
+              break
+            }
+            case 'WSMessage.PushReq': {
+              if (options?.onPush) {
+                yield* Effect.tryAll(() => options.onPush!(decodedMessage))
+              }
 
-              const createdAt = new Date().toISOString()
+              // TODO check whether we could use the Durable Object storage for this to speed up the lookup
+              const latestEvent = yield* Effect.promise(() => storage.getLatestEvent())
+              const expectedParentId = latestEvent?.id ?? EventId.ROOT.global
 
-              // NOTE we're currently not blocking on this to allow broadcasting right away
-              const storePromise = this.storage.appendEvent(mutationEventEncoded, createdAt)
+              let i = 0
+              for (const mutationEventEncoded of decodedMessage.batch) {
+                if (mutationEventEncoded.parentId !== expectedParentId + i) {
+                  const err = WSMessage.Error.make({
+                    message: `Invalid parent id. Received ${mutationEventEncoded.parentId} but expected ${expectedParentId}`,
+                    requestId,
+                  })
 
-              ws.send(
-                encodeOutgoingMessage(
-                  WSMessage.PushAck.make({ mutationId: mutationEventEncoded.id.global, requestId }),
-                ),
-              )
+                  yield* Effect.fail(err).pipe(Effect.ignoreLogged)
+
+                  ws.send(encodeOutgoingMessage(err))
+                  return
+                }
+
+                // TODO handle clientId unique conflict
 
-              // console.debug(`Broadcasting mutation event to ${this.subscribedWebSockets.size} clients`)
+                const createdAt = new Date().toISOString()
 
-              const connectedClients = this.ctx.getWebSockets()
+                // NOTE we're currently not blocking on this to allow broadcasting right away
+                const storePromise = storage.appendEvent(mutationEventEncoded, createdAt)
 
-              if (connectedClients.length > 0) {
-                const broadcastMessage = encodeOutgoingMessage(
-                  // TODO refactor to batch api
-                  WSMessage.PushBroadcast.make({
-                    mutationEventEncoded,
-                    metadata: Option.some({ createdAt }),
-                  }),
+                ws.send(
+                  encodeOutgoingMessage(WSMessage.PushAck.make({ mutationId: mutationEventEncoded.id, requestId })),
                 )
 
-                for (const conn of connectedClients) {
-                  console.log('Broadcasting to client', conn === ws ? 'self' : 'other')
-                  // if (conn !== ws) {
-                  conn.send(broadcastMessage)
-                  // }
+                // console.debug(`Broadcasting mutation event to ${this.subscribedWebSockets.size} clients`)
+
+                const connectedClients = this.ctx.getWebSockets()
+
+                if (connectedClients.length > 0) {
+                  const broadcastMessage = encodeOutgoingMessage(
+                    // TODO refactor to batch api
+                    WSMessage.PushBroadcast.make({
+                      mutationEventEncoded,
+                      metadata: Option.some({ createdAt }),
+                    }),
+                  )
+
+                  for (const conn of connectedClients) {
+                    console.log('Broadcasting to client', conn === ws ? 'self' : 'other')
+                    // if (conn !== ws) {
+                    conn.send(broadcastMessage)
+                    // }
+                  }
                 }
-              }
 
-              yield* Effect.promise(() => storePromise)
+                yield* Effect.promise(() => storePromise)
 
-              i++
-            }
+                i++
+              }
 
-            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* Effect.promise(() => storage.resetRoom())
+              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'),
+        Effect.tapCauseLogPretty,
+        Logger.withMinimumLogLevel(LogLevel.Debug),
+        Effect.provide(Logger.pretty),
+        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.Any | undefined> => {
-    const rawEvents = await env.DB.prepare(`SELECT * FROM ${dbName} ORDER BY idGlobal DESC LIMIT 1`).all()
+type SyncStorage = {
+  dbName: string
+  getLatestEvent: () => Promise<MutationEvent.AnyEncodedGlobal | undefined>
+  getEvents: (
+    cursor: number | undefined,
+  ) => Promise<
+    ReadonlyArray<{ mutationEventEncoded: MutationEvent.AnyEncodedGlobal; metadata: Option.Option<SyncMetadata> }>
+  >
+  appendEvent: (event: MutationEvent.AnyEncodedGlobal, createdAt: string) => Promise<void>
+  resetRoom: () => Promise<void>
+}
+
+const makeStorage = (ctx: DurableObjectState, env: Env, storeId: string): SyncStorage => {
+  const dbName = `mutation_log_${PERSISTENCE_FORMAT_VERSION}_${toValidTableName(storeId)}`
+
+  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).map((e) => ({
-      ...e,
-      // TODO remove local ids
-      id: { global: e.idGlobal, local: 0 },
-      parentId: { global: e.parentIdGlobal, local: 0 },
-    }))
+    const events = Schema.decodeUnknownSync(Schema.Array(mutationLogTable.schema))(rawEvents.results)
+
     return events[0]
   }
 
   const getEvents = async (
     cursor: number | undefined,
   ): Promise<
-    ReadonlyArray<{ mutationEventEncoded: MutationEvent.AnyEncoded; metadata: Option.Option<SyncMetadata> }>
+    ReadonlyArray<{ mutationEventEncoded: MutationEvent.AnyEncodedGlobal; metadata: Option.Option<SyncMetadata> }>
   > => {
-    const whereClause = cursor === undefined ? '' : `WHERE idGlobal > ${cursor}`
-    const sql = `SELECT * FROM ${dbName} ${whereClause} ORDER BY idGlobal ASC`
+    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, ...e }) => ({
-        mutationEventEncoded: {
-          ...e,
-          // TODO remove local ids
-          id: { global: e.idGlobal, local: 0 },
-          parentId: { global: e.parentIdGlobal, local: 0 },
-        },
+      ({ createdAt, ...mutationEventEncoded }) => ({
+        mutationEventEncoded,
         metadata: Option.some({ createdAt }),
       }),
     )
     return events
   }
 
-  const appendEvent = async (event: MutationEvent.Any, createdAt: string) => {
-    const sql = `INSERT INTO ${dbName} (idGlobal, parentIdGlobal, args, mutation, createdAt) VALUES (?, ?, ?, ?, ?)`
+  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.global, event.parentId.global, JSON.stringify(event.args), event.mutation, createdAt)
+      .bind(event.id, event.parentId, JSON.stringify(event.args), event.mutation, createdAt)
       .run()
   }
 
@@ -257,5 +299,17 @@ const makeStorage = (ctx: DurableObjectState, env: Env, dbName: string) => {
     await ctx.storage.deleteAll()
   }
 
-  return { getLatestEvent, getEvents, appendEvent, resetRoom }
+  return { dbName, getLatestEvent, getEvents, appendEvent, resetRoom }
+}
+
+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,39 @@
+import type { Env } from './durable-object.js'
+
+export type CFWorker = {
+  fetch: (request: Request, env: Env, ctx: ExecutionContext) => Promise<Response>
+}
+
+export const makeWorker = (): CFWorker => {
+  return {
+    fetch: async (request, env, _ctx) => {
+      const url = new URL(request.url)
+      const searchParams = url.searchParams
+      const storeId = searchParams.get('storeId')
+
+      if (storeId === null) {
+        return new Response('storeId search param is required', { status: 400 })
+      }
+
+      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 })
+        }
+
+        return durableObject.fetch(request)
+      }
+
+      return new Response(null, {
+        status: 400,
+        statusText: 'Bad Request',
+        headers: {
+          'Content-Type': 'text/plain',
+        },
+      })
+    },
+  }
+}

package/src/common/ws-message-types.ts

@@ -20,7 +20,7 @@ export const PullRes = Schema.TaggedStruct('WSMessage.PullRes', {
   requestId: Schema.String,
   events: Schema.Array(
     Schema.Struct({
-      mutationEventEncoded: MutationEvent.EncodedAny,
+      mutationEventEncoded: MutationEvent.AnyEncodedGlobal,
       metadata: Schema.Option(SyncMetadata),
     }),
   ),
@@ -30,7 +30,7 @@ export const PullRes = Schema.TaggedStruct('WSMessage.PullRes', {
 export type PullRes = typeof PullRes.Type
 
 export const PushBroadcast = Schema.TaggedStruct('WSMessage.PushBroadcast', {
-  mutationEventEncoded: MutationEvent.EncodedAny,
+  mutationEventEncoded: MutationEvent.AnyEncodedGlobal,
   metadata: Schema.Option(SyncMetadata),
 })
 
@@ -38,7 +38,7 @@ export type PushBroadcast = typeof PushBroadcast.Type
 
 export const PushReq = Schema.TaggedStruct('WSMessage.PushReq', {
   requestId: Schema.String,
-  batch: Schema.Array(MutationEvent.EncodedAny),
+  batch: Schema.Array(MutationEvent.AnyEncodedGlobal),
 })
 
 export type PushReq = typeof PushReq.Type

package/src/sync-impl/ws-impl.ts

@@ -1,6 +1,6 @@
 /// <reference lib="dom" />
 
-import type { SyncBackend, SyncBackendOptionsBase } from '@livestore/common'
+import type { SyncBackend } from '@livestore/common'
 import { InvalidPullError, InvalidPushError } from '@livestore/common'
 import { pick } from '@livestore/utils'
 import type { Scope } from '@livestore/utils/effect'
@@ -18,26 +18,18 @@ import {
 } from '@livestore/utils/effect'
 import { nanoid } from '@livestore/utils/nanoid'
 
-import { WSMessage } from '../common/index.js'
+import { WSMessage } from '../common/mod.js'
 import type { SyncMetadata } from '../common/ws-message-types.js'
 
-export interface WsSyncOptions extends SyncBackendOptionsBase {
-  type: 'cf'
+export interface WsSyncOptions {
   url: string
-  roomId: string
-}
-
-interface LiveStoreGlobalCf {
-  syncBackend: WsSyncOptions
-}
-
-declare global {
-  interface LiveStoreGlobal extends LiveStoreGlobalCf {}
+  storeId: string
 }
 
 export const makeWsSync = (options: WsSyncOptions): Effect.Effect<SyncBackend<SyncMetadata>, never, Scope.Scope> =>
   Effect.gen(function* () {
-    const wsUrl = `${options.url}/websocket?room=${options.roomId}`
+    // TODO also allow for auth scenarios
+    const wsUrl = `${options.url}/websocket?storeId=${options.storeId}`
 
     const { isConnected, incomingMessages, send } = yield* connect(wsUrl)
 
@@ -127,8 +119,8 @@ const connect = (wsUrl: string) =>
           `Sending message: ${message._tag}`,
           message._tag === 'WSMessage.PushReq'
             ? {
-                id: message.batch[0]!.id.global,
-                parentId: message.batch[0]!.parentId.global,
+                id: message.batch[0]!.id,
+                parentId: message.batch[0]!.parentId,
                 batchLength: message.batch.length,
               }
             : message._tag === 'WSMessage.PullReq'