@livestore/sync-cf 0.4.0-dev.3 → 0.4.0-dev.6

package/src/cf-worker/do/sync-storage.ts

@@ -0,0 +1,126 @@
+import { UnexpectedError } from '@livestore/common'
+import type { LiveStoreEvent } from '@livestore/common/schema'
+import type { CfTypes } from '@livestore/common-cf'
+import { Effect, Option, Schema } from '@livestore/utils/effect'
+import { SyncMetadata } from '../../common/sync-message-types.ts'
+import { type Env, PERSISTENCE_FORMAT_VERSION, type StoreId } from '../shared.ts'
+import { eventlogTable } from './sqlite.ts'
+
+export 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>
+}
+
+export const makeStorage = (ctx: CfTypes.DurableObjectState, env: Env, storeId: StoreId): SyncStorage => {
+  const dbName = `eventlog_${PERSISTENCE_FORMAT_VERSION}_${toValidTableName(storeId)}`
+
+  const execDb = <T>(cb: (db: CfTypes.D1Database) => Promise<CfTypes.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'),
+    )
+
+  // 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(),
+  //     )
+
+  //     return result[0]?.seqNum ?? EventSequenceNumber.ROOT.global
+  //   },
+  // ).pipe(UnexpectedError.mapToUnexpectedError)
+
+  // TODO support streaming
+  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(SyncMetadata.make({ createdAt })),
+        }),
+      )
+      return events
+    }).pipe(
+      UnexpectedError.mapToUnexpectedError,
+      Effect.withSpan('@livestore/sync-cf:durable-object:getEvents', { attributes: { dbName, cursor } }),
+    )
+
+  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,
+      Effect.withSpan('@livestore/sync-cf:durable-object:appendEvents', {
+        attributes: { dbName, batchLength: batch.length },
+      }),
+    )
+
+  const resetStore = Effect.promise(() => ctx.storage.deleteAll()).pipe(
+    UnexpectedError.mapToUnexpectedError,
+    Effect.withSpan('@livestore/sync-cf:durable-object:resetStore'),
+  )
+
+  return {
+    dbName,
+    // getHead,
+    getEvents,
+    appendEvents,
+    resetStore,
+  }
+}
+
+const toValidTableName = (str: string) => str.replaceAll(/[^a-zA-Z0-9]/g, '_')

package/src/cf-worker/do/transport/do-rpc-server.ts

@@ -0,0 +1,82 @@
+import { InvalidPullError, InvalidPushError } from '@livestore/common'
+import { toDurableObjectHandler } from '@livestore/common-cf'
+import {
+  Effect,
+  Headers,
+  HttpServer,
+  Layer,
+  Logger,
+  LogLevel,
+  Option,
+  RpcSerialization,
+  Stream,
+} from '@livestore/utils/effect'
+import { SyncDoRpc } from '../../../common/do-rpc-schema.ts'
+import { SyncMessage } from '../../../common/mod.ts'
+import { DoCtx, type DoCtxInput } from '../layer.ts'
+import { makeEndingPullStream } from '../pull.ts'
+import { makePush } from '../push.ts'
+
+export interface DoRpcHandlerOptions {
+  payload: Uint8Array<ArrayBuffer>
+  input: Omit<DoCtxInput, 'from'>
+}
+
+export const createDoRpcHandler = (options: DoRpcHandlerOptions) =>
+  Effect.gen(this, function* () {
+    const { payload, input } = options
+    // const { rpcSubscriptions, backendId, doOptions, ctx, env } = yield* DoCtx
+
+    // TODO add admin RPCs
+    const RpcLive = SyncDoRpc.toLayer({
+      'SyncDoRpc.Ping': (_req) => {
+        return Effect.succeed(SyncMessage.Pong.make({}))
+      },
+      'SyncDoRpc.Pull': (req, { headers }) =>
+        Effect.gen(this, function* () {
+          const { rpcSubscriptions } = yield* DoCtx
+
+          // TODO rename `req.rpcContext` to something more appropriate
+          if (req.rpcContext) {
+            rpcSubscriptions.set(req.storeId, {
+              storeId: req.storeId,
+              payload: req.payload,
+              subscribedAt: Date.now(),
+              requestId: Headers.get(headers, 'x-rpc-request-id').pipe(Option.getOrThrow),
+              callerContext: req.rpcContext.callerContext,
+            })
+          }
+
+          return makeEndingPullStream(req, req.payload)
+        }).pipe(
+          Stream.unwrap,
+          Stream.map((res) => ({
+            ...res,
+            rpcRequestId: Headers.get(headers, 'x-rpc-request-id').pipe(Option.getOrThrow),
+          })),
+          Stream.provideLayer(DoCtx.Default({ ...input, from: { storeId: req.storeId } })),
+          Stream.mapError((cause) => (cause._tag === 'InvalidPullError' ? cause : InvalidPullError.make({ cause }))),
+          Stream.tapErrorCause(Effect.log),
+        ),
+      'SyncDoRpc.Push': (req) =>
+        Effect.gen(this, function* () {
+          const { doOptions, ctx, env, storeId } = yield* DoCtx
+          const push = makePush({ storeId, payload: req.payload, options: doOptions, ctx, env })
+
+          return yield* push(req)
+        }).pipe(
+          Effect.provide(DoCtx.Default({ ...input, from: { storeId: req.storeId } })),
+          Effect.mapError((cause) => (cause._tag === 'InvalidPushError' ? cause : InvalidPushError.make({ cause }))),
+          Effect.tapCauseLogPretty,
+        ),
+    })
+
+    const handler = toDurableObjectHandler(SyncDoRpc, {
+      layer: Layer.mergeAll(RpcLive, RpcSerialization.layerJson, HttpServer.layerContext).pipe(
+        Layer.provide(Logger.consoleWithThread('SyncDo')),
+        Layer.provide(Logger.minimumLogLevel(LogLevel.Debug)),
+      ),
+    })
+
+    return yield* handler(payload)
+  }).pipe(Effect.withSpan('createDoRpcHandler'))

package/src/cf-worker/do/transport/http-rpc-server.ts

@@ -0,0 +1,37 @@
+import type { CfTypes } from '@livestore/common-cf'
+import { Effect, HttpApp, Layer, RpcSerialization, RpcServer } from '@livestore/utils/effect'
+import { SyncHttpRpc } from '../../../common/http-rpc-schema.ts'
+import * as SyncMessage from '../../../common/sync-message-types.ts'
+import { DoCtx } from '../layer.ts'
+import { makeEndingPullStream } from '../pull.ts'
+import { makePush } from '../push.ts'
+
+export const createHttpRpcHandler = ({ request }: { request: CfTypes.Request }) =>
+  Effect.gen(function* () {
+    const handlerLayer = createHttpRpcLayer
+    const httpApp = RpcServer.toHttpApp(SyncHttpRpc).pipe(Effect.provide(handlerLayer))
+    const webHandler = yield* httpApp.pipe(Effect.map(HttpApp.toWebHandler))
+
+    return yield* Effect.promise(
+      () => webHandler(request as TODO as Request) as TODO as Promise<CfTypes.Response>,
+    ).pipe(Effect.timeout(10000))
+  }).pipe(Effect.withSpan('createHttpRpcHandler'))
+
+const createHttpRpcLayer =
+  // TODO implement admin requests
+  SyncHttpRpc.toLayer({
+    'SyncHttpRpc.Pull': (req) => makeEndingPullStream(req, req.payload),
+
+    'SyncHttpRpc.Push': (req) =>
+      Effect.gen(function* () {
+        const { ctx, env, doOptions, storeId } = yield* DoCtx
+        const push = makePush({ payload: undefined, options: doOptions, storeId, ctx, env })
+
+        return yield* push(req)
+      }),
+
+    'SyncHttpRpc.Ping': () => Effect.succeed(SyncMessage.Pong.make({})),
+  }).pipe(
+    Layer.provideMerge(RpcServer.layerProtocolHttp({ path: '/http-rpc' })),
+    Layer.provideMerge(RpcSerialization.layerJson),
+  )

package/src/cf-worker/do/transport/ws-rpc-server.ts

@@ -0,0 +1,34 @@
+import { InvalidPullError, InvalidPushError } from '@livestore/common'
+import { Effect, identity, Layer, RpcServer, Stream } from '@livestore/utils/effect'
+import { SyncWsRpc } from '../../../common/ws-rpc-schema.ts'
+import { DoCtx, type DoCtxInput } from '../layer.ts'
+import { makeEndingPullStream } from '../pull.ts'
+import { makePush } from '../push.ts'
+
+export const makeRpcServer = ({ doSelf, doOptions }: Omit<DoCtxInput, 'from'>) => {
+  // TODO implement admin requests
+  const handlersLayer = SyncWsRpc.toLayer({
+    'SyncWsRpc.Pull': (req) =>
+      makeEndingPullStream(req, req.payload).pipe(
+        // Needed to keep the stream alive on the client side for phase 2 (i.e. not send the `Exit` stream RPC message)
+        req.live ? Stream.concat(Stream.never) : identity,
+        Stream.provideLayer(DoCtx.Default({ doSelf, doOptions, from: { storeId: req.storeId } })),
+        Stream.mapError((cause) => (cause._tag === 'InvalidPullError' ? cause : InvalidPullError.make({ cause }))),
+        // Stream.tapErrorCause(Effect.log),
+      ),
+    'SyncWsRpc.Push': (req) =>
+      Effect.gen(function* () {
+        const { doOptions, storeId, ctx, env } = yield* DoCtx
+
+        const push = makePush({ options: doOptions, storeId, payload: req.payload, ctx, env })
+
+        return yield* push(req)
+      }).pipe(
+        Effect.provide(DoCtx.Default({ doSelf, doOptions, from: { storeId: req.storeId } })),
+        Effect.mapError((cause) => (cause._tag === 'InvalidPushError' ? cause : InvalidPushError.make({ cause }))),
+        Effect.tapCauseLogPretty,
+      ),
+  })
+
+  return RpcServer.layer(SyncWsRpc).pipe(Layer.provide(handlersLayer))
+}

package/src/cf-worker/mod.ts

@@ -1,3 +1,5 @@
-export * from './cf-types.ts'
-export * from './durable-object.ts'
+export type { CfTypes } from '@livestore/common-cf'
+export { CfDeclare } from '@livestore/common-cf/declare'
+export * from './do/durable-object.ts'
+export * from './shared.ts'
 export * from './worker.ts'

package/src/cf-worker/shared.ts

@@ -0,0 +1,95 @@
+import type { InvalidPullError, InvalidPushError } from '@livestore/common'
+import type { CfTypes } from '@livestore/common-cf'
+import { Effect, type Option, Schema, UrlParams } from '@livestore/utils/effect'
+import { SearchParamsSchema, SyncMessage } from '../common/mod.ts'
+
+export interface Env {
+  /** Eventlog database */
+  DB: CfTypes.D1Database
+  ADMIN_SECRET: string
+}
+
+export type MakeDurableObjectClassOptions = {
+  onPush?: (
+    message: SyncMessage.PushRequest,
+    context: { storeId: StoreId; payload?: Schema.JsonValue },
+  ) => Effect.SyncOrPromiseOrEffect<void>
+  onPushRes?: (message: SyncMessage.PushAck | InvalidPushError) => Effect.SyncOrPromiseOrEffect<void>
+  onPull?: (
+    message: SyncMessage.PullRequest,
+    context: { storeId: StoreId; payload?: Schema.JsonValue },
+  ) => Effect.SyncOrPromiseOrEffect<void>
+  onPullRes?: (message: SyncMessage.PullResponse | InvalidPullError) => Effect.SyncOrPromiseOrEffect<void>
+  // TODO make storage configurable: D1, DO SQLite, later: external SQLite
+
+  /**
+   * Enabled transports for sync backend
+   * - `http`: HTTP JSON-RPC
+   * - `ws`: WebSocket
+   * - `do-rpc`: Durable Object RPC calls (only works in combination with `@livestore/adapter-cf`)
+   *
+   * @default Set(['http', 'ws', 'do-rpc'])
+   */
+  enabledTransports?: Set<'http' | 'ws' | 'do-rpc'>
+
+  otel?: {
+    baseUrl?: string
+    serviceName?: string
+  }
+}
+
+export type StoreId = string
+export type DurableObjectId = string
+
+/**
+ * Needs to be bumped when the storage format changes (e.g. eventlogTable schema changes)
+ *
+ * Changing this version number will lead to a "soft reset".
+ */
+export const PERSISTENCE_FORMAT_VERSION = 7
+
+export const DEFAULT_SYNC_DURABLE_OBJECT_NAME = 'SYNC_BACKEND_DO'
+
+export const encodeOutgoingMessage = Schema.encodeSync(Schema.parseJson(SyncMessage.BackendToClientMessage))
+export const encodeIncomingMessage = Schema.encodeSync(Schema.parseJson(SyncMessage.ClientToBackendMessage))
+
+export const getSyncRequestSearchParams = (request: CfTypes.Request): Option.Option<typeof SearchParamsSchema.Type> => {
+  const url = new URL(request.url)
+  const urlParams = UrlParams.fromInput(url.searchParams)
+  const paramsResult = UrlParams.schemaStruct(SearchParamsSchema)(urlParams).pipe(Effect.option, Effect.runSync)
+
+  return paramsResult
+}
+
+export const PULL_CHUNK_SIZE = 100
+
+// RPC subscription storage (TODO refactor)
+export type RpcSubscription = {
+  storeId: StoreId
+  payload?: Schema.JsonValue
+  subscribedAt: number
+  /** Effect RPC request ID */
+  requestId: string
+  callerContext: {
+    bindingName: string
+    durableObjectId: string
+  }
+}
+
+/**
+ * Durable Object interface supporting the DO RPC protocol for DO <> DO syncing.
+ */
+export interface SyncBackendRpcInterface {
+  __DURABLE_OBJECT_BRAND: never
+  rpc(payload: Uint8Array): Promise<Uint8Array | CfTypes.ReadableStream>
+}
+
+export const WebSocketAttachmentSchema = Schema.parseJson(
+  Schema.Struct({
+    // Same across all websocket connections
+    storeId: Schema.String,
+    // Different for each websocket connection
+    payload: Schema.optional(Schema.JsonValue),
+    pullRequestIds: Schema.Array(Schema.String),
+  }),
+)

package/src/cf-worker/worker.ts

@@ -1,17 +1,15 @@
-import type * as CfWorker from '@cloudflare/workers-types'
 import { UnexpectedError } from '@livestore/common'
 import type { Schema } from '@livestore/utils/effect'
-import { Effect, UrlParams } from '@livestore/utils/effect'
-
-import { SearchParamsSchema } from '../common/mod.ts'
-
-import type { Env } from './durable-object.ts'
+import { Effect } from '@livestore/utils/effect'
+import type { CfTypes, SearchParams } from '../common/mod.ts'
+import type { CfDeclare } from './mod.ts'
+import { DEFAULT_SYNC_DURABLE_OBJECT_NAME, type Env, getSyncRequestSearchParams } from './shared.ts'
 
 // NOTE We need to redeclare runtime types here to avoid type conflicts with the lib.dom Response type.
-declare class Response extends CfWorker.Response {}
+declare class Response extends CfDeclare.Response {}
 
 export namespace HelperTypes {
-  type AnyDON = CfWorker.DurableObjectNamespace<undefined>
+  type AnyDON = CfTypes.DurableObjectNamespace<undefined>
 
   type DOKeys<T> = {
     [K in keyof T]-?: T[K] extends AnyDON ? K : never
@@ -27,11 +25,11 @@ export namespace HelperTypes {
    *  type PlatformEnv = {
    *    DB: D1Database
    *    ADMIN_TOKEN: string
-   *    WEBSOCKET_SERVER: DurableObjectNamespace<WebSocketServer>
+   *    SYNC_BACKEND_DO: DurableObjectNamespace<SyncBackendDO>
    * }
    *  export default makeWorker<PlatformEnv>({
-   *    durableObject: { name: "WEBSOCKET_SERVER" },
-   *    // ^ (property) name?: "WEBSOCKET_SERVER" | undefined
+   *    durableObject: { name: "SYNC_BACKEND_DO" },
+   *    // ^ (property) name?: "SYNC_BACKEND_DO" | undefined
    *  });
    */
   export type ExtractDurableObjectKeys<TEnv = Env> = DOKeys<NonBuiltins<TEnv>> extends never
@@ -40,12 +38,12 @@ export namespace HelperTypes {
 }
 
 // HINT: If we ever extend user's custom worker RPC, type T can help here with expected return type safety. Currently unused.
-export type CFWorker<TEnv extends Env = Env, _T extends CfWorker.Rpc.DurableObjectBranded | undefined = undefined> = {
+export type CFWorker<TEnv extends Env = Env, _T extends CfTypes.Rpc.DurableObjectBranded | undefined = undefined> = {
   fetch: <CFHostMetada = unknown>(
-    request: CfWorker.Request<CFHostMetada>,
+    request: CfTypes.Request<CFHostMetada>,
     env: TEnv,
-    ctx: CfWorker.ExecutionContext,
-  ) => Promise<CfWorker.Response>
+    ctx: CfTypes.ExecutionContext,
+  ) => Promise<CfTypes.Response>
 }
 
 export type MakeWorkerOptions<TEnv extends Env = Env> = {
@@ -61,7 +59,7 @@ export type MakeWorkerOptions<TEnv extends Env = Env> = {
     /**
      * Needs to match the binding name from the wrangler config
      *
-     * @default 'WEBSOCKET_SERVER'
+     * @default 'SYNC_BACKEND_DO'
      */
     name?: HelperTypes.ExtractDurableObjectKeys<TEnv>
   }
@@ -69,7 +67,7 @@ export type MakeWorkerOptions<TEnv extends Env = Env> = {
 
 export const makeWorker = <
   TEnv extends Env = Env,
-  TDurableObjectRpc extends CfWorker.Rpc.DurableObjectBranded | undefined = undefined,
+  TDurableObjectRpc extends CfTypes.Rpc.DurableObjectBranded | undefined = undefined,
 >(
   options: MakeWorkerOptions<TEnv> = {},
 ): CFWorker<TEnv, TDurableObjectRpc> => {
@@ -77,16 +75,7 @@ export const makeWorker = <
     fetch: async (request, env, _ctx) => {
       const url = new URL(request.url)
 
-      await new Promise((resolve) => setTimeout(resolve, 500))
-
-      if (request.method === 'GET' && url.pathname === '/') {
-        return new Response('Info: WebSocket sync backend endpoint for @livestore/sync-cf.', {
-          status: 200,
-          headers: { 'Content-Type': 'text/plain' },
-        })
-      }
-
-      const corsHeaders: CfWorker.HeadersInit = options.enableCORS
+      const corsHeaders: CfTypes.HeadersInit = options.enableCORS
         ? {
             'Access-Control-Allow-Origin': '*',
             'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
@@ -101,11 +90,28 @@ export const makeWorker = <
         })
       }
 
-      if (url.pathname.endsWith('/websocket')) {
-        return handleWebSocket<TEnv, TDurableObjectRpc>(request, env, _ctx, {
-          headers: corsHeaders,
-          validatePayload: options.validatePayload,
-          durableObject: options.durableObject,
+      const requestParamsResult = getSyncRequestSearchParams(request)
+
+      // Check if this is a sync request first, before showing info message
+      if (requestParamsResult._tag === 'Some') {
+        return handleSyncRequest<TEnv, TDurableObjectRpc>({
+          request,
+          searchParams: requestParamsResult.value,
+          env,
+          ctx: _ctx,
+          options: {
+            headers: corsHeaders,
+            validatePayload: options.validatePayload,
+            durableObject: options.durableObject,
+          },
+        })
+      }
+
+      // Only show info message for GET requests to / without sync parameters
+      if (request.method === 'GET' && url.pathname === '/') {
+        return new Response('Info: Sync backend endpoint for @livestore/sync-cf.', {
+          status: 200,
+          headers: { 'Content-Type': 'text/plain' },
         })
       }
 
@@ -124,7 +130,7 @@ export const makeWorker = <
 }
 
 /**
- * Handles `/websocket` endpoint.
+ * Handles `/sync` endpoint.
  *
  * @example
  * ```ts
@@ -137,46 +143,49 @@ export const makeWorker = <
  *
  * export default {
  *   fetch: async (request, env, ctx) => {
- *     if (request.url.endsWith('/websocket')) {
- *       return handleWebSocket(request, env, ctx, { headers: {}, validatePayload })
+ *     const requestParamsResult = getSyncRequestSearchParams(request)
+ *
+ *     // Is LiveStore sync request
+ *     if (requestParamsResult._tag === 'Some') {
+ *       return handleSyncRequest({
+ *         request,
+ *         searchParams: requestParamsResult.value,
+ *         env,
+ *         ctx,
+ *         options: { headers: {}, validatePayload }
+ *       })
  *     }
  *
  *     return new Response('Invalid path', { status: 400 })
- *     return new Response('Invalid path', { status: 400 })
  *   }
  * }
  * ```
  *
  * @throws {UnexpectedError} If the payload is invalid
  */
-export const handleWebSocket = <
+export const handleSyncRequest = <
   TEnv extends Env = Env,
-  TDurableObjectRpc extends CfWorker.Rpc.DurableObjectBranded | undefined = undefined,
+  TDurableObjectRpc extends CfTypes.Rpc.DurableObjectBranded | undefined = undefined,
   CFHostMetada = unknown,
->(
-  request: CfWorker.Request<CFHostMetada>,
-  env: TEnv,
-  _ctx: CfWorker.ExecutionContext,
-  options: {
-    headers?: CfWorker.HeadersInit
+>({
+  request,
+  searchParams,
+  env,
+  options = {},
+}: {
+  request: CfTypes.Request<CFHostMetada>
+  searchParams: SearchParams
+  env: TEnv
+  /** Only there for type-level reasons */
+  ctx: CfTypes.ExecutionContext
+  options?: {
+    headers?: CfTypes.HeadersInit
     durableObject?: MakeWorkerOptions<TEnv>['durableObject']
     validatePayload?: (payload: Schema.JsonValue | undefined, context: { storeId: string }) => void | Promise<void>
-  } = {},
-): Promise<CfWorker.Response> =>
+  }
+}): Promise<CfTypes.Response> =>
   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)
-
-    if (paramsResult._tag === 'Left') {
-      return new Response(`Invalid search params: ${paramsResult.left.toString()}`, {
-        status: 500,
-        headers: options?.headers,
-      })
-    }
-
-    const { storeId, payload } = paramsResult.right
+    const { storeId, payload, transport } = searchParams
 
     if (options.validatePayload !== undefined) {
       const result = yield* Effect.promise(async () => options.validatePayload!(payload, { storeId })).pipe(
@@ -190,7 +199,7 @@ export const handleWebSocket = <
       }
     }
 
-    const durableObjectName = options.durableObject?.name ?? 'WEBSOCKET_SERVER'
+    const durableObjectName = options.durableObject?.name ?? DEFAULT_SYNC_DURABLE_OBJECT_NAME
     if (!(durableObjectName in env)) {
       return new Response(
         `Failed dependency: Required Durable Object binding '${durableObjectName as string}' not available`,
@@ -203,19 +212,19 @@ export const handleWebSocket = <
 
     const durableObjectNamespace = env[
       durableObjectName as keyof TEnv
-    ] as CfWorker.DurableObjectNamespace<TDurableObjectRpc>
+    ] as CfTypes.DurableObjectNamespace<TDurableObjectRpc>
 
     const id = durableObjectNamespace.idFromName(storeId)
     const durableObject = durableObjectNamespace.get(id)
 
+    // Handle WebSocket upgrade request
     const upgradeHeader = request.headers.get('Upgrade')
-    if (!upgradeHeader || upgradeHeader !== 'websocket') {
+    if (transport === 'ws' && (upgradeHeader === null || upgradeHeader !== 'websocket')) {
       return new Response('Durable Object expected Upgrade: websocket', {
         status: 426,
         headers: options?.headers,
       })
     }
 
-    // Cloudflare Durable Object type clashing with lib.dom Response type, which is why we need the casts here.
     return yield* Effect.promise(() => durableObject.fetch(request))
   }).pipe(Effect.tapCauseLogPretty, Effect.runPromise)

package/src/client/mod.ts

@@ -0,0 +1,3 @@
+export * from './transport/do-rpc-client.ts'
+export * from './transport/http-rpc-client.ts'
+export * from './transport/ws-rpc-client.ts'