@livestore/sync-cf 0.4.0 → 0.5.0-dev.1

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

@@ -1,13 +1,12 @@
-import { IsOfflineError, SyncBackend, UnknownError } from '@livestore/common'
+import { SyncBackend, UnknownError } from '@livestore/common'
 import type { LiveStoreEvent } from '@livestore/common/schema'
-import { splitChunkBySize } from '@livestore/common/sync'
-import { omit } from '@livestore/utils'
+import { splitArrayBySize } from '@livestore/common/sync'
 import {
-  Chunk,
-  type Duration,
+  Duration,
   Effect,
   Layer,
   Option,
+  ReadonlyArray as EffectArray,
   RpcClient,
   RpcSerialization,
   Schedule,
@@ -15,6 +14,7 @@ import {
   type Scope,
   Socket,
   Stream,
+  Struct,
   SubscriptionRef,
   UrlParams,
 } from '@livestore/utils/effect'
@@ -24,6 +24,7 @@ import { MAX_PUSH_EVENTS_PER_REQUEST, MAX_WS_MESSAGE_BYTES } from '../../common/
 import { SearchParamsSchema } from '../../common/mod.ts'
 import type { SyncMetadata } from '../../common/sync-message-types.ts'
 import { SyncWsRpc } from '../../common/ws-rpc-schema.ts'
+import { mapRpcClientError } from './rpc-client-error.ts'
 
 export interface WsSyncOptions {
   /**
@@ -48,12 +49,12 @@ export interface WsSyncOptions {
      * How long to wait for a ping response before timing out
      * @default 10 seconds
      */
-    requestTimeout?: Duration.DurationInput
+    requestTimeout?: Duration.Input
     /**
      * How often to send ping requests
      * @default 10 seconds
      */
-    requestInterval?: Duration.DurationInput
+    requestInterval?: Duration.Input
   }
 }
 
@@ -70,7 +71,7 @@ export const makeWsSync =
   (options: WsSyncOptions): SyncBackend.SyncBackendConstructor<SyncMetadata> =>
   ({ storeId, payload }) =>
     Effect.gen(function* () {
-      const urlParamsData = yield* Schema.encode(SearchParamsSchema)({
+      const urlParamsData = yield* Schema.encodeEffect(SearchParamsSchema)({
         storeId,
         payload,
         transport: 'ws',
@@ -89,7 +90,7 @@ export const makeWsSync =
       // }
       // TODO bring this back in a cross-platform way
       // if (navigator.onLine === false) {
-      //   yield* Effect.async((cb) => self.addEventListener('online', () => cb(Effect.void)))
+      //   yield* Effect.callback((cb) => self.addEventListener('online', () => cb(Effect.void)))
       // }
 
       const pingInterval = options.ping?.requestInterval ?? 10_000
@@ -97,10 +98,10 @@ export const makeWsSync =
       const ProtocolLive = RpcClient.layerProtocolSocketWithIsConnected({
         isConnected,
         retryTransientErrors: Schedule.exponential('1 seconds').pipe(
-          Schedule.union(Schedule.fixed('30 seconds')),
+          Schedule.modifyDelay(({ duration }) => Effect.succeed(Duration.min(duration, Duration.seconds(30)))),
           Schedule.jittered,
         ),
-        pingSchedule: Schedule.once.pipe(Schedule.andThen(Schedule.fixed(pingInterval))),
+        pingSchedule: Schedule.recurs(1).pipe(Schedule.concat(Schedule.fixed(pingInterval))),
         url: wsUrl,
       }).pipe(
         Layer.provide(Socket.layerWebSocket(wsUrl)),
@@ -121,8 +122,10 @@ export const makeWsSync =
         yield* pinger.ping
         yield* SubscriptionRef.set(isConnected, true)
       }).pipe(
-        Effect.timeout(pingTimeout),
-        Effect.catchTag('TimeoutException', () => SubscriptionRef.set(isConnected, false)),
+        Effect.timeoutOrElse({
+          duration: pingTimeout,
+          orElse: () => SubscriptionRef.set(isConnected, false),
+        }),
         UnknownError.mapToUnknownError,
         Effect.withSpan('ping'),
       )
@@ -133,7 +136,7 @@ export const makeWsSync =
         isConnected,
         connect: ping,
         pull: (cursor, options) =>
-          rpcClient.SyncWsRpc.Pull({
+          rpcClient['SyncWsRpc.Pull']({
             storeId,
             payload,
             cursor: cursor.pipe(
@@ -145,10 +148,10 @@ export const makeWsSync =
             live: options?.live === true,
           }).pipe(
             Stream.tap((res) => backendIdHelper.lazySet(res.backendId)),
-            Stream.map((res) => omit(res, ['backendId'])),
+            Stream.map((res) => Struct.omit(res, ['backendId'])),
             Stream.mapError((cause) =>
-              cause._tag === 'RpcClientError' && Socket.isSocketError(cause.cause) === true
-                ? new IsOfflineError({ cause: cause.cause })
+              cause._tag === 'RpcClientError'
+                ? mapRpcClientError(cause)
                 : cause._tag === 'UnknownError' || cause._tag === 'BackendIdMismatchError'
                   ? cause
                   : new UnknownError({ cause }),
@@ -166,26 +169,31 @@ export const makeWsSync =
             backendId: backendIdHelper.get(),
           })
 
-          const chunksChunk = yield* Chunk.fromIterable(batch).pipe(
-            splitChunkBySize({
-              maxItems: MAX_PUSH_EVENTS_PER_REQUEST,
-              maxBytes: MAX_WS_MESSAGE_BYTES,
-              encode: encodePayload,
-            }),
-            Effect.mapError((cause) => new UnknownError({ cause })),
-          )
-
-          for (const sub of chunksChunk) {
-            yield* rpcClient.SyncWsRpc.Push({
+          if (EffectArray.isReadonlyArrayNonEmpty(batch) === false) {
+            return
+          }
+
+          const batchChunks = yield* splitArrayBySize({
+            maxItems: MAX_PUSH_EVENTS_PER_REQUEST,
+            maxBytes: MAX_WS_MESSAGE_BYTES,
+            encode: encodePayload,
+          })(batch).pipe(Effect.mapError((cause) => new UnknownError({ cause })))
+
+          for (const batchChunk of batchChunks) {
+            yield* rpcClient['SyncWsRpc.Push']({
               storeId,
               payload,
-              batch: Chunk.toReadonlyArray(sub),
+              batch: batchChunk,
               backendId: backendIdHelper.get(),
             }).pipe(
               Effect.mapError((cause) =>
-                cause._tag === 'UnknownError' || cause._tag === 'ServerAheadError' || cause._tag === 'BackendIdMismatchError'
-                  ? cause
-                  : new UnknownError({ cause }),
+                cause._tag === 'RpcClientError'
+                  ? mapRpcClientError(cause)
+                  : cause._tag === 'UnknownError' ||
+                      cause._tag === 'ServerAheadError' ||
+                      cause._tag === 'BackendIdMismatchError'
+                    ? cause
+                    : new UnknownError({ cause }),
               ),
             )
           }

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

@@ -11,7 +11,7 @@ const commonPayloadFields = {
    */
   storeId: Schema.String,
   /** Needed for various reasons (e.g. auth) */
-  payload: Schema.optional(Schema.JsonValue),
+  payload: Schema.optional(Schema.Json),
 }
 
 export class SyncDoRpc extends RpcGroup.make(
@@ -35,7 +35,7 @@ export class SyncDoRpc extends RpcGroup.make(
       rpcRequestId: Schema.String,
       ...SyncMessage.PullResponse.fields,
     }),
-    error: Schema.Union(UnknownError, BackendIdMismatchError),
+    error: Schema.Union([UnknownError, BackendIdMismatchError]),
     stream: true,
   }),
   Rpc.make('SyncDoRpc.Push', {
@@ -44,7 +44,7 @@ export class SyncDoRpc extends RpcGroup.make(
       ...commonPayloadFields,
     },
     success: SyncMessage.PushAck,
-    error: Schema.Union(UnknownError, ServerAheadError, BackendIdMismatchError),
+    error: Schema.Union([UnknownError, ServerAheadError, BackendIdMismatchError]),
   }),
   Rpc.make('SyncDoRpc.Ping', {
     payload: {
@@ -52,4 +52,14 @@ export class SyncDoRpc extends RpcGroup.make(
     },
     success: Schema.Void,
   }),
+  Rpc.make('SyncDoRpc.Unsubscribe', {
+    payload: {
+      /** Client DO id whose live-pull subscription row to drop. */
+      durableObjectId: Schema.String,
+      /** Request id of the live pull that registered the row; the row is only dropped if it still matches. */
+      requestId: Schema.String,
+      ...commonPayloadFields,
+    },
+    success: Schema.Void,
+  }),
 ) {}

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

@@ -14,26 +14,26 @@ export class SyncHttpRpc extends RpcGroup.make(
   Rpc.make('SyncHttpRpc.Pull', {
     payload: Schema.Struct({
       storeId: Schema.String,
-      payload: Schema.optional(Schema.JsonValue),
+      payload: Schema.optional(Schema.Json),
       ...SyncMessage.PullRequest.fields,
     }),
     success: SyncMessage.PullResponse,
-    error: Schema.Union(UnknownError, BackendIdMismatchError),
+    error: Schema.Union([UnknownError, BackendIdMismatchError]),
     stream: true,
   }),
   Rpc.make('SyncHttpRpc.Push', {
     payload: Schema.Struct({
       storeId: Schema.String,
-      payload: Schema.optional(Schema.JsonValue),
+      payload: Schema.optional(Schema.Json),
       ...SyncMessage.PushRequest.fields,
     }),
     success: SyncMessage.PushAck,
-    error: Schema.Union(UnknownError, ServerAheadError, BackendIdMismatchError),
+    error: Schema.Union([UnknownError, ServerAheadError, BackendIdMismatchError]),
   }),
   Rpc.make('SyncHttpRpc.Ping', {
     payload: Schema.Struct({
       storeId: Schema.String,
-      payload: Schema.optional(Schema.JsonValue),
+      payload: Schema.optional(Schema.Json),
     }),
     success: SyncMessage.Pong,
     error: UnknownError,

package/src/common/mod.ts

@@ -1,17 +1,17 @@
-import { OversizeChunkItemError, splitChunkBySize } from '@livestore/common/sync'
+export { OversizeChunkItemError, splitArrayBySize } from '@livestore/common/sync'
 import { Schema } from '@livestore/utils/effect'
 
 export type { CfTypes } from '@livestore/common-cf'
 export * from './constants.ts'
+export { SyncDoRpc } from './do-rpc-schema.ts'
 export { SyncHttpRpc } from './http-rpc-schema.ts'
 export * as SyncMessage from './sync-message-types.ts'
-export { OversizeChunkItemError, splitChunkBySize }
 
 export const SearchParamsSchema = Schema.Struct({
   storeId: Schema.String,
-  payload: Schema.compose(Schema.StringFromUriComponent, Schema.parseJson(Schema.JsonValue)).pipe(Schema.UndefinedOr),
+  payload: Schema.optional(Schema.StringFromUriComponent.pipe(Schema.decodeTo(Schema.fromJsonString(Schema.Json)))),
   // NOTE `do-rpc` is handled differently
-  transport: Schema.Literal('http', 'ws'),
+  transport: Schema.Literals(['http', 'ws']),
 })
 
 export type SearchParams = typeof SearchParamsSchema.Type

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

@@ -11,7 +11,7 @@ import { Schema } from '@livestore/utils/effect'
 export const SyncMetadata = Schema.TaggedStruct('SyncMessage.SyncMetadata', {
   /** ISO date format */
   createdAt: Schema.String,
-}).annotations({ title: '@livestore/sync-cf:SyncMetadata' })
+}).annotate({ title: '@livestore/sync-cf:SyncMetadata' })
 
 export type SyncMetadata = typeof SyncMetadata.Type
 
@@ -23,7 +23,7 @@ export const PullRequest = Schema.Struct({
       eventSequenceNumber: EventSequenceNumber.Global.Schema,
     }),
   ),
-}).annotations({ title: '@livestore/sync-cf:PullRequest' })
+}).annotate({ title: '@livestore/sync-cf:PullRequest' })
 
 export type PullRequest = typeof PullRequest.Type
 
@@ -36,7 +36,7 @@ export const PullResponse = Schema.Struct({
   ),
   pageInfo: SyncBackend.PullResPageInfo,
   backendId: BackendId,
-}).annotations({ title: '@livestore/sync-cf:PullResponse' })
+}).annotate({ title: '@livestore/sync-cf:PullResponse' })
 
 export const emptyPullResponse = (backendId: string) =>
   PullResponse.make({
@@ -50,32 +50,32 @@ export type PullResponse = typeof PullResponse.Type
 export const PushRequest = Schema.Struct({
   batch: Schema.Array(LiveStoreEvent.Global.Encoded),
   backendId: Schema.Option(BackendId),
-}).annotations({ title: '@livestore/sync-cf:PushRequest' })
+}).annotate({ title: '@livestore/sync-cf:PushRequest' })
 
 export type PushRequest = typeof PushRequest.Type
 
-export const PushAck = Schema.Struct({}).annotations({
+export const PushAck = Schema.Struct({}).annotate({
   title: '@livestore/sync-cf:PushAck',
 })
 
 export type PushAck = typeof PushAck.Type
 
-export const Ping = Schema.TaggedStruct('SyncMessage.Ping', {}).annotations({ title: '@livestore/sync-cf:Ping' })
+export const Ping = Schema.TaggedStruct('SyncMessage.Ping', {}).annotate({ title: '@livestore/sync-cf:Ping' })
 
 export type Ping = typeof Ping.Type
 
-export const Pong = Schema.TaggedStruct('SyncMessage.Pong', {}).annotations({ title: '@livestore/sync-cf:Pong' })
+export const Pong = Schema.TaggedStruct('SyncMessage.Pong', {}).annotate({ title: '@livestore/sync-cf:Pong' })
 
 export type Pong = typeof Pong.Type
 
 // Admin operations
 export const AdminResetRoomRequest = Schema.TaggedStruct('SyncMessage.AdminResetRoomRequest', {
   adminSecret: Schema.String,
-}).annotations({ title: '@livestore/sync-cf:AdminResetRoomRequest' })
+}).annotate({ title: '@livestore/sync-cf:AdminResetRoomRequest' })
 
 export type AdminResetRoomRequest = typeof AdminResetRoomRequest.Type
 
-export const AdminResetRoomResponse = Schema.TaggedStruct('SyncMessage.AdminResetRoomResponse', {}).annotations({
+export const AdminResetRoomResponse = Schema.TaggedStruct('SyncMessage.AdminResetRoomResponse', {}).annotate({
   title: '@livestore/sync-cf:AdminResetRoomResponse',
 })
 
@@ -83,7 +83,7 @@ export type AdminResetRoomResponse = typeof AdminResetRoomResponse.Type
 
 export const AdminInfoRequest = Schema.TaggedStruct('SyncMessage.AdminInfoRequest', {
   adminSecret: Schema.String,
-}).annotations({ title: '@livestore/sync-cf:AdminInfoRequest' })
+}).annotate({ title: '@livestore/sync-cf:AdminInfoRequest' })
 
 export type AdminInfoRequest = typeof AdminInfoRequest.Type
 
@@ -91,27 +91,27 @@ export const AdminInfoResponse = Schema.TaggedStruct('SyncMessage.AdminInfoRespo
   info: Schema.Struct({
     durableObjectId: Schema.String,
   }),
-}).annotations({ title: '@livestore/sync-cf:AdminInfoResponse' })
+}).annotate({ title: '@livestore/sync-cf:AdminInfoResponse' })
 
 export type AdminInfoResponse = typeof AdminInfoResponse.Type
 
-export const BackendToClientMessage = Schema.Union(
+export const BackendToClientMessage = Schema.Union([
   PullResponse,
   PushAck,
   Pong,
   AdminResetRoomResponse,
   AdminInfoResponse,
-)
+])
 export type BackendToClientMessage = typeof BackendToClientMessage.Type
 
-export const ClientToBackendMessage = Schema.Union(
+export const ClientToBackendMessage = Schema.Union([
   PullRequest,
   PushRequest,
   Ping,
   AdminResetRoomRequest,
   AdminInfoRequest,
-)
+])
 export type ClientToBackendMessage = typeof ClientToBackendMessage.Type
 
-export const Message = Schema.Union(BackendToClientMessage, ClientToBackendMessage)
+export const Message = Schema.Union([BackendToClientMessage, ClientToBackendMessage])
 export type Message = typeof Message.Type

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

@@ -14,23 +14,23 @@ export class SyncWsRpc extends RpcGroup.make(
   Rpc.make('SyncWsRpc.Pull', {
     payload: Schema.Struct({
       storeId: Schema.String,
-      payload: Schema.optional(Schema.JsonValue),
+      payload: Schema.optional(Schema.Json),
       /** Whether to keep the pull stream alive and wait for more events */
       live: Schema.Boolean,
       ...SyncMessage.PullRequest.fields,
     }),
     success: SyncMessage.PullResponse,
-    error: Schema.Union(UnknownError, BackendIdMismatchError),
+    error: Schema.Union([UnknownError, BackendIdMismatchError]),
     stream: true,
   }),
   Rpc.make('SyncWsRpc.Push', {
     payload: Schema.Struct({
       storeId: Schema.String,
-      payload: Schema.optional(Schema.JsonValue),
+      payload: Schema.optional(Schema.Json),
       ...SyncMessage.PushRequest.fields,
     }),
     success: SyncMessage.PushAck,
-    error: Schema.Union(UnknownError, ServerAheadError, BackendIdMismatchError),
+    error: Schema.Union([UnknownError, ServerAheadError, BackendIdMismatchError]),
   }),
   // Ping <> Pong is handled by DO WS auto-response
   // TODO add admin RPCs