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

package/src/client/transport/do-rpc-client.ts

@@ -0,0 +1,171 @@
+import { InvalidPullError, InvalidPushError, SyncBackend, UnexpectedError } from '@livestore/common'
+import { type CfTypes, layerProtocolDurableObject } from '@livestore/common-cf'
+import { omit, shouldNeverHappen } from '@livestore/utils'
+import {
+  Effect,
+  identity,
+  Layer,
+  Mailbox,
+  Option,
+  RpcClient,
+  RpcSerialization,
+  Schema,
+  Stream,
+  SubscriptionRef,
+} from '@livestore/utils/effect'
+import type { SyncBackendRpcInterface } from '../../cf-worker/shared.ts'
+import { SyncDoRpc } from '../../common/do-rpc-schema.ts'
+import { SyncMessage } from '../../common/mod.ts'
+import type { SyncMetadata } from '../../common/sync-message-types.ts'
+
+export interface SyncBackendRpcStub extends CfTypes.DurableObjectStub, SyncBackendRpcInterface {}
+
+// TODO we probably need better scoping for the requestIdMailboxMap (i.e. support multiple stores, ...)
+type EffectRpcRequestId = string // 0, 1, 2, ...
+const requestIdMailboxMap = new Map<EffectRpcRequestId, Mailbox.Mailbox<SyncMessage.PullResponse>>()
+
+export interface DoRpcSyncOptions {
+  /** Durable Object stub that implements the SyncDoRpc interface */
+  syncBackendStub: SyncBackendRpcStub
+  /** Information about this DurableObject instance so the Sync DO instance can call back to this instance */
+  durableObjectContext: {
+    /** See `wrangler.toml` for the binding name */
+    bindingName: string
+    /** `state.id.toString()` in the DO */
+    durableObjectId: string
+  }
+}
+
+/**
+ * Creates a sync backend that uses Durable Object RPC to communicate with the sync backend.
+ *
+ * Used internally by `@livestore/adapter-cf` to connect to the sync backend.
+ */
+export const makeDoRpcSync =
+  ({ syncBackendStub, durableObjectContext }: DoRpcSyncOptions): SyncBackend.SyncBackendConstructor<SyncMetadata> =>
+  ({ storeId, payload }) =>
+    Effect.gen(function* () {
+      const isConnected = yield* SubscriptionRef.make(true)
+
+      const ProtocolLive = layerProtocolDurableObject({
+        callRpc: (payload) => syncBackendStub.rpc(payload),
+        callerContext: durableObjectContext,
+      }).pipe(Layer.provide(RpcSerialization.layerJson))
+
+      const context = yield* Layer.build(ProtocolLive)
+
+      const rpcClient = yield* RpcClient.make(SyncDoRpc).pipe(Effect.provide(context))
+
+      // Nothing to do here
+      const connect = Effect.void
+
+      const backendIdHelper = yield* SyncBackend.makeBackendIdHelper
+
+      const pull: SyncBackend.SyncBackend<SyncMetadata>['pull'] = (cursor, options) =>
+        rpcClient.SyncDoRpc.Pull({
+          cursor: cursor.pipe(
+            Option.map((a) => ({
+              eventSequenceNumber: a.eventSequenceNumber,
+              backendId: backendIdHelper.get().pipe(Option.getOrThrow),
+            })),
+          ),
+          storeId,
+          rpcContext: options?.live ? { callerContext: durableObjectContext } : undefined,
+        }).pipe(
+          options?.live
+            ? Stream.concatWithLastElement((res) =>
+                Effect.gen(function* () {
+                  if (res._tag === 'None')
+                    return shouldNeverHappen('There should at least be a no-more page info response')
+
+                  const mailbox = yield* Mailbox.make<SyncMessage.PullResponse>().pipe(
+                    Effect.acquireRelease((mailbox) => mailbox.shutdown),
+                  )
+
+                  requestIdMailboxMap.set(res.value.rpcRequestId, mailbox)
+
+                  return Mailbox.toStream(mailbox)
+                }).pipe(Stream.unwrapScoped),
+              )
+            : identity,
+          Stream.tap((res) => backendIdHelper.lazySet(res.backendId)),
+          Stream.map((res) => omit(res, ['backendId'])),
+          Stream.mapError((cause) => (cause._tag === 'InvalidPullError' ? cause : InvalidPullError.make({ cause }))),
+          Stream.withSpan('rpc-sync-client:pull'),
+        )
+
+      const push: SyncBackend.SyncBackend<{ createdAt: string }>['push'] = (batch) =>
+        Effect.gen(function* () {
+          if (batch.length === 0) {
+            return
+          }
+
+          yield* rpcClient.SyncDoRpc.Push({ batch, storeId, backendId: backendIdHelper.get() })
+        }).pipe(
+          Effect.mapError((cause) =>
+            cause._tag === 'InvalidPushError'
+              ? cause
+              : InvalidPushError.make({ cause: new UnexpectedError({ cause }) }),
+          ),
+          Effect.withSpan('rpc-sync-client:push'),
+        )
+
+      const ping: SyncBackend.SyncBackend<{ createdAt: string }>['ping'] = rpcClient.SyncDoRpc.Ping({
+        storeId,
+        payload,
+      }).pipe(UnexpectedError.mapToUnexpectedError, Effect.withSpan('rpc-sync-client:ping'))
+
+      return SyncBackend.of({
+        connect,
+        isConnected,
+        pull,
+        push,
+        ping,
+        metadata: {
+          name: 'rpc-sync-client',
+          description: 'Cloudflare Durable Object RPC Sync Client',
+          protocol: 'rpc',
+          storeId,
+        },
+        supports: {
+          pullPageInfoKnown: true,
+          pullLive: true,
+        },
+      })
+    }).pipe(Effect.withSpan('rpc-sync-client:makeDoRpcSync'))
+
+/**
+ *
+ * ```ts
+ * import { DurableObject } from 'cloudflare:workers'
+ * import { ClientDoWithRpcCallback } from '@livestore/common-cf'
+ *
+ * export class MyDurableObject extends DurableObject implements ClientDoWithRpcCallback {
+ *   // ...
+ *
+ *   async syncUpdateRpc(payload: RpcMessage.ResponseChunkEncoded) {
+ *     return handleSyncUpdateRpc(payload)
+ *   }
+ * }
+ * ```
+ */
+export const handleSyncUpdateRpc = (payload: unknown) =>
+  Effect.gen(function* () {
+    const decodedPayload = yield* Schema.decodeUnknown(ResponseChunkEncoded)(payload)
+    const decoded = yield* Schema.decodeUnknown(SyncMessage.PullResponse)(decodedPayload.values[0]!)
+
+    const pullStreamMailbox = requestIdMailboxMap.get(decodedPayload.requestId)
+
+    if (pullStreamMailbox === undefined) {
+      // Case: DO was hibernated, so we need to manually update the store
+      yield* Effect.log(`No mailbox found for ${decodedPayload.requestId}`)
+    } else {
+      // Case: DO was still alive, so the existing `pull` will pick up the new events
+      yield* pullStreamMailbox.offer(decoded)
+    }
+  }).pipe(Effect.withSpan('rpc-sync-client:rpcCallback'), Effect.tapCauseLogPretty, Effect.runPromise)
+
+const ResponseChunkEncoded = Schema.Struct({
+  requestId: Schema.String,
+  values: Schema.Array(Schema.Any),
+})

package/src/client/transport/http-rpc-client.ts

@@ -0,0 +1,205 @@
+import { InvalidPullError, InvalidPushError, SyncBackend, UnexpectedError } from '@livestore/common'
+import type { EventSequenceNumber } from '@livestore/common/schema'
+import { omit } from '@livestore/utils'
+import {
+  Chunk,
+  type Duration,
+  Effect,
+  HttpClient,
+  HttpClientRequest,
+  identity,
+  Layer,
+  Option,
+  RpcClient,
+  RpcSerialization,
+  Schedule,
+  Schema,
+  Stream,
+  SubscriptionRef,
+  UrlParams,
+} from '@livestore/utils/effect'
+import { SyncHttpRpc } from '../../common/http-rpc-schema.ts'
+import { SearchParamsSchema } from '../../common/mod.ts'
+import type { SyncMetadata } from '../../common/sync-message-types.ts'
+
+export interface HttpSyncOptions {
+  /**
+   * URL of the sync backend
+   *
+   * @example
+   * ```ts
+   * const syncBackend = makeHttpSync({ url: 'https://sync.example.com' })
+   * ```
+   */
+  url: string
+  headers?: Record<string, string>
+  livePull?: {
+    /**
+     * How often to poll for new events
+     * @default 5 seconds
+     */
+    pollInterval?: Duration.DurationInput
+  }
+  ping?: {
+    /**
+     * @default true
+     */
+    enabled?: boolean
+    /**
+     * How long to wait for a ping response before timing out
+     * @default 10 seconds
+     */
+    requestTimeout?: Duration.DurationInput
+    /**
+     * How often to send ping requests
+     * @default 10 seconds
+     */
+    requestInterval?: Duration.DurationInput
+  }
+}
+
+/**
+ * Note: This implementation requires the `enable_request_signal` compatibility flag to properly support `pull` streaming responses
+ */
+export const makeHttpSync =
+  (options: HttpSyncOptions): SyncBackend.SyncBackendConstructor<SyncMetadata> =>
+  ({ storeId, payload }) =>
+    Effect.gen(function* () {
+      // Based on ping responses
+      const isConnected = yield* SubscriptionRef.make(false)
+
+      const livePullInterval = options.livePull?.pollInterval ?? 5_000
+
+      const urlParamsData = yield* Schema.encode(SearchParamsSchema)({
+        storeId,
+        payload,
+        transport: 'http',
+      }).pipe(UnexpectedError.mapToUnexpectedError)
+
+      const urlParams = UrlParams.fromInput(urlParamsData)
+
+      // Setup HTTP RPC Protocol
+      const HttpProtocolLive = RpcClient.layerProtocolHttp({
+        url: `${options.url}?${UrlParams.toString(urlParams)}`,
+        transformClient: HttpClient.mapRequest((request) =>
+          request.pipe(
+            HttpClientRequest.setHeaders({
+              ...options.headers,
+              // Used in CF Worker to identify the store (additionally to storeId embedded in the RPC requests)
+              'x-livestore-store-id': storeId,
+            }),
+          ),
+        ),
+      }).pipe(Layer.provide(RpcSerialization.layerJson))
+
+      const rpcClient = yield* RpcClient.make(SyncHttpRpc).pipe(Effect.provide(HttpProtocolLive))
+
+      const pingTimeout = options.ping?.requestTimeout ?? 10_000
+
+      const ping: SyncBackend.SyncBackend<SyncMetadata>['ping'] = Effect.gen(function* () {
+        yield* rpcClient.SyncHttpRpc.Ping({ storeId, payload })
+
+        yield* SubscriptionRef.set(isConnected, true)
+      }).pipe(
+        UnexpectedError.mapToUnexpectedError,
+        Effect.timeout(pingTimeout),
+        Effect.catchTag('TimeoutException', () => SubscriptionRef.set(isConnected, false)),
+      )
+
+      const pingInterval = options.ping?.requestInterval ?? 10_000
+
+      if (options.ping?.enabled !== false) {
+        // Automatically ping the server to keep the connection alive
+        yield* ping.pipe(Effect.repeat(Schedule.spaced(pingInterval)), Effect.tapCauseLogPretty, Effect.forkScoped)
+      }
+
+      // Helps already establish a TCP connection to the server
+      const connect = ping.pipe(UnexpectedError.mapToUnexpectedError)
+
+      const backendIdHelper = yield* SyncBackend.makeBackendIdHelper
+
+      const mapCursor = (cursor: Option.Option<{ eventSequenceNumber: number }>) =>
+        cursor.pipe(
+          Option.map((a) => ({
+            eventSequenceNumber: a.eventSequenceNumber as EventSequenceNumber.GlobalEventSequenceNumber,
+            backendId: backendIdHelper.get().pipe(Option.getOrThrow),
+          })),
+        )
+
+      const pull: SyncBackend.SyncBackend<SyncMetadata>['pull'] = (cursor, options) =>
+        rpcClient.SyncHttpRpc.Pull({
+          storeId,
+          payload,
+          cursor: mapCursor(cursor),
+        }).pipe(
+          options?.live
+            ? // Phase 2: Simulate `live` pull by polling for new events
+              Stream.concatWithLastElement((lastElement) => {
+                const initialPhase2Cursor = lastElement.pipe(
+                  Option.flatMap((_) => Option.fromNullable(_.batch.at(-1)?.eventEncoded.seqNum)),
+                  Option.map((eventSequenceNumber) => ({ eventSequenceNumber })),
+                  Option.orElse(() => cursor),
+                  mapCursor,
+                )
+
+                return Stream.unfoldChunkEffect(initialPhase2Cursor, (currentCursor) =>
+                  Effect.gen(function* () {
+                    yield* Effect.sleep(livePullInterval)
+
+                    const items = yield* rpcClient.SyncHttpRpc.Pull({ storeId, payload, cursor: currentCursor }).pipe(
+                      Stream.runCollect,
+                    )
+
+                    const nextCursor = Chunk.last(items).pipe(
+                      Option.flatMap((item) => Option.fromNullable(item.batch.at(-1)?.eventEncoded.seqNum)),
+                      Option.map((eventSequenceNumber) => ({ eventSequenceNumber })),
+                      Option.orElse(() => currentCursor),
+                      mapCursor,
+                    )
+
+                    return Option.some([items, nextCursor])
+                  }),
+                )
+              })
+            : identity,
+          Stream.tap((res) => backendIdHelper.lazySet(res.backendId)),
+          Stream.map((res) => omit(res, ['backendId'])),
+          Stream.mapError((cause) => (cause._tag === 'InvalidPullError' ? cause : InvalidPullError.make({ cause }))),
+          Stream.withSpan('http-sync-client:pull'),
+        )
+
+      const pushSemaphore = yield* Effect.makeSemaphore(1)
+
+      const push: SyncBackend.SyncBackend<SyncMetadata>['push'] = (batch) =>
+        Effect.gen(function* () {
+          if (batch.length === 0) {
+            return
+          }
+
+          yield* rpcClient.SyncHttpRpc.Push({ storeId, payload, batch, backendId: backendIdHelper.get() })
+        }).pipe(
+          pushSemaphore.withPermits(1),
+          Effect.mapError((cause) =>
+            cause._tag === 'InvalidPushError' ? cause : new InvalidPushError({ cause: new UnexpectedError({ cause }) }),
+          ),
+          Effect.withSpan('http-sync-client:push'),
+        )
+
+      return SyncBackend.of({
+        connect,
+        isConnected,
+        pull,
+        push,
+        ping,
+        metadata: {
+          name: '@livestore/cf-sync-http',
+          description: 'LiveStore sync backend implementation using HTTP RPC',
+          protocol: 'http',
+          url: options.url,
+        },
+        supports: {
+          pullPageInfoKnown: true,
+          pullLive: true,
+        },
+      })
+    })

package/src/client/transport/ws-rpc-client.ts

@@ -0,0 +1,182 @@
+import { InvalidPullError, InvalidPushError, IsOfflineError, SyncBackend, UnexpectedError } from '@livestore/common'
+import { omit } from '@livestore/utils'
+import {
+  type Duration,
+  Effect,
+  Layer,
+  Option,
+  RpcClient,
+  RpcSerialization,
+  Schedule,
+  Schema,
+  type Scope,
+  Socket,
+  Stream,
+  SubscriptionRef,
+  UrlParams,
+  type WebSocket,
+} from '@livestore/utils/effect'
+import { SearchParamsSchema } from '../../common/mod.ts'
+import type { SyncMetadata } from '../../common/sync-message-types.ts'
+import { SyncWsRpc } from '../../common/ws-rpc-schema.ts'
+
+export interface WsSyncOptions {
+  /**
+   * URL of the sync backend
+   *
+   * The protocol can either `http`/`https` or `ws`/`wss`
+   *
+   * @example 'https://sync.example.com'
+   */
+  url: string
+  /**
+   * Optional WebSocket factory for custom WebSocket implementations (e.g., Cloudflare Durable Objects)
+   * If not provided, uses standard WebSocket from @livestore/utils/effect
+   */
+  webSocketFactory?: (wsUrl: string) => Effect.Effect<globalThis.WebSocket, WebSocket.WebSocketError, Scope.Scope>
+  ping?: {
+    /**
+     * @default true
+     */
+    enabled?: boolean
+    /**
+     * How long to wait for a ping response before timing out
+     * @default 10 seconds
+     */
+    requestTimeout?: Duration.DurationInput
+    /**
+     * How often to send ping requests
+     * @default 10 seconds
+     */
+    requestInterval?: Duration.DurationInput
+  }
+}
+
+/**
+ * Creates a sync backend that uses WebSocket to communicate with the sync backend.
+ *
+ * @example
+ * ```ts
+ * import { makeWsSync } from '@livestore/sync-cf/client'
+ *
+ * const syncBackend = makeWsSync({ url: 'wss://sync.example.com' })
+ */
+export const makeWsSync =
+  (options: WsSyncOptions): SyncBackend.SyncBackendConstructor<SyncMetadata> =>
+  ({ storeId, payload }) =>
+    Effect.gen(function* () {
+      const urlParamsData = yield* Schema.encode(SearchParamsSchema)({
+        storeId,
+        payload,
+        transport: 'ws',
+      }).pipe(UnexpectedError.mapToUnexpectedError)
+
+      const urlParams = UrlParams.fromInput(urlParamsData)
+      const wsUrl = `${options.url}?${UrlParams.toString(urlParams)}`
+
+      const isConnected = yield* SubscriptionRef.make(false)
+
+      // TODO bring this back in a cross-platform way
+      // If the browser already tells us we're offline, then we'll at least wait until the browser
+      // thinks we're online again. (We'll only know for sure once the WS conneciton is established.)
+      // while (typeof navigator !== 'undefined' && navigator.onLine === false) {
+      //   yield* Effect.sleep(1000)
+      // }
+      // TODO bring this back in a cross-platform way
+      // if (navigator.onLine === false) {
+      //   yield* Effect.async((cb) => self.addEventListener('online', () => cb(Effect.void)))
+      // }
+
+      const pingInterval = options.ping?.requestInterval ?? 10_000
+
+      const ProtocolLive = RpcClient.layerProtocolSocketWithIsConnected({
+        isConnected,
+        retryTransientErrors: Schedule.fixed(1000),
+        pingSchedule: Schedule.once.pipe(Schedule.andThen(Schedule.fixed(pingInterval))),
+        url: wsUrl,
+      }).pipe(
+        Layer.provide(Socket.layerWebSocket(wsUrl)),
+        Layer.provide(Socket.layerWebSocketConstructorGlobal),
+        Layer.provide(RpcSerialization.layerJson),
+      )
+
+      // Warning: we need to build the layer here eagerly to tie it to the scope
+      // instead of using `Effect.provide(ProtocolLive)` which would close the layer scope too early
+      const ctx = yield* Layer.build(ProtocolLive)
+
+      const rpcClient = yield* RpcClient.make(SyncWsRpc).pipe(Effect.provide(ctx))
+
+      const pingTimeout = options.ping?.requestTimeout ?? 10_000
+
+      const ping = Effect.gen(function* () {
+        const pinger = yield* RpcClient.SocketPinger.pipe(Effect.provide(ctx))
+        yield* pinger.ping
+        yield* SubscriptionRef.set(isConnected, true)
+      }).pipe(
+        Effect.timeout(pingTimeout),
+        Effect.catchTag('TimeoutException', () => SubscriptionRef.set(isConnected, false)),
+        UnexpectedError.mapToUnexpectedError,
+        Effect.withSpan('ping'),
+      )
+
+      const backendIdHelper = yield* SyncBackend.makeBackendIdHelper
+
+      return SyncBackend.of<SyncMetadata>({
+        isConnected,
+        connect: ping,
+        pull: (cursor, options) =>
+          rpcClient.SyncWsRpc.Pull({
+            storeId,
+            payload,
+            cursor: cursor.pipe(
+              Option.map((a) => ({
+                eventSequenceNumber: a.eventSequenceNumber,
+                backendId: backendIdHelper.get().pipe(Option.getOrThrow),
+              })),
+            ),
+            live: options?.live ?? false,
+          }).pipe(
+            Stream.tap((res) => backendIdHelper.lazySet(res.backendId)),
+            Stream.map((res) => omit(res, ['backendId'])),
+            Stream.mapError((cause) =>
+              cause._tag === 'RpcClientError' && Socket.isSocketError(cause.cause)
+                ? new IsOfflineError({ cause: cause.cause })
+                : cause._tag === 'InvalidPullError'
+                  ? cause
+                  : InvalidPullError.make({ cause }),
+            ),
+            Stream.withSpan('pull'),
+          ),
+
+        push: (batch) =>
+          Effect.gen(function* () {
+            if (batch.length === 0) {
+              return
+            }
+
+            return yield* rpcClient.SyncWsRpc.Push({
+              storeId,
+              payload,
+              batch,
+              backendId: backendIdHelper.get(),
+            }).pipe(
+              Effect.mapError((cause) =>
+                cause._tag === 'InvalidPushError'
+                  ? cause
+                  : new InvalidPushError({ cause: new UnexpectedError({ cause }) }),
+              ),
+            )
+          }).pipe(Effect.withSpan('push')),
+        ping,
+        metadata: {
+          name: '@livestore/cf-sync',
+          description: 'LiveStore sync backend implementation using Cloudflare Workers & Durable Objects',
+          protocol: 'ws',
+          url: options.url,
+        },
+        supports: {
+          pullPageInfoKnown: true,
+          pullLive: true,
+        },
+      })
+    })

package/src/common/do-rpc-schema.ts

@@ -0,0 +1,54 @@
+import { InvalidPullError, InvalidPushError } from '@livestore/common'
+import { Rpc, RpcGroup, Schema } from '@livestore/utils/effect'
+import * as SyncMessage from './sync-message-types.ts'
+
+const commonPayloadFields = {
+  /**
+   * While the storeId is already implied by the durable object, we still need the explicit storeId
+   * since a DO doesn't know its own id.name value. 🫠
+   * https://community.cloudflare.com/t/how-can-i-get-the-name-of-a-durable-object-from-itself/505961/8
+   */
+  storeId: Schema.String,
+  /** Needed for various reasons (e.g. auth) */
+  payload: Schema.optional(Schema.JsonValue),
+}
+
+export class SyncDoRpc extends RpcGroup.make(
+  Rpc.make('SyncDoRpc.Pull', {
+    payload: {
+      /** Omitting the cursor will start from the beginning */
+      cursor: SyncMessage.PullRequest.fields.cursor,
+      // TODO rename
+      /** Whether to keep the pull stream alive and wait for more events */
+      rpcContext: Schema.optional(
+        Schema.Struct({
+          callerContext: Schema.Struct({
+            bindingName: Schema.String,
+            durableObjectId: Schema.String,
+          }),
+        }),
+      ),
+      ...commonPayloadFields,
+    },
+    success: Schema.Struct({
+      rpcRequestId: Schema.String,
+      ...SyncMessage.PullResponse.fields,
+    }),
+    error: InvalidPullError,
+    stream: true,
+  }),
+  Rpc.make('SyncDoRpc.Push', {
+    payload: {
+      ...SyncMessage.PushRequest.fields,
+      ...commonPayloadFields,
+    },
+    success: SyncMessage.PushAck,
+    error: InvalidPushError,
+  }),
+  Rpc.make('SyncDoRpc.Ping', {
+    payload: {
+      ...commonPayloadFields,
+    },
+    success: Schema.Void,
+  }),
+) {}

package/src/common/http-rpc-schema.ts

@@ -0,0 +1,40 @@
+import { InvalidPullError, InvalidPushError, UnexpectedError } from '@livestore/common'
+import { Rpc, RpcGroup, Schema } from '@livestore/utils/effect'
+import * as SyncMessage from './sync-message-types.ts'
+
+/**
+ * HTTP RPC Schema for LiveStore CF Sync Provider
+ *
+ * This defines the RPC endpoints available over HTTP transport.
+ * Unlike WebSocket transport which maintains persistent connections,
+ * HTTP transport uses request/response patterns for each operation.
+ */
+export class SyncHttpRpc extends RpcGroup.make(
+  Rpc.make('SyncHttpRpc.Pull', {
+    payload: Schema.Struct({
+      storeId: Schema.String,
+      payload: Schema.optional(Schema.JsonValue),
+      ...SyncMessage.PullRequest.fields,
+    }),
+    success: SyncMessage.PullResponse,
+    error: InvalidPullError,
+    stream: true,
+  }),
+  Rpc.make('SyncHttpRpc.Push', {
+    payload: Schema.Struct({
+      storeId: Schema.String,
+      payload: Schema.optional(Schema.JsonValue),
+      ...SyncMessage.PushRequest.fields,
+    }),
+    success: SyncMessage.PushAck,
+    error: InvalidPushError,
+  }),
+  Rpc.make('SyncHttpRpc.Ping', {
+    payload: Schema.Struct({
+      storeId: Schema.String,
+      payload: Schema.optional(Schema.JsonValue),
+    }),
+    success: SyncMessage.Pong,
+    error: UnexpectedError,
+  }),
+) {}

package/src/common/mod.ts

@@ -1,8 +1,15 @@
 import { Schema } from '@livestore/utils/effect'
 
-export * as WSMessage from './ws-message-types.ts'
+export type { CfTypes } from '@livestore/common-cf'
+
+export { SyncHttpRpc } from './http-rpc-schema.ts'
+export * as SyncMessage from './sync-message-types.ts'
 
 export const SearchParamsSchema = Schema.Struct({
   storeId: Schema.String,
   payload: Schema.compose(Schema.StringFromUriComponent, Schema.parseJson(Schema.JsonValue)).pipe(Schema.UndefinedOr),
+  // NOTE `do-rpc` is handled differently
+  transport: Schema.Union(Schema.Literal('http'), Schema.Literal('ws')),
 })
+
+export type SearchParams = typeof SearchParamsSchema.Type