@livestore/sync-cf 0.3.0-dev.10 → 0.3.0-dev.2

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/mod.js'
+import { WSMessage } from '../common/index.js'
 import type { SyncMetadata } from '../common/ws-message-types.js'
 
 export interface Env {
-  WEBSOCKET_SERVER: DurableObjectNamespace
+  WEBSOCKET_SERVER: DurableObjectNamespace<WebSocketServer>
   DB: D1Database
   ADMIN_SECRET: string
 }
@@ -21,274 +21,235 @@ const decodeIncomingMessage = Schema.decodeUnknownEither(Schema.parseJson(WSMess
 
 // 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 }),
+  idGlobal: DbSchema.integer({ primaryKey: true }),
+  parentIdGlobal: DbSchema.integer({}),
   mutation: DbSchema.text({}),
   args: DbSchema.text({ schema: Schema.parseJson(Schema.Any) }),
-  /** ISO date format. Currently only used for debugging purposes. */
+  /** ISO date format */
   createdAt: DbSchema.text({}),
 })
 
-/**
- * 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
+// Durable Object
+export class WebSocketServer extends DurableObject<Env> {
+  dbName = `mutation_log_${this.ctx.id.toString()}`
+  storage = makeStorage(this.ctx, this.env, this.dbName)
 
-export type MakeDurableObjectClassOptions = {
-  onPush?: (message: WSMessage.PushReq) => Effect.Effect<void> | Promise<void>
-  onPull?: (message: WSMessage.PullReq) => Effect.Effect<void> | Promise<void>
-}
-
-export type MakeDurableObjectClass = (options?: MakeDurableObjectClassOptions) => {
-  new (ctx: DurableObjectState, env: Env): DurableObject<Env>
-}
-
-export const makeDurableObject: MakeDurableObjectClass = (options) => {
-  return class WebSocketServerBase extends DurableObject<Env> {
-    storage: SyncStorage | undefined = undefined
-
-    constructor(ctx: DurableObjectState, env: Env) {
-      super(ctx, env)
-    }
-
-    fetch = async (request: Request) =>
-      Effect.gen(this, function* () {
-        if (this.storage === undefined) {
-          const storeId = getStoreId(request)
-          const dbName = `mutation_log_${PERSISTENCE_FORMAT_VERSION}_${toValidTableName(storeId)}`
-          this.storage = makeStorage(this.ctx, this.env, dbName)
-        }
-
-        const { 0: client, 1: server } = new WebSocketPair()
+  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 { 0: client, 1: server } = new WebSocketPair()
 
-        this.ctx.acceptWebSocket(server)
+      // See https://developers.cloudflare.com/durable-objects/examples/websocket-hibernation-server
 
-        this.ctx.setWebSocketAutoResponse(
-          new WebSocketRequestResponsePair(
-            encodeIncomingMessage(WSMessage.Ping.make({ requestId: 'ping' })),
-            encodeOutgoingMessage(WSMessage.Pong.make({ requestId: 'ping' })),
-          ),
-        )
+      this.ctx.acceptWebSocket(server)
 
-        const colSpec = makeColumnSpec(mutationLogTable.sqliteDef.ast)
-        this.env.DB.exec(`CREATE TABLE IF NOT EXISTS ${this.storage.dbName} (${colSpec}) strict`)
+      this.ctx.setWebSocketAutoResponse(
+        new WebSocketRequestResponsePair(
+          encodeIncomingMessage(WSMessage.Ping.make({ requestId: 'ping' })),
+          encodeOutgoingMessage(WSMessage.Pong.make({ requestId: 'ping' })),
+        ),
+      )
 
-        return new Response(null, {
-          status: 101,
-          webSocket: client,
-        })
-      }).pipe(Effect.tapCauseLogPretty, Effect.runPromise)
+      const colSpec = makeColumnSpec(mutationLogTable.sqliteDef.ast)
+      this.env.DB.exec(`CREATE TABLE IF NOT EXISTS ${this.dbName} (${colSpec}) strict`)
 
-    webSocketMessage = (ws: WebSocketClient, message: ArrayBuffer | string) =>
-      Effect.gen(this, function* () {
-        const decodedMessageRes = decodeIncomingMessage(message)
+      return new Response(null, {
+        status: 101,
+        webSocket: client,
+      })
+    }).pipe(Effect.tapCauseLogPretty, Effect.runPromise)
 
-        if (decodedMessageRes._tag === 'Left') {
-          console.error('Invalid message received', decodedMessageRes.left)
-          return
-        }
+  webSocketMessage = (ws: WebSocketClient, message: ArrayBuffer | string) =>
+    Effect.gen(this, function* () {
+      const decodedMessageRes = decodeIncomingMessage(message)
 
-        const decodedMessage = decodedMessageRes.right
-        const requestId = decodedMessage.requestId
+      if (decodedMessageRes._tag === 'Left') {
+        console.error('Invalid message received', decodedMessageRes.left)
+        return
+      }
 
-        const storage = this.storage
+      const decodedMessage = decodedMessageRes.right
+      const requestId = decodedMessage.requestId
 
-        if (storage === undefined) {
-          throw new Error('storage not initialized')
-        }
-
-        try {
-          switch (decodedMessage._tag) {
-            case 'WSMessage.PullReq': {
-              if (options?.onPull) {
-                yield* Effect.tryAll(() => options.onPull!(decodedMessage))
-              }
+      try {
+        switch (decodedMessage._tag) {
+          case 'WSMessage.PullReq': {
+            const cursor = decodedMessage.cursor
+            const CHUNK_SIZE = 100
 
-              const cursor = decodedMessage.cursor
-              const CHUNK_SIZE = 100
+            // TODO use streaming
+            const remainingEvents = [...(yield* Effect.promise(() => this.storage.getEvents(cursor)))]
 
-              // 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)
 
-              // 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 }),
-                  ),
-                )
+              ws.send(
+                encodeOutgoingMessage(WSMessage.PullRes.make({ events, remaining: remainingEvents.length, requestId })),
+              )
 
-                if (remainingEvents.length === 0) {
-                  break
-                }
+              if (remainingEvents.length === 0) {
+                break
               }
-
-              break
             }
-            case 'WSMessage.PushReq': {
-              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 latestEvent = yield* Effect.promise(() => storage.getLatestEvent())
-              const expectedParentId = latestEvent?.id ?? EventId.ROOT.global
+            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
+              }
 
-              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,
-                  })
+              // TODO handle clientId unique conflict
 
-                  yield* Effect.fail(err).pipe(Effect.ignoreLogged)
+              const createdAt = new Date().toISOString()
 
-                  ws.send(encodeOutgoingMessage(err))
-                  return
-                }
+              // NOTE we're currently not blocking on this to allow broadcasting right away
+              const storePromise = this.storage.appendEvent(mutationEventEncoded, createdAt)
 
-                // TODO handle clientId unique conflict
+              ws.send(
+                encodeOutgoingMessage(
+                  WSMessage.PushAck.make({ mutationId: mutationEventEncoded.id.global, requestId }),
+                ),
+              )
 
-                const createdAt = new Date().toISOString()
+              // console.debug(`Broadcasting mutation event to ${this.subscribedWebSockets.size} clients`)
 
-                // NOTE we're currently not blocking on this to allow broadcasting right away
-                const storePromise = storage.appendEvent(mutationEventEncoded, createdAt)
+              const connectedClients = this.ctx.getWebSockets()
 
-                ws.send(
-                  encodeOutgoingMessage(WSMessage.PushAck.make({ mutationId: mutationEventEncoded.id, requestId })),
+              if (connectedClients.length > 0) {
+                const broadcastMessage = encodeOutgoingMessage(
+                  // TODO refactor to batch api
+                  WSMessage.PushBroadcast.make({
+                    mutationEventEncoded,
+                    metadata: Option.some({ createdAt }),
+                  }),
                 )
 
-                // 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)
-                    // }
-                  }
+                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
+            break
+          }
+          case 'WSMessage.AdminResetRoomReq': {
+            if (decodedMessage.adminSecret !== this.env.ADMIN_SECRET) {
+              ws.send(encodeOutgoingMessage(WSMessage.Error.make({ message: 'Invalid admin secret', requestId })))
+              return
             }
-            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(() => storage.resetRoom())
-              ws.send(encodeOutgoingMessage(WSMessage.AdminResetRoomRes.make({ requestId })))
+            yield* Effect.promise(() => this.storage.resetRoom())
+            ws.send(encodeOutgoingMessage(WSMessage.AdminResetRoomRes.make({ requestId })))
 
-              break
+            break
+          }
+          case 'WSMessage.AdminInfoReq': {
+            if (decodedMessage.adminSecret !== this.env.ADMIN_SECRET) {
+              ws.send(encodeOutgoingMessage(WSMessage.Error.make({ message: 'Invalid admin secret', requestId })))
+              return
             }
-            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 })))
         }
-      }).pipe(
-        Effect.withSpan('@livestore/sync-cf:durable-object:webSocketMessage'),
-        Effect.tapCauseLogPretty,
-        Logger.withMinimumLogLevel(LogLevel.Debug),
-        Effect.provide(Logger.pretty),
-        Effect.runPromise,
-      )
+      } 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,
+    )
 
-    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')
   }
 }
 
-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, dbName: string): SyncStorage => {
-  const getLatestEvent = async (): Promise<MutationEvent.AnyEncodedGlobal | undefined> => {
-    const rawEvents = await env.DB.prepare(`SELECT * FROM ${dbName} ORDER BY id DESC LIMIT 1`).all()
+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()
     if (rawEvents.error) {
       throw new Error(rawEvents.error)
     }
-    const events = Schema.decodeUnknownSync(Schema.Array(mutationLogTable.schema))(rawEvents.results)
-
+    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 },
+    }))
     return events[0]
   }
 
   const getEvents = async (
     cursor: number | undefined,
   ): Promise<
-    ReadonlyArray<{ mutationEventEncoded: MutationEvent.AnyEncodedGlobal; metadata: Option.Option<SyncMetadata> }>
+    ReadonlyArray<{ mutationEventEncoded: MutationEvent.AnyEncoded; metadata: Option.Option<SyncMetadata> }>
   > => {
-    const whereClause = cursor === undefined ? '' : `WHERE id > ${cursor}`
-    const sql = `SELECT * FROM ${dbName} ${whereClause} ORDER BY id ASC`
+    const whereClause = cursor === undefined ? '' : `WHERE idGlobal > ${cursor}`
+    const sql = `SELECT * FROM ${dbName} ${whereClause} ORDER BY idGlobal 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,
+      ({ createdAt, ...e }) => ({
+        mutationEventEncoded: {
+          ...e,
+          // TODO remove local ids
+          id: { global: e.idGlobal, local: 0 },
+          parentId: { global: e.parentIdGlobal, local: 0 },
+        },
         metadata: Option.some({ createdAt }),
       }),
     )
     return events
   }
 
-  const appendEvent = async (event: MutationEvent.AnyEncodedGlobal, createdAt: string) => {
-    const sql = `INSERT INTO ${dbName} (id, parentId, args, mutation, createdAt) VALUES (?, ?, ?, ?, ?)`
+  const appendEvent = async (event: MutationEvent.Any, createdAt: string) => {
+    const sql = `INSERT INTO ${dbName} (idGlobal, parentIdGlobal, args, mutation, createdAt) VALUES (?, ?, ?, ?, ?)`
     await env.DB.prepare(sql)
-      .bind(event.id, event.parentId, JSON.stringify(event.args), event.mutation, createdAt)
+      .bind(event.id.global, event.parentId.global, JSON.stringify(event.args), event.mutation, createdAt)
       .run()
   }
 
@@ -296,17 +257,5 @@ const makeStorage = (ctx: DurableObjectState, env: Env, dbName: string): SyncSto
     await ctx.storage.deleteAll()
   }
 
-  return { dbName, getLatestEvent, getEvents, appendEvent, resetRoom }
+  return { 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/index.ts

@@ -0,0 +1,84 @@
+/// <reference no-default-lib="true"/>
+/// <reference lib="esnext" />
+
+// import { EncodedAny } from '@livestore/common/schema'
+// import { Effect, HttpServer, Schema } from '@livestore/utils/effect'
+
+import type { Env } from './durable-object.js'
+
+export * from './durable-object.js'
+
+// const handleRequest = (request: Request, env: Env) =>
+//   HttpServer.router.empty.pipe(
+//     HttpServer.router.get(
+//       '/websocket',
+//       Effect.gen(function* () {
+//         // This example will refer to the same Durable Object instance,
+//         // since the name "foo" is hardcoded.
+//         const id = env.WEBSOCKET_SERVER.idFromName('foo')
+//         const durableObject = env.WEBSOCKET_SERVER.get(id)
+
+//         HttpServer.
+
+//         // Expect to receive a WebSocket Upgrade request.
+//         // If there is one, accept the request and return a WebSocket Response.
+//         const headerRes = yield* HttpServer.request
+//           .schemaHeaders(
+//             Schema.Struct({
+//               Upgrade: Schema.Literal('websocket'),
+//             }),
+//           )
+//           .pipe(Effect.either)
+
+//         if (headerRes._tag === 'Left') {
+//           // return new Response('Durable Object expected Upgrade: websocket', { status: 426 })
+//           return yield* HttpServer.response.text('Durable Object expected Upgrade: websocket', { status: 426 })
+//         }
+
+//         HttpServer.response.empty
+
+//         return yield* Effect.promise(() => durableObject.fetch(request))
+//       }),
+//     ),
+//     HttpServer.router.catchAll((e) => {
+//       console.log(e)
+//       return HttpServer.response.empty({ status: 400 })
+//     }),
+//     (_) => HttpServer.app.toWebHandler(_)(request),
+//     // request
+//   )
+
+// Worker
+export default {
+  fetch: async (request: Request, env: Env, _ctx: ExecutionContext): Promise<Response> => {
+    const url = new URL(request.url)
+    const searchParams = url.searchParams
+    const roomId = searchParams.get('room')
+
+    if (roomId === null) {
+      return new Response('Room ID is required', { status: 400 })
+    }
+
+    // This example will refer to the same Durable Object instance,
+    // since the name "foo" is hardcoded.
+    const id = env.WEBSOCKET_SERVER.idFromName(roomId)
+    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.AnyEncodedGlobal,
+      mutationEventEncoded: MutationEvent.EncodedAny,
       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.AnyEncodedGlobal,
+  mutationEventEncoded: MutationEvent.EncodedAny,
   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.AnyEncodedGlobal),
+  batch: Schema.Array(MutationEvent.EncodedAny),
 })
 
 export type PushReq = typeof PushReq.Type

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

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

package/dist/cf-worker/make-worker.d.ts

@@ -1,6 +0,0 @@
-import type { Env } from './durable-object.js';
-export type CFWorker = {
-    fetch: (request: Request, env: Env, ctx: ExecutionContext) => Promise<Response>;
-};
-export declare const makeWorker: () => CFWorker;
-//# sourceMappingURL=make-worker.d.ts.map

package/dist/cf-worker/make-worker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"make-worker.d.ts","sourceRoot":"","sources":["../../src/cf-worker/make-worker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,qBAAqB,CAAA;AAE9C,MAAM,MAAM,QAAQ,GAAG;IACrB,KAAK,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,gBAAgB,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;CAChF,CAAA;AAED,eAAO,MAAM,UAAU,QAAO,QAkC7B,CAAA"}