@livestore/utils 0.4.0-dev.3 → 0.4.0-dev.5

package/src/effect/RpcClient.ts

@@ -0,0 +1,204 @@
+export * from '@effect/rpc/RpcClient'
+
+import { Socket } from '@effect/platform'
+import { RpcClient, RpcClientError, RpcSerialization } from '@effect/rpc'
+import { Protocol } from '@effect/rpc/RpcClient'
+import { constPing, type FromServerEncoded } from '@effect/rpc/RpcMessage'
+import { Cause, Deferred, Effect, Layer, Option, Schedule, type Scope } from 'effect'
+import { constVoid, identity } from 'effect/Function'
+import * as SubscriptionRef from './SubscriptionRef.ts'
+
+// This is based on `makeProtocolSocket` / `layerProtocolSocket` from `@effect/rpc` in order to:
+// - Add a `isConnected` subscription ref to track the connection state
+// - Add a ping schedule to the socket
+// - Add a retry schedule to the socket
+
+export const layerProtocolSocketWithIsConnected = (options: {
+  readonly url: string
+  readonly retryTransientErrors?: Schedule.Schedule<unknown> | undefined
+  readonly isConnected: SubscriptionRef.SubscriptionRef<boolean>
+  readonly pingSchedule?: Schedule.Schedule<unknown> | undefined
+}): Layer.Layer<Protocol, never, RpcSerialization.RpcSerialization | Socket.Socket> =>
+  Layer.scoped(Protocol, makeProtocolSocketWithIsConnected(options))
+
+export const makeProtocolSocketWithIsConnected = (options: {
+  readonly url: string
+  readonly retryTransientErrors?: Schedule.Schedule<unknown> | undefined
+  // CHANGED: add isConnected subscription ref
+  readonly isConnected: SubscriptionRef.SubscriptionRef<boolean>
+  // CHANGED: add ping schedule
+  readonly pingSchedule?: Schedule.Schedule<unknown> | undefined
+}): Effect.Effect<Protocol['Type'], never, Scope.Scope | RpcSerialization.RpcSerialization | Socket.Socket> =>
+  Protocol.make(
+    Effect.fnUntraced(function* (writeResponse) {
+      const socket = yield* Socket.Socket
+      const serialization = yield* RpcSerialization.RpcSerialization
+
+      const write = yield* socket.writer
+      const parser = serialization.unsafeMake()
+
+      const pinger = yield* makePinger(write(parser.encode(constPing)!), options?.pingSchedule)
+
+      yield* Effect.suspend(() => {
+        // CHANGED: don't reset parser on every message
+        // parser = serialization.unsafeMake()
+        pinger.reset()
+        return socket
+          .runRaw((message) => {
+            try {
+              const responses = parser.decode(message) as Array<FromServerEncoded>
+              if (responses.length === 0) return
+              let i = 0
+              return Effect.whileLoop({
+                while: () => i < responses.length,
+                body: () => {
+                  const response = responses[i++]!
+                  if (response._tag === 'Pong') {
+                    pinger.onPong()
+                  }
+                  return writeResponse(response).pipe(
+                    // CHANGED: set isConnected to true on pong
+                    Effect.tap(
+                      Effect.fn(function* () {
+                        if (options?.isConnected !== undefined) {
+                          yield* SubscriptionRef.set(options.isConnected, true)
+                        }
+                      }),
+                    ),
+                  )
+                },
+                step: constVoid,
+              })
+            } catch (defect) {
+              return writeResponse({
+                _tag: 'ClientProtocolError',
+                error: new RpcClientError.RpcClientError({
+                  reason: 'Protocol',
+                  message: 'Error decoding message',
+                  cause: Cause.fail(defect),
+                }),
+              })
+            }
+          })
+          .pipe(
+            Effect.raceFirst(
+              Effect.zipRight(
+                pinger.timeout,
+                Effect.fail(
+                  new Socket.SocketGenericError({
+                    reason: 'OpenTimeout',
+                    cause: new Error('ping timeout'),
+                  }),
+                ),
+              ),
+            ),
+          )
+      }).pipe(
+        Effect.zipRight(
+          Effect.fail(
+            new Socket.SocketCloseError({
+              reason: 'Close',
+              code: 1000,
+              closeReason: 'Closing connection',
+            }),
+          ),
+        ),
+        Effect.tapErrorCause(
+          Effect.fn(function* (cause) {
+            // CHANGED: set isConnected to false on error
+            if (options?.isConnected !== undefined) {
+              yield* SubscriptionRef.set(options.isConnected, false)
+            }
+
+            const error = Cause.failureOption(cause)
+            if (
+              options?.retryTransientErrors &&
+              Option.isSome(error) &&
+              (error.value.reason === 'Open' || error.value.reason === 'OpenTimeout')
+            ) {
+              return
+            }
+            return yield* writeResponse({
+              _tag: 'ClientProtocolError',
+              error: new RpcClientError.RpcClientError({
+                reason: 'Protocol',
+                message: 'Error in socket',
+                cause: Cause.squash(cause),
+              }),
+            })
+          }),
+        ),
+        // CHANGED: make configurable via schedule
+        options?.retryTransientErrors ? Effect.retry(options.retryTransientErrors) : identity,
+        Effect.annotateLogs({
+          module: 'RpcClient',
+          method: 'makeProtocolSocket',
+        }),
+        Effect.interruptible,
+        Effect.ignore, // Errors are already handled
+        Effect.provide(Layer.setUnhandledErrorLogLevel(Option.none())),
+        Effect.forkScoped,
+      )
+
+      return {
+        send: (request) => {
+          const encoded = parser.encode(request)
+          if (encoded === undefined) return Effect.void
+
+          return Effect.orDie(write(encoded))
+        },
+        supportsAck: true,
+        supportsTransferables: false,
+        pinger,
+      }
+    }),
+  )
+
+export const SocketPinger = Effect.map(RpcClient.Protocol, (protocol) => (protocol as any).pinger as SocketPinger)
+
+export type SocketPinger = Effect.Effect.Success<ReturnType<typeof makePinger>>
+
+const makePinger = Effect.fnUntraced(function* <A, E, R>(
+  writePing: Effect.Effect<A, E, R>,
+  pingSchedule: Schedule.Schedule<unknown> = Schedule.spaced(10000).pipe(Schedule.addDelay(() => 5000)),
+) {
+  // CHANGED: add manual ping deferreds
+  const manualPingDeferreds = new Set<Deferred.Deferred<void, never>>()
+
+  let recievedPong = true
+  const latch = Effect.unsafeMakeLatch()
+  const reset = () => {
+    recievedPong = true
+    latch.unsafeClose()
+  }
+  const onPong = () => {
+    recievedPong = true
+    // CHANGED: mark all manual ping deferreds as done
+    for (const deferred of manualPingDeferreds) {
+      Deferred.unsafeDone(deferred, Effect.void)
+    }
+  }
+  yield* Effect.suspend(() => {
+    // Starting new ping
+    if (!recievedPong) return latch.open
+    recievedPong = false
+    return writePing
+  }).pipe(
+    // CHANGED: make configurable via schedule
+    Effect.schedule(pingSchedule),
+    Effect.ignore,
+    Effect.forever,
+    Effect.interruptible,
+    Effect.forkScoped,
+  )
+
+  // CHANGED: add manual ping
+  const ping = Effect.gen(function* () {
+    const deferred = yield* Deferred.make<void, never>()
+    manualPingDeferreds.add(deferred)
+    yield* deferred
+    manualPingDeferreds.delete(deferred)
+  })
+
+  return { timeout: latch.await, reset, onPong, ping } as const
+})

package/src/effect/Schema/index.ts

@@ -8,7 +8,6 @@ import { shouldNeverHappen } from '../../mod.ts'
 
 export * from 'effect/Schema'
 export * from './debug-diff.ts'
-export * from './msgpack.ts'
 
 // NOTE this is a temporary workaround until Effect schema has a better way to hash schemas
 // https://github.com/Effect-TS/effect/issues/2719

package/src/effect/Stream.test.ts

@@ -0,0 +1,127 @@
+import { Effect, Option, Stream } from 'effect'
+import { describe, expect, it } from 'vitest'
+import { concatWithLastElement, runCollectReadonlyArray } from './Stream.ts'
+
+describe('concatWithLastElement', () => {
+  it('should concatenate streams with access to last element of first stream', async () => {
+    const stream1 = Stream.make(1, 2, 3)
+    const result = concatWithLastElement(stream1, (lastElement) =>
+      lastElement.pipe(
+        Option.match({
+          onNone: () => Stream.make('no-previous'),
+          onSome: (last) => Stream.make(`last-was-${last}`, 'continuing'),
+        }),
+      ),
+    )
+
+    const collected = await Effect.runPromise(runCollectReadonlyArray(result))
+    expect(collected).toEqual([1, 2, 3, 'last-was-3', 'continuing'])
+  })
+
+  it('should handle empty first stream', async () => {
+    const stream1 = Stream.empty
+    const result = concatWithLastElement(stream1, (lastElement) =>
+      lastElement.pipe(
+        Option.match({
+          onNone: () => Stream.make('no-previous-element'),
+          onSome: (last) => Stream.make(`last-was-${last}`),
+        }),
+      ),
+    )
+
+    const collected = await Effect.runPromise(runCollectReadonlyArray(result))
+    expect(collected).toEqual(['no-previous-element'])
+  })
+
+  it('should handle single element first stream', async () => {
+    const stream1 = Stream.make('single')
+    const result = concatWithLastElement(stream1, (lastElement) =>
+      lastElement.pipe(
+        Option.match({
+          onNone: () => Stream.make('unexpected'),
+          onSome: (last) => Stream.make(`after-${last}`),
+        }),
+      ),
+    )
+
+    const collected = await Effect.runPromise(runCollectReadonlyArray(result))
+    expect(collected).toEqual(['single', 'after-single'])
+  })
+
+  it('should handle empty second stream', async () => {
+    const stream1 = Stream.make(1, 2, 3)
+    const result = concatWithLastElement(stream1, () => Stream.empty)
+
+    const collected = await Effect.runPromise(runCollectReadonlyArray(result))
+    expect(collected).toEqual([1, 2, 3])
+  })
+
+  it('should preserve error handling from first stream', async () => {
+    const stream1 = Stream.fail('first-error')
+    const result = concatWithLastElement(stream1, () => Stream.make('should-not-reach'))
+
+    const outcome = await Effect.runPromise(Effect.either(runCollectReadonlyArray(result)))
+    expect(outcome._tag).toBe('Left')
+    if (outcome._tag === 'Left') {
+      expect(outcome.left).toBe('first-error')
+    }
+  })
+
+  it('should preserve error handling from second stream', async () => {
+    const stream1 = Stream.make(1, 2)
+    const result = concatWithLastElement(stream1, () => Stream.fail('second-error'))
+
+    const outcome = await Effect.runPromise(Effect.either(runCollectReadonlyArray(result)))
+    expect(outcome._tag).toBe('Left')
+    if (outcome._tag === 'Left') {
+      expect(outcome.left).toBe('second-error')
+    }
+  })
+
+  it('should work with different types in streams', async () => {
+    const stream1 = Stream.make(1, 2, 3)
+    const result = concatWithLastElement(stream1, (lastElement) =>
+      lastElement.pipe(
+        Option.match({
+          onNone: () => Stream.make('no-number') as Stream.Stream<number | string, never, never>,
+          onSome: (last) => Stream.make(last * 10, last * 100),
+        }),
+      ),
+    )
+
+    const collected = await Effect.runPromise(runCollectReadonlyArray(result))
+    expect(collected).toEqual([1, 2, 3, 30, 300])
+  })
+
+  it('should handle async effects in streams', async () => {
+    const stream1 = Stream.fromEffect(Effect.succeed('async-value'))
+    const result = concatWithLastElement(stream1, (lastElement) =>
+      lastElement.pipe(
+        Option.match({
+          onNone: () => Stream.fromEffect(Effect.succeed('no-async')),
+          onSome: (last) => Stream.fromEffect(Effect.succeed(`processed-${last}`)),
+        }),
+      ),
+    )
+
+    const collected = await Effect.runPromise(runCollectReadonlyArray(result))
+    expect(collected).toEqual(['async-value', 'processed-async-value'])
+  })
+
+  it('should work with dual function - piped style', async () => {
+    const stream1 = Stream.make('a', 'b', 'c')
+    const result = stream1.pipe(
+      concatWithLastElement((lastElement) =>
+        lastElement.pipe(
+          Option.match({
+            onNone: () => Stream.make('no-last'),
+            onSome: (last) => Stream.make(`last-${last}`, 'done'),
+          }),
+        ),
+      ),
+    )
+
+    const collected = await Effect.runPromise(runCollectReadonlyArray(result))
+    expect(collected).toEqual(['a', 'b', 'c', 'last-c', 'done'])
+  })
+})

package/src/effect/Stream.ts

@@ -1,7 +1,8 @@
+/** biome-ignore-all lint/suspicious/useIterableCallbackReturn: Biome bug */
 export * from 'effect/Stream'
 
-import type { Chunk } from 'effect'
-import { Effect, Option, pipe, Ref, Stream } from 'effect'
+import { type Cause, Chunk, Effect, Option, pipe, Ref, Stream } from 'effect'
+import { dual } from 'effect/Function'
 
 export const tapLog = <R, E, A>(stream: Stream.Stream<A, E, R>): Stream.Stream<A, E, R> =>
   tapChunk<never, never, A, void>(Effect.forEach((_) => Effect.succeed(console.log(_))))(stream)
@@ -61,3 +62,111 @@ export const skipRepeated_ = <R, E, A>(
       ),
     ),
   )
+
+/**
+ * Returns the first element of the stream or `None` if the stream is empty.
+ * It's different than `Stream.runHead` which runs the stream to completion.
+ * */
+export const runFirst = <A, E, R>(stream: Stream.Stream<A, E, R>): Effect.Effect<Option.Option<A>, E, R> =>
+  stream.pipe(Stream.take(1), Stream.runCollect, Effect.map(Chunk.head))
+
+/**
+ * Returns the first element of the stream or throws a `NoSuchElementException` if the stream is empty.
+ * It's different than `Stream.runHead` which runs the stream to completion.
+ * */
+export const runFirstUnsafe = <A, E, R>(
+  stream: Stream.Stream<A, E, R>,
+): Effect.Effect<A, Cause.NoSuchElementException | E, R> => runFirst(stream).pipe(Effect.flatten)
+
+export const runCollectReadonlyArray = <A, E, R>(stream: Stream.Stream<A, E, R>): Effect.Effect<readonly A[], E, R> =>
+  stream.pipe(Stream.runCollect, Effect.map(Chunk.toReadonlyArray))
+
+/**
+ * Concatenates two streams where the second stream has access to the last element
+ * of the first stream as an `Option`. If the first stream is empty, the callback
+ * receives `Option.none()`.
+ *
+ * @param stream - The first stream to consume
+ * @param getStream2 - Function that receives the last element from the first stream
+ *   and returns the second stream to concatenate
+ * @returns A new stream containing all elements from both streams
+ *
+ * @example
+ * ```ts
+ * // Direct usage
+ * const result = concatWithLastElement(
+ *   Stream.make(1, 2, 3),
+ *   lastElement => lastElement.pipe(
+ *     Option.match({
+ *       onNone: () => Stream.make('empty'),
+ *       onSome: last => Stream.make(`last-was-${last}`)
+ *     })
+ *   )
+ * )
+ *
+ * // Piped usage
+ * const result = Stream.make(1, 2, 3).pipe(
+ *   concatWithLastElement(lastElement =>
+ *     Stream.make(lastElement.pipe(Option.getOrElse(() => 0)) * 10)
+ *   )
+ * )
+ * ```
+ */
+export const concatWithLastElement: {
+  <A1, A2, E2, R2>(
+    getStream2: (lastElement: Option.Option<A1>) => Stream.Stream<A2, E2, R2>,
+  ): <E1, R1>(stream: Stream.Stream<A1, E1, R1>) => Stream.Stream<A1 | A2, E1 | E2, R1 | R2>
+  <A1, E1, R1, A2, E2, R2>(
+    stream: Stream.Stream<A1, E1, R1>,
+    getStream2: (lastElement: Option.Option<A1>) => Stream.Stream<A2, E2, R2>,
+  ): Stream.Stream<A1 | A2, E1 | E2, R1 | R2>
+} = dual(
+  2,
+  <A1, E1, R1, A2, E2, R2>(
+    stream1: Stream.Stream<A1, E1, R1>,
+    getStream2: (lastElement: Option.Option<A1>) => Stream.Stream<A2, E2, R2>,
+  ): Stream.Stream<A1 | A2, E1 | E2, R1 | R2> =>
+    pipe(
+      Ref.make<Option.Option<A1>>(Option.none()),
+      Stream.fromEffect,
+      Stream.flatMap((lastRef) =>
+        pipe(
+          stream1,
+          Stream.tap((value) => Ref.set(lastRef, Option.some(value))),
+          Stream.concat(pipe(Ref.get(lastRef), Effect.map(getStream2), Stream.unwrap)),
+        ),
+      ),
+    ),
+)
+
+/**
+ * Emits a default value if the stream is empty, otherwise passes through all elements.
+ * Uses `concatWithLastElement` internally to detect if the stream was empty.
+ *
+ * @param fallbackValue - The value to emit if the stream is empty
+ * @returns A dual function that can be used in pipe or direct call
+ *
+ * @example
+ * ```ts
+ * // Direct usage
+ * const result = emitIfEmpty(Stream.empty, 'default')
+ * // Emits: 'default'
+ *
+ * // Piped usage
+ * const result = Stream.make(1, 2, 3).pipe(emitIfEmpty('fallback'))
+ * // Emits: 1, 2, 3
+ *
+ * const empty = Stream.empty.pipe(emitIfEmpty('fallback'))
+ * // Emits: 'fallback'
+ * ```
+ */
+export const emitIfEmpty: {
+  <A>(fallbackValue: A): <E, R>(stream: Stream.Stream<A, E, R>) => Stream.Stream<A, E, R>
+  <A, E, R>(stream: Stream.Stream<A, E, R>, fallbackValue: A): Stream.Stream<A, E, R>
+} = dual(
+  2,
+  <A, E, R>(stream: Stream.Stream<A, E, R>, fallbackValue: A): Stream.Stream<A, E, R> =>
+    concatWithLastElement(stream, (lastElement) =>
+      lastElement._tag === 'None' ? Stream.make(fallbackValue) : Stream.empty,
+    ),
+)

package/src/effect/SubscriptionRef.ts

@@ -1,5 +1,4 @@
-import type { SubscriptionRef } from 'effect'
-import { Chunk, Effect, pipe, Stream } from 'effect'
+import { Chunk, Effect, pipe, Stream, SubscriptionRef } from 'effect'
 import { dual } from 'effect/Function'
 import type { Predicate, Refinement } from 'effect/Predicate'
 
@@ -20,3 +19,16 @@ export const waitUntil: {
 } = dual(2, <A>(sref: SubscriptionRef.SubscriptionRef<A>, predicate: (a: A) => boolean) =>
   pipe(sref.changes, Stream.filter(predicate), Stream.take(1), Stream.runCollect, Effect.map(Chunk.unsafeHead)),
 )
+
+export const fromStream = <A>(stream: Stream.Stream<A>, initialValue: A) =>
+  Effect.gen(function* () {
+    const sref = yield* SubscriptionRef.make(initialValue)
+
+    yield* stream.pipe(
+      Stream.tap((a) => SubscriptionRef.set(sref, a)),
+      Stream.runDrain,
+      Effect.forkScoped,
+    )
+
+    return sref
+  })

package/src/effect/WebSocket.ts

@@ -88,7 +88,7 @@ export const makeWebSocket = ({
             socket.close(1000)
           }
         } catch (error) {
-          yield* Effect.die(new WebSocketError({ cause: error }))
+          return yield* Effect.die(new WebSocketError({ cause: error }))
         }
       }),
     )

package/src/effect/index.ts

@@ -1,6 +1,7 @@
 import '../global.ts'
 
-export * as OtelTracer from '@effect/opentelemetry/Tracer'
+export { AiError, AiLanguageModel, AiModel, AiTool, AiToolkit, McpSchema, McpServer } from '@effect/ai'
+export * as Otlp from '@effect/opentelemetry/Otlp'
 export {
   Command,
   CommandExecutor,
@@ -8,6 +9,11 @@ export {
   FetchHttpClient,
   FileSystem,
   Headers,
+  HttpApi,
+  HttpApiClient,
+  HttpApiEndpoint,
+  HttpApiGroup,
+  HttpApp,
   HttpClient,
   HttpClientError,
   HttpClientRequest,
@@ -18,6 +24,7 @@ export {
   HttpServerRequest,
   HttpServerResponse,
   KeyValueStore,
+  MsgPack,
   Socket,
   Terminal,
   Transferable,
@@ -29,7 +36,8 @@ export {
 export { BrowserWorker, BrowserWorkerRunner } from '@effect/platform-browser'
 export {
   Rpc,
-  RpcClient,
+  // RpcClient, // TODO bring back "original" RpcClient from effect/rpc
+  RpcClientError,
   RpcGroup,
   RpcMessage,
   RpcMiddleware,
@@ -47,8 +55,8 @@ export {
   Cause,
   Channel,
   Chunk,
-  // Logger,
   Config,
+  ConfigError,
   Console,
   Context,
   Data,
@@ -107,13 +115,15 @@ export {
   Tracer,
   Types,
 } from 'effect'
-export { dual } from 'effect/Function'
+export type { NonEmptyArray } from 'effect/Array'
+export { constVoid, dual } from 'effect/Function'
 export { TreeFormatter } from 'effect/ParseResult'
 export type { Serializable, SerializableWithResult } from 'effect/Schema'
-
 export * as SchemaAST from 'effect/SchemaAST'
 export * as BucketQueue from './BucketQueue.ts'
 export * as Logger from './Logger.ts'
+export * as OtelTracer from './OtelTracer.ts'
+export * as RpcClient from './RpcClient.ts'
 export * as Schema from './Schema/index.ts'
 export * as Stream from './Stream.ts'
 export * as Subscribable from './Subscribable.ts'

package/src/global.ts

@@ -1,5 +1,6 @@
 declare global {
   export type TODO<_Reason extends string = 'unknown'> = any
+  export type UNUSED<_Reason extends string = 'unknown'> = any
 }
 
 export {}

package/src/node/mod.ts

@@ -17,7 +17,7 @@ export * as ChildProcessWorker from './ChildProcessRunner/ChildProcessWorker.ts'
 
 // export const OtelLiveHttp = (args: any): Layer.Layer<never> => Layer.empty
 
-export const getFreePort = Effect.async<number, UnknownError>((cb, signal) => {
+export const getFreePort: Effect.Effect<number, UnknownError> = Effect.async<number, UnknownError>((cb, signal) => {
   const server = http.createServer()
 
   signal.addEventListener('abort', () => {

package/src/effect/Schema/msgpack.ts

@@ -1,8 +0,0 @@
-import { Schema } from 'effect'
-import * as msgpack from 'msgpackr'
-
-export const MsgPack = <A, I>(schema: Schema.Schema<A, I>) =>
-  Schema.transform(Schema.Uint8ArrayFromSelf, schema, {
-    encode: (decoded) => msgpack.pack(decoded),
-    decode: (encodedBytes) => msgpack.unpack(encodedBytes),
-  })