effect 4.1.0 → 4.1.2

package/src/persistence/RateLimiter.ts

@@ -16,8 +16,11 @@ import * as Context from "../Context.ts"
 import * as Duration from "../Duration.ts"
 import * as Effect from "../Effect.ts"
 import { flow, identity } from "../Function.ts"
+import { escapeKeySegment } from "../internal/persistence.ts"
 import * as Layer from "../Layer.ts"
+import * as Schedule from "../Schedule.ts"
 import * as Schema from "../Schema.ts"
+import type * as Scope from "../Scope.ts"
 import * as Redis from "./Redis.ts"
 
 /**
@@ -85,6 +88,9 @@ export const RateLimiter: Context.Service<RateLimiter, RateLimiter> = Context.Se
  * The limiter supports fixed-window and token-bucket algorithms and either
  * fails or returns a delay when a limit is exceeded.
  *
+ * A nonpositive `limit` admits no positive token requests: fail mode rejects
+ * them and delay mode returns an infinite delay without touching the store.
+ *
  * @stability unstable
  * @category constructors
  * @since 4.0.0
@@ -106,10 +112,9 @@ export const make: Effect.Effect<
       const algorithm = options.algorithm ?? "fixed-window"
       const window = Duration.max(Duration.fromInputUnsafe(options.window), Duration.millis(1))
       const windowMillis = Duration.toMillis(window)
-      const refillRate = Duration.divideUnsafe(window, options.limit)
-      const refillRateMillis = Duration.toMillis(refillRate)
+      const exceeded = tokens > options.limit
 
-      if (onExceeded === "fail" && tokens > options.limit) {
+      if (onExceeded === "fail" && exceeded) {
         return Effect.fail(
           new RateLimiterError({
             reason: new RateLimitExceeded({
@@ -122,6 +127,19 @@ export const make: Effect.Effect<
         )
       }
 
+      // A nonpositive limit never refills, so skip the store and its infinite refill rate.
+      if (options.limit <= 0) {
+        return Effect.succeed<ConsumeResult>({
+          delay: exceeded ? Duration.infinity : Duration.zero,
+          limit: options.limit,
+          remaining: options.limit - tokens,
+          resetAfter: exceeded ? Duration.infinity : Duration.zero
+        })
+      }
+
+      const refillRate = Duration.divideUnsafe(window, options.limit)
+      const refillRateMillis = Duration.toMillis(refillRate)
+
       if (algorithm === "fixed-window") {
         return Effect.flatMap(
           store.fixedWindow({
@@ -706,18 +724,25 @@ interface AdaptiveState {
   expiresAt: number
 }
 
+const memoryStoreSweepInterval = Duration.minutes(1)
+
 /**
- * Provides a process-local in-memory `RateLimiterStore`.
+ * Creates a process-local `RateLimiterStore`. Every entry expires once its
+ * state is indistinguishable from a missing key, and a background sweep tied to
+ * the scope removes expired entries, so an idle store drains to empty.
  *
- * @stability unstable
- * @category layers
- * @since 4.0.0
+ * @internal
  */
-export const layerStoreMemory: Layer.Layer<
-  RateLimiterStore
-> = Layer.sync(RateLimiterStore, () => {
+export const makeMemoryStore: Effect.Effect<
+  {
+    readonly store: RateLimiterStore["Service"]
+    readonly size: number
+  },
+  never,
+  Scope.Scope
+> = Effect.gen(function*() {
   const fixedCounters = new Map<string, { count: number; expiresAt: number }>()
-  const tokenBuckets = new Map<string, { tokens: number; lastRefill: number }>()
+  const tokenBuckets = new Map<string, { tokens: number; lastRefill: number; expiresAt: number }>()
   const adaptiveStates = new Map<string, AdaptiveState>()
 
   const getAdaptiveState = (key: string, now: number): AdaptiveState | undefined => {
@@ -738,7 +763,7 @@ export const layerStoreMemory: Layer.Layer<
   const learnedExpiresAt = (now: number, learnedWindowMillis: number): number =>
     now + learnedWindowMillis + adaptiveStateTtlGraceMillis
 
-  return RateLimiterStore.of({
+  const store = RateLimiterStore.of({
     fixedWindow: (options) =>
       Effect.clockWith((clock) =>
         Effect.sync(() => {
@@ -749,7 +774,7 @@ export const layerStoreMemory: Layer.Layer<
             counter = { count: 0, expiresAt: now }
             fixedCounters.set(options.key, counter)
           }
-          if (options.limit && counter.count + options.tokens > options.limit) {
+          if (options.limit !== undefined && counter.count + options.tokens > options.limit) {
             return [counter.count + options.tokens, counter.expiresAt - now] as const
           }
           counter.count += options.tokens
@@ -763,8 +788,8 @@ export const layerStoreMemory: Layer.Layer<
           const refillRateMillis = Duration.toMillis(options.refillRate)
           const now = clock.currentTimeMillisUnsafe()
           let bucket = tokenBuckets.get(options.key)
-          if (!bucket) {
-            bucket = { tokens: options.limit, lastRefill: now }
+          if (!bucket || bucket.expiresAt <= now) {
+            bucket = { tokens: options.limit, lastRefill: now, expiresAt: now }
             tokenBuckets.set(options.key, bucket)
           }
           const tokensToAdd = Math.floor((now - bucket.lastRefill) / refillRateMillis)
@@ -780,6 +805,8 @@ export const layerStoreMemory: Layer.Layer<
           if (options.allowOverflow || newTokenCount >= 0) {
             bucket.tokens = newTokenCount
           }
+          // The bucket is indistinguishable from a fresh one once fully refilled
+          bucket.expiresAt = bucket.lastRefill + Math.ceil(options.limit - bucket.tokens) * refillRateMillis
           return [newTokenCount, Math.max(0, now - bucket.lastRefill)] as const
         })
       ),
@@ -924,12 +951,59 @@ export const layerStoreMemory: Layer.Layer<
         })
       )
   })
+
+  const sweep = Effect.clockWith((clock) =>
+    Effect.sync(() => {
+      const now = clock.currentTimeMillisUnsafe()
+      for (const map of [fixedCounters, tokenBuckets, adaptiveStates]) {
+        for (const [key, entry] of map) {
+          if (entry.expiresAt <= now) {
+            map.delete(key)
+          }
+        }
+      }
+    })
+  )
+  yield* sweep.pipe(
+    Effect.repeat(Schedule.spaced(memoryStoreSweepInterval)),
+    Effect.forkScoped
+  )
+
+  return {
+    store,
+    get size() {
+      return fixedCounters.size + tokenBuckets.size + adaptiveStates.size
+    }
+  }
 })
 
+/**
+ * Provides a process-local in-memory `RateLimiterStore`.
+ *
+ * **Details**
+ *
+ * Entries expire once their state is indistinguishable from an unseen key, and
+ * a background sweep scoped to the layer removes expired entries periodically.
+ *
+ * @stability unstable
+ * @category layers
+ * @since 4.0.0
+ */
+export const layerStoreMemory: Layer.Layer<
+  RateLimiterStore
+> = Layer.effect(RateLimiterStore)(Effect.map(makeMemoryStore, (memory) => memory.store))
+
 /**
  * Creates a Redis-backed `RateLimiterStore` using Lua scripts and the
  * configured key prefix.
  *
+ * **Details**
+ *
+ * State for a rate-limit key is stored under `<prefix><key>`, with
+ * `<prefix><key>:refill` holding token-bucket refill times and
+ * `<prefix><key>:adaptive` holding adaptive state. `%` and `:` in the key are
+ * percent-encoded so different keys never share Redis state.
+ *
  * @stability unstable
  * @category constructors
  * @since 4.0.0
@@ -941,6 +1015,7 @@ export const makeStoreRedis = Effect.fnUntraced(function*(
 ) {
   const prefix = options?.prefix ?? "ratelimiter:"
   const redis = yield* Redis.Redis
+  const redisKey = (key: string) => `${prefix}${escapeKeySegment(key)}`
 
   const fixedWindow = redis.eval(fixedWindowScript)
   const tokenBucket = redis.eval(tokenBucketScript)
@@ -949,7 +1024,7 @@ export const makeStoreRedis = Effect.fnUntraced(function*(
 
   return RateLimiterStore.of({
     fixedWindow(options) {
-      const key = `${prefix}${options.key}`
+      const key = redisKey(options.key)
       const refillMillis = Duration.toMillis(options.refillRate)
       return Effect.mapError(
         Effect.map(
@@ -966,7 +1041,7 @@ export const makeStoreRedis = Effect.fnUntraced(function*(
       )
     },
     tokenBucket(options) {
-      const key = `${prefix}${options.key}`
+      const key = redisKey(options.key)
       const lastRefillKey = `${key}:refill`
       const refillMillis = Duration.toMillis(options.refillRate)
       return Effect.clockWith((clock) =>
@@ -994,7 +1069,7 @@ export const makeStoreRedis = Effect.fnUntraced(function*(
       )
     },
     adaptiveConsume(options) {
-      const key = `${prefix}${options.key}:adaptive`
+      const key = `${redisKey(options.key)}:adaptive`
       return Effect.map(
         Effect.mapError(
           adaptiveConsume(
@@ -1021,7 +1096,7 @@ export const makeStoreRedis = Effect.fnUntraced(function*(
     adaptiveFeedback(options) {
       if (options.status !== 429 || options.retryAfter === undefined) return Effect.void
       const retryAfterMillis = clampAdaptiveDurationMillis(Duration.toMillis(options.retryAfter))
-      const key = `${prefix}${options.key}:adaptive`
+      const key = `${redisKey(options.key)}:adaptive`
       return Effect.asVoid(
         Effect.mapError(
           adaptiveFeedback(
@@ -1057,6 +1132,9 @@ local limit = tonumber(ARGV[3])
 local current = tonumber(redis.call("GET", key))
 
 if not current then
+  if limit and tokens > limit then
+    return { string.format("%.17g", tokens), 0 }
+  end
   local nextpttl = math.max(1, math.ceil(refillms * tokens))
   redis.call("SET", key, tokens, "PX", nextpttl)
   return { string.format("%.17g", tokens), nextpttl }

package/src/persistence/index.ts

@@ -7,7 +7,7 @@
 
 /**
  * @stability experimental
- * @since 4.0.6
+ * @since 4.0.7
  */
 export * as CircuitBreaker from "./CircuitBreaker.ts"
 

package/src/reactivity/AtomRegistry.ts

@@ -553,9 +553,15 @@ class RegistryImpl implements AtomRegistry {
     const node = this.ensureNode(atom)
     if (options?.immediate) {
       f(node.value())
-    } else if (node.state === NodeState.stale) {
-      // a listener hears the next change, which only reaches an up-to-date node
-      node.value()
+    } else {
+      // build the node so the listener hears its next change. A failed build
+      // is left for the next read to report; an error raised after the value
+      // is committed has no later read to report it, so it is rethrown
+      try {
+        node.value()
+      } catch (error) {
+        if ((node.state & NodeFlags.waitingForValue) === 0) throw error
+      }
     }
     const remove = node.subscribe(function() {
       f(node._value)
@@ -842,11 +848,15 @@ class NodeImpl<A> {
   }
 
   build(): void {
-    // a lifetime still attached to a node that needs a value belongs to a
-    // build that failed, or to one that is running and is now superseded
-    this.disposeLifetime()
-    this.invalidatedDuringBuild = false
     const lifetime = makeLifetime(this)
+    // release a failed or superseded build; its finalizers run only once, so
+    // their failure is rethrown once this build commits
+    try {
+      this.disposeLifetime()
+    } catch (error) {
+      lifetime.failure = error
+    }
+    this.invalidatedDuringBuild = false
     this.lifetime = lifetime
     let value: A
     let read = false
@@ -1126,7 +1136,8 @@ interface Lifetime<A> extends Atom.AtomContext {
   readonly node: NodeImpl<A>
   // the parents read so far by the build; `undefined` once the build has returned
   reads: Set<NodeImpl<any>> | undefined
-  // a failure met while reading a parent that still produced its value
+  // rethrown once the build commits: a failure from releasing the previous
+  // lifetime, or from reading a parent that still produced its value
   failure: unknown
   finalizers: Array<() => void> | undefined
   disposed: boolean

package/src/rpc/Rpc.ts

@@ -363,7 +363,9 @@ export type SuccessExit<R> = Success<R> extends infer T ? T extends Stream<infer
  * @category utility types
  * @since 4.0.0
  */
-export type SuccessChunk<R> = Success<R> extends Stream<infer _A, infer _E, infer _Env> ? _A : never
+export type SuccessChunk<R> = R extends Any ?
+  SuccessSchema<R> extends RpcSchema.Stream<infer _A, infer _E> ? _A["Type"] : never
+  : never
 
 /**
  * Extracts the RPC error schema, including error schemas contributed by

package/src/rpc/RpcClient.ts

@@ -113,7 +113,8 @@ export declare namespace RpcClient {
            * handler's result and error are not returned, but transport errors,
            * middleware errors and failures before the handler starts still fail the
            * call. Over HTTP and workers the call completes after the handler has
-           * finished.
+           * finished. A protocol that only delivers requests acknowledges the call
+           * itself once it has delivered the request.
            */
           readonly discard?: Discard | undefined
         }
@@ -188,7 +189,8 @@ export declare namespace RpcClient {
          * handler's result and error are not returned, but transport errors,
          * middleware errors and failures before the handler starts still fail the
          * call. Over HTTP and workers the call completes after the handler has
-         * finished.
+         * finished. A protocol that only delivers requests acknowledges the call
+         * itself once it has delivered the request.
          */
         readonly discard?: Discard | undefined
       }
@@ -418,19 +420,18 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
       let fiber: Fiber.Fiber<any, any>
       return Effect.onInterrupt(
         Effect.callback<any, any>((resume) => {
-          // the acknowledgement of a discarded call, held until its send has finished
-          let ack: Exit.Exit<any, any> | undefined
+          let acked = false
           const entry: ClientEntry = {
             _tag: "Effect",
             rpc,
             context,
             resume(exit) {
-              if (discard) {
-                // Interrupting the send could cancel the call, as an HTTP
-                // handler is scoped to its request, so the call completes
-                // once the send has finished too.
-                ack = exit._tag === "Success" ? Exit.void : exit
-                if (fiber?.pollUnsafe()) resume(ack)
+              if (discard && exit._tag === "Success") {
+                // A successful acknowledgement waits for the send to finish, as
+                // interrupting the send could cancel the call: an HTTP handler
+                // is scoped to its request. Failures complete the call at once.
+                acked = true
+                if (fiber?.pollUnsafe()) resume(Exit.void)
                 return
               }
               resume(exit)
@@ -450,8 +451,8 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
             if (exit._tag === "Failure") {
               entries.delete(id)
               return resume(exit)
-            } else if (ack) {
-              return resume(ack)
+            } else if (acked) {
+              return resume(Exit.void)
             }
           })
         }),
@@ -604,8 +605,10 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
         if (!entry || entry._tag !== "Queue") return Effect.void
         return Queue.offerAll(entry.queue, message.values).pipe(
           supportsAck
-            ? Effect.flatMap(() =>
-              options.onFromClient({
+            ? Effect.flatMap((dropped) =>
+              // values are dropped when the queue was shutdown by an interrupted
+              // consumer, so the server should not be asked for more
+              dropped.length > 0 ? Effect.void : options.onFromClient({
                 message: { _tag: "Ack", requestId: message.requestId },
                 context: entry.context
               })
@@ -831,8 +834,10 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
       }
       case "ClientProtocolError": {
         const exit = Exit.fail(message.error)
-        const requestIds = Array.from(entries.keys())
-        entries.clear()
+        const requestIds = message.requestIds === undefined
+          ? Array.from(entries.keys())
+          : message.requestIds.map(RequestId).filter((requestId) => entries.has(requestId))
+        for (const requestId of requestIds) entries.delete(requestId)
         return Effect.forEach(
           requestIds,
           (requestId) => write({ _tag: "Exit", clientId: 0, requestId, exit: exit as any })
@@ -953,6 +958,16 @@ export const withHeaders: {
  * Use to provide the transport boundary for RPC clients over HTTP, WebSocket,
  * workers, sockets, or custom protocols.
  *
+ * **Details**
+ *
+ * A `Request` that `send` accepts stays pending until a reply names its id: an
+ * `Exit`, or a `ClientProtocolError` that lists it in `requestIds`. Until then
+ * the client keeps the request and the caller's context, unless the caller is
+ * interrupted, the client closes or the connection fails. A transport that
+ * only delivers requests, such as a message queue, writes a void `Exit` for a
+ * `discard` request once the request is delivered, and fails `send` with an
+ * `RpcClientError` for any other request.
+ *
  * @stability unstable
  * @category services
  * @since 4.0.0
@@ -1599,21 +1614,26 @@ export const makeProtocolWorker = (
           undefined
       }).pipe(
         Effect.tapCause((cause) => {
+          const requestIdsByClient = new Map<number, Array<string | number>>()
           for (const [requestId, entry] of entries) {
             if (entry.worker !== backing) continue
             entries.delete(requestId)
             entry.latch.openUnsafe()
+            const requestIds = requestIdsByClient.get(entry.clientId)
+            if (requestIds) requestIds.push(requestId)
+            else requestIdsByClient.set(entry.clientId, [requestId])
           }
-          const error = Cause.findError(cause)
-          return broadcast({
-            _tag: "ClientProtocolError",
-            error: new RpcClientError({
-              reason: Result.isSuccess(error) ? error.success.reason : new RpcClientDefect({
-                message: "Error in worker",
-                cause: Cause.squash(cause)
-              })
+          const found = Cause.findError(cause)
+          const error = new RpcClientError({
+            reason: Result.isSuccess(found) ? found.success.reason : new RpcClientDefect({
+              message: "Error in worker",
+              cause: Cause.squash(cause)
             })
           })
+          return Effect.forEach(
+            requestIdsByClient,
+            ([clientId, requestIds]) => writeResponse(clientId, { _tag: "ClientProtocolError", error, requestIds })
+          )
         }),
         Effect.retry(Schedule.spaced(1000)),
         Effect.annotateLogs({

package/src/rpc/RpcMessage.ts

@@ -325,8 +325,8 @@ export interface ResponseExitEncoded {
 }
 
 /**
- * A server-to-client protocol message reporting a client protocol error to all
- * affected in-flight requests.
+ * A server-to-client protocol message failing in-flight requests with a client
+ * protocol error: those in `requestIds`, or all of them when it is omitted.
  *
  * @stability unstable
  * @category models
@@ -335,6 +335,7 @@ export interface ResponseExitEncoded {
 export interface ClientProtocolError {
   readonly _tag: "ClientProtocolError"
   readonly error: RpcClientError
+  readonly requestIds?: ReadonlyArray<string | number>
 }
 
 /**

package/src/rpc/RpcServer.ts

@@ -902,6 +902,17 @@ export const make: <Rpcs extends Rpc.Any>(
     request: RequestEncoded,
     payload: unknown
   ) => {
+    // the headers come from the wire unvalidated, and malformed input makes
+    // `Headers.fromInput` throw
+    let headers: Headers.Headers
+    try {
+      headers = Headers.fromInput(request.headers)
+    } catch {
+      const reason = "Invalid request headers"
+      return request.isNotification === true
+        ? dropNotification(reason)
+        : sendRequestDefect(client, requestId, schemas.encodeExit, reason)
+    }
     // nothing is encoded for a notification, and only a reply would remove its schemas
     if (request.isNotification !== true) {
       client.schemas.set(
@@ -919,7 +930,7 @@ export const make: <Rpcs extends Rpc.Any>(
     const decoded = request as Types.Mutable<RequestEncoded>
     decoded.id = requestId
     decoded.payload = payload
-    decoded.headers = Headers.fromInput(request.headers) as any
+    decoded.headers = headers as any
     return server.write(client.id, decoded as any)
   }
 

package/src/sql/Migrator.ts

@@ -12,7 +12,7 @@
 import * as Arr from "../Array.ts"
 import * as Data from "../Data.ts"
 import * as Effect from "../Effect.ts"
-import { pipe } from "../Function.ts"
+import { identity, pipe } from "../Function.ts"
 import * as Option from "../Option.ts"
 import * as Order from "../Order.ts"
 import * as Client from "./SqlClient.ts"
@@ -99,13 +99,22 @@ export class MigrationError extends Data.TaggedError("MigrationError")<{
  * migrations. ClickHouse runs without a transaction and records each migration
  * only after it succeeds.
  *
+ * **Details**
+ *
+ * `transformWrites` transforms only the effects that create the migrations
+ * table and insert into it, for clients such as ClickHouse that run row-less
+ * statements differently from queries. Reads of the migrations table and the
+ * migrations themselves are not transformed. It defaults to `identity`.
+ *
  * @stability unstable
  * @category constructors
  * @since 4.0.0
  */
 export const make = <RD = never>({
+  transformWrites = identity,
   dumpSchema = () => Effect.void
 }: {
+  transformWrites?: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   dumpSchema?: (
     path: string,
     migrationsTable: string
@@ -123,7 +132,7 @@ export const make = <RD = never>({
   Effect.gen(function*() {
     const sql = yield* Client.SqlClient
 
-    const ensureMigrationsTable = sql.onDialectOrElse({
+    const createMigrationsTable = transformWrites(sql.onDialectOrElse({
       mssql: () =>
         sql`IF OBJECT_ID(N'${sql.literal(table)}', N'U') IS NULL
   CREATE TABLE ${sql(table)} (
@@ -147,14 +156,25 @@ export const make = <RD = never>({
 ) ENGINE = MergeTree
 ORDER BY migration_id`,
       pg: () =>
-        Effect.flatMap(
-          migrationsTableExists(sql, table),
-          (exists) =>
-            exists ? Effect.void : Effect.asVoid(sql`CREATE TABLE ${sql(table)} (
+        sql`CREATE TABLE ${sql(table)} (
   migration_id integer primary key,
   created_at timestamp with time zone not null default now(),
   name text not null
-)`).pipe(
+)`,
+      orElse: () =>
+        sql`CREATE TABLE IF NOT EXISTS ${sql(table)} (
+  migration_id integer PRIMARY KEY NOT NULL,
+  created_at datetime NOT NULL DEFAULT current_timestamp,
+  name VARCHAR(255) NOT NULL
+)`
+    }))
+
+    const ensureMigrationsTable = sql.onDialectOrElse({
+      pg: () =>
+        Effect.flatMap(
+          migrationsTableExists(sql, table),
+          (exists) =>
+            exists ? Effect.void : Effect.asVoid(createMigrationsTable).pipe(
               Effect.catch((error) =>
                 Effect.flatMap(
                   migrationsTableExists(sql, table),
@@ -163,22 +183,19 @@ ORDER BY migration_id`,
               )
             )
         ),
-      orElse: () =>
-        sql`CREATE TABLE IF NOT EXISTS ${sql(table)} (
-  migration_id integer PRIMARY KEY NOT NULL,
-  created_at datetime NOT NULL DEFAULT current_timestamp,
-  name VARCHAR(255) NOT NULL
-)`
+      orElse: () => createMigrationsTable
     })
 
     const insertMigrations = (
       rows: Arr.NonEmptyReadonlyArray<[id: number, name: string]>
     ) =>
-      sql`INSERT INTO ${sql(table)} ${
-        sql.insert(
-          Arr.map(rows, ([migration_id, name]) => ({ migration_id, name }))
-        )
-      }`.withoutTransform
+      transformWrites(
+        sql`INSERT INTO ${sql(table)} ${
+          sql.insert(
+            Arr.map(rows, ([migration_id, name]) => ({ migration_id, name }))
+          )
+        }`.withoutTransform
+      )
 
     const latestMigration = Effect.map(
       sql<{ migration_id: number; name: string; created_at: Date }>`SELECT migration_id, name, created_at FROM ${