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

package/src/limits.test.ts

@@ -1,6 +1,5 @@
-import { describe, expect, it } from 'vitest'
-
 import type { EventSequenceNumber, LiveStoreEvent } from '@livestore/common/schema'
+import { describe, expect, it } from 'vitest'
 
 import {
   chunkEventsForS2,

package/src/limits.ts

@@ -1,6 +1,6 @@
 import type { LiveStoreEvent } from '@livestore/common/schema'
-import { splitChunkBySize } from '@livestore/common/sync'
-import { Chunk, Effect, Schema } from '@livestore/utils/effect'
+import { splitArrayBySize } from '@livestore/common/sync'
+import { Effect, ReadonlyArray as EffectArray, Schema } from '@livestore/utils/effect'
 
 const textEncoder = new TextEncoder()
 
@@ -19,13 +19,15 @@ export const MAX_BATCH_METERED_BYTES = 1_048_576 // 1 MiB
  */
 export const MAX_RECORDS_PER_BATCH = 1_000
 
-const LimitType = Schema.Literal('record-metered-bytes', 'batch-metered-bytes', 'batch-count')
+const LimitType = Schema.Literals(['record-metered-bytes', 'batch-metered-bytes', 'batch-count'])
 
-export class S2LimitExceededError extends Schema.TaggedError<S2LimitExceededError>('~@livestore/sync-s2/S2LimitExceededError')('S2LimitExceededError', {
+export class S2LimitExceededError extends Schema.TaggedError<S2LimitExceededError>(
+  '~@livestore/sync-s2/S2LimitExceededError',
+)('S2LimitExceededError', {
   limitType: LimitType,
-  max: Schema.Number,
-  actual: Schema.Number,
-  recordIndex: Schema.optional(Schema.Number),
+  max: Schema.Finite,
+  actual: Schema.Finite,
+  recordIndex: Schema.optional(Schema.Finite),
 }) {}
 
 export interface AppendRecordBody {
@@ -89,9 +91,8 @@ const convertEventsToPrepared = (events: ReadonlyArray<LiveStoreEvent.Global.Enc
 const makeChunkMeasure = (items: ReadonlyArray<PreparedEvent>): number =>
   items.reduce((acc, item) => acc + item.meteredBytes, 0)
 
-const mapPreparedChunks = (chunks: Chunk.Chunk<Chunk.Chunk<PreparedEvent>>): ReadonlyArray<S2Chunk> =>
-  Chunk.toReadonlyArray(chunks).map((chunk) => {
-    const chunkItems = Chunk.toReadonlyArray(chunk)
+const mapPreparedChunks = (chunks: ReadonlyArray<ReadonlyArray<PreparedEvent>>): ReadonlyArray<S2Chunk> =>
+  chunks.map((chunkItems) => {
     const events = chunkItems.map((item) => item.event)
     const records = chunkItems.map((item) => item.record)
     return {
@@ -102,22 +103,19 @@ const mapPreparedChunks = (chunks: Chunk.Chunk<Chunk.Chunk<PreparedEvent>>): Rea
   })
 
 export const chunkEventsForS2 = (events: ReadonlyArray<LiveStoreEvent.Global.Encoded>): ReadonlyArray<S2Chunk> => {
-  if (events.length === 0) {
+  const prepared = convertEventsToPrepared(events)
+
+  if (EffectArray.isReadonlyArrayNonEmpty(prepared) === false) {
     return []
   }
 
-  const prepared = convertEventsToPrepared(events)
-
   try {
-    const chunks = Chunk.fromIterable(prepared).pipe(
-      splitChunkBySize({
-        maxItems: MAX_RECORDS_PER_BATCH,
-        maxBytes: MAX_BATCH_METERED_BYTES,
-        encode: (items) => ({ records: items.map((item) => item.record) }),
-        measure: makeChunkMeasure,
-      }),
-      Effect.runSync,
-    )
+    const chunks = splitArrayBySize<PreparedEvent>({
+      maxItems: MAX_RECORDS_PER_BATCH,
+      maxBytes: MAX_BATCH_METERED_BYTES,
+      encode: (items) => ({ records: items.map((item) => item.record) }),
+      measure: makeChunkMeasure,
+    })(prepared).pipe(Effect.runSync)
 
     return mapPreparedChunks(chunks)
   } catch (error) {

package/src/make-s2-url.ts

@@ -1,5 +1,5 @@
 import { shouldNeverHappen } from '@livestore/utils'
-import { Schema } from '@livestore/utils/effect'
+import { Result, Schema } from '@livestore/utils/effect'
 
 import * as ApiSchema from './api-schema.ts'
 
@@ -8,11 +8,11 @@ export const makeS2StreamName = (storeId: string) => storeId.replace(/[^a-zA-Z0-
 /**
  * Decode `args` from URLSearchParams using Effect Schema, mirroring Electric's approach.
  */
-export const decodePullArgsFromSearchParams = (searchParams: URLSearchParams): typeof ApiSchema.PullArgs.Type => {
+export const decodePullArgsFromSearchParams = (searchParams: URLSearchParams): ApiSchema.PullArgs => {
   const UrlParamsSchema = Schema.Struct({ args: ApiSchema.ArgsSchema })
-  const argsResult = Schema.decodeUnknownEither(UrlParamsSchema)(Object.fromEntries(searchParams.entries()))
+  const argsResult = Schema.decodeUnknownResult(UrlParamsSchema)(Object.fromEntries(searchParams.entries()))
 
-  if (argsResult._tag === 'Left') {
+  if (Result.isFailure(argsResult) === true) {
     return shouldNeverHappen(
       'Invalid search params provided to decodePullArgsFromSearchParams',
       searchParams,
@@ -20,5 +20,5 @@ export const decodePullArgsFromSearchParams = (searchParams: URLSearchParams): t
     )
   }
 
-  return argsResult.right.args
+  return argsResult.success.args
 }

package/src/sync-provider.ts

@@ -37,16 +37,17 @@ import { shouldNeverHappen } from '@livestore/utils'
 import {
   type Duration,
   Effect,
+  Filter,
   HttpClient,
   HttpClientRequest,
   HttpClientResponse,
   Option,
   Schedule,
   Schema,
-  Sse,
   Stream,
   SubscriptionRef,
 } from '@livestore/utils/effect'
+import { Sse } from 'effect/encoding'
 
 import * as ApiSchema from './api-schema.ts'
 import { decodeReadBatch } from './decode.ts'
@@ -66,9 +67,9 @@ export interface SyncS2Options {
     /** Enable periodic ping; default true */
     enabled?: boolean
     /** Timeout for individual ping request; default 10s */
-    requestTimeout?: Duration.DurationInput
+    requestTimeout?: Duration.Input
     /** Interval between ping requests; default 10s */
-    requestInterval?: Duration.DurationInput
+    requestInterval?: Duration.Input
   }
   retry?: {
     /** Custom retry schedule for non-live pulls (default: 2 recurs, 100ms spaced) */
@@ -78,7 +79,7 @@ export interface SyncS2Options {
   }
 }
 
-export const defaultRetry = Schedule.compose(Schedule.recurs(2), Schedule.spaced(100))
+export const defaultRetry = Schedule.recurs(2).pipe(Schedule.addDelay(() => Effect.succeed(100)))
 
 const getBrowserOrigin = () => {
   if (typeof globalThis !== 'object' || globalThis === null || !('location' in globalThis)) {
@@ -114,8 +115,10 @@ export const makeSyncBackend =
         yield* SubscriptionRef.set(isConnected, true)
       }).pipe(
         UnknownError.mapToUnknownError,
-        Effect.timeout(pingTimeout),
-        Effect.catchTag('TimeoutException', () => SubscriptionRef.set(isConnected, false)),
+        Effect.timeoutOrElse({
+          duration: pingTimeout,
+          orElse: () => SubscriptionRef.set(isConnected, false),
+        }),
       )
 
       const pingInterval = pingOptions?.requestInterval ?? 10_000
@@ -149,8 +152,8 @@ export const makeSyncBackend =
           .pipe(
             HttpClientResponse.stream,
             // decode text and split into lines
-            Stream.decodeText('utf8'),
-            Stream.pipeThroughChannel(Sse.makeChannel()),
+            Stream.decodeText({ encoding: 'utf8' }),
+            Stream.pipeThroughChannel(Sse.decode()),
             // Filter out pings, map errors to stream failures
             Stream.mapEffect(
               Effect.fnUntraced(function* (msg) {
@@ -160,7 +163,9 @@ export const makeSyncBackend =
                   return yield* new UnknownError({ cause: new Error(`SSE error: ${msg.data}`) })
                 }
                 if (evt === 'batch') {
-                  const readBatch = yield* Schema.decode(Schema.parseJson(HttpClientGenerated.ReadBatch))(msg.data)
+                  const readBatch = yield* Schema.decodeEffect(Schema.fromJsonString(HttpClientGenerated.ReadBatch))(
+                    msg.data,
+                  )
                   const batch = decodeReadBatch(readBatch)
 
                   const lastS2SeqNum = batch.at(-1)?.metadata.pipe(
@@ -188,10 +193,8 @@ export const makeSyncBackend =
                 return shouldNeverHappen(`Unexpected SSE event: ${evt}`, msg)
               }),
             ),
-            Stream.filterMap((_) => _), // filter out Option.none()
-            Stream.mapError((cause) =>
-              cause._tag === 'UnknownError' ? cause : new UnknownError({ cause }),
-            ),
+            Stream.filterMap(Filter.fromPredicateOption((_) => _)), // filter out Option.none()
+            Stream.mapError((cause) => (cause._tag === 'UnknownError' ? cause : new UnknownError({ cause }))),
             Stream.retry(retry?.pull ?? defaultRetry),
           )
       }

package/src/types.ts

@@ -12,7 +12,7 @@ import { Brand, Schema } from '@livestore/utils/effect'
  */
 export type S2SeqNum = Brand.Branded<number, 'S2SeqNum'>
 export const s2SeqNum = Brand.nominal<S2SeqNum>()
-export const S2SeqNum = Schema.fromBrand(s2SeqNum)(Schema.Int.pipe(Schema.greaterThanOrEqualTo(0)))
+export const S2SeqNum = Schema.fromBrand('S2SeqNum', s2SeqNum)(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)))
 
 /**
  * Metadata for tracking S2-specific cursor information.