effect 4.0.0-beta.24 → 4.0.0-beta.25

package/src/internal/effect.ts

@@ -4950,7 +4950,8 @@ export const forkScoped: {
       readonly startImmediately?: boolean | undefined
       readonly uninterruptible?: boolean | "inherit" | undefined
     } | undefined
-  ): [Arg] extends [Effect.Effect<infer _A, infer _E, infer _R>] ? Effect.Effect<Fiber.Fiber<_A, _E>, never, _R>
+  ): [Arg] extends [Effect.Effect<infer _A, infer _E, infer _R>] ?
+    Effect.Effect<Fiber.Fiber<_A, _E>, never, _R | Scope.Scope>
     : <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<Fiber.Fiber<A, E>, never, R | Scope.Scope>
 } = dual((args) => isEffect(args[0]), <A, E, R>(
   self: Effect.Effect<A, E, R>,

package/src/unstable/http/HttpClient.ts

@@ -8,7 +8,7 @@ import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
-import { constFalse, constTrue, dual, flow, identity } from "../../Function.ts"
+import { constant, constFalse, constTrue, dual, flow, identity } from "../../Function.ts"
 import * as Inspectable from "../../Inspectable.ts"
 import * as Layer from "../../Layer.ts"
 import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
@@ -1158,6 +1158,7 @@ export const withRateLimiter: {
   options: WithRateLimiter.Options
 ): HttpClient.With<E | RateLimiter.RateLimiterError, R> => {
   const initialState: RateLimiterState = {
+    initial: true,
     limit: options.limit,
     window: Duration.max(Duration.fromInputUnsafe(options.window), Duration.millis(1))
   }
@@ -1166,10 +1167,11 @@ export const withRateLimiter: {
   const keyOption = options.key
   const resolveKey: (request: HttpClientRequest.HttpClientRequest) => string = typeof keyOption === "function"
     ? keyOption
-    : () => keyOption
+    : constant(keyOption)
   const tokensOption = options.tokens
-  const resolveTokens: (request: HttpClientRequest.HttpClientRequest) => number | undefined =
-    typeof tokensOption === "function" ? tokensOption : () => tokensOption
+  const resolveTokens: (request: HttpClientRequest.HttpClientRequest) => number = typeof tokensOption === "function"
+    ? tokensOption
+    : constant(tokensOption ?? 1)
 
   const getState = (key: string): RateLimiterState => {
     const current = states.get(key)
@@ -1182,7 +1184,7 @@ export const withRateLimiter: {
 
   const onResponse = options.disableResponseInspection
     ? undefined
-    : (clock: Clock, key: string, headers: Headers.Headers, tokens: number | undefined) => {
+    : (clock: Clock, key: string, headers: Headers.Headers, tokens: number) => {
       const current = getState(key)
       const next = parseRateLimiterState(current, clock, headers, tokens)
       if (next.limit !== current.limit || !Duration.equals(next.window, current.window)) {
@@ -1198,8 +1200,15 @@ export const withRateLimiter: {
     const fiber = Fiber.getCurrent()!
     const clock = fiber.getRef(Clock)
     const key = resolveKey(request)
-    const tokens = resolveTokens(request)
+    const tokens = Math.max(resolveTokens(request), 1)
     const current = getState(key)
+    function retry(response: HttpClientResponse.HttpClientResponse) {
+      if (options.disableResponseInspection) return loop(effect, request)
+      const retryAfter = parseRetryAfter(clock, getHeader(response.headers, "retry-after"))
+      return retryAfter
+        ? Effect.flatMap(Effect.sleep(retryAfter), () => loop(effect, request))
+        : loop(effect, request)
+    }
     return Effect.flatMap(
       options.limiter.consume({
         algorithm: options.algorithm,
@@ -1213,12 +1222,13 @@ export const withRateLimiter: {
         const run = Effect.matchEffect(effect, {
           onSuccess(response) {
             onResponse?.(clock, key, response.headers, tokens)
-            return response.status === 429 ? loop(effect, request) : Effect.succeed(response)
+            if (response.status !== 429) return Effect.succeed(response)
+            return retry(response)
           },
           onFailure(error) {
             if (isTooManyRequestsHttpClientError(error)) {
               onResponse?.(clock, key, error.reason.response.headers, tokens)
-              return loop(effect, request)
+              return retry(error.reason.response)
             }
             return Effect.fail(error)
           }
@@ -1232,23 +1242,28 @@ export const withRateLimiter: {
 interface RateLimiterState {
   readonly limit: number
   readonly window: Duration.Duration
+  readonly initial: boolean
 }
 
 const parseRateLimiterState = (
   state: RateLimiterState,
   clock: Clock,
   headers: Headers.Headers,
-  tokens: number | undefined
+  tokens: number
 ): RateLimiterState => {
-  const limit = parseRateLimitLimit(headers, tokens) ?? state.limit
+  const limit = parseRateLimitLimit(state, headers, tokens) ?? state.limit
   const window = parseRateLimitWindow(clock, headers) ?? state.window
   if (limit === state.limit && Duration.equals(window, state.window)) {
     return state
   }
-  return { limit, window }
+  return { limit, window, initial: false }
 }
 
-const parseRateLimitLimit = (headers: Headers.Headers, tokens: number | undefined): number | undefined => {
+const parseRateLimitLimit = (
+  state: RateLimiterState,
+  headers: Headers.Headers,
+  tokens: number
+): number | undefined => {
   const raw = getHeader(headers, "ratelimit-limit", "x-ratelimit-limit")
   const value = parseNumberHeader(raw)
   if (value !== undefined && value > 0) {
@@ -1258,7 +1273,7 @@ const parseRateLimitLimit = (headers: Headers.Headers, tokens: number | undefine
   if (remaining === undefined) {
     return undefined
   }
-  return Math.max(remaining + (tokens !== undefined && tokens > 0 ? tokens : 1), 1)
+  return state.initial ? remaining + tokens : Math.max(remaining + tokens, state.limit)
 }
 
 const parseRateLimitRemaining = (headers: Headers.Headers): number | undefined => {

package/src/unstable/sql/SqlResolver.ts

@@ -104,14 +104,14 @@ export const ordered = <Req extends Schema.Top, Res extends Schema.Top, _, E, R>
     >,
     SqlClient.TransactionConnection["Service"] | undefined
   >({
-    key: (entry) => entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key),
+    key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
       const inputs = yield* partitionRequests(entries, options.Request)
       const results = yield* options.execute(inputs as any).pipe(
         Effect.provideServices(entries[0].services)
       )
       if (results.length !== inputs.length) {
-        return yield* Effect.fail(new ResultLengthMismatch({ expected: inputs.length, actual: results.length }))
+        return yield* new ResultLengthMismatch({ expected: inputs.length, actual: results.length })
       }
       const decodedResults = yield* decodeArray(results).pipe(
         Effect.provideServices(entries[0].services)
@@ -160,7 +160,7 @@ export const grouped = <Req extends Schema.Top, Res extends Schema.Top, K, Row,
     >,
     SqlClient.TransactionConnection["Service"] | undefined
   >({
-    key: (entry) => entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key),
+    key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
       const inputs = yield* partitionRequests(entries, options.Request)
       const resultMap = MutableHashMap.empty<K, Arr.NonEmptyArray<Res["Type"]>>()
@@ -226,7 +226,11 @@ export const findById = <Id extends Schema.Top, Res extends Schema.Top, Row, E,
     >,
     SqlClient.TransactionConnection["Service"] | undefined
   >({
-    key: (entry) => entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key),
+    key(entry) {
+      const conn = entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key)
+      if (!conn) return undefined
+      return Equal.byReferenceUnsafe(conn)
+    },
     resolver: Effect.fnUntraced(function*(entries) {
       const [inputs, idMap] = yield* partitionRequestsById(entries, options.Id)
       const results = yield* options.execute(inputs as any).pipe(
@@ -279,7 +283,7 @@ const void_ = <Req extends Schema.Top, _, E, R>(
     >,
     SqlClient.TransactionConnection["Service"] | undefined
   >({
-    key: (entry) => entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key),
+    key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
       const inputs = yield* partitionRequests(entries, options.Request)
       yield* options.execute(inputs as any).pipe(
@@ -354,3 +358,9 @@ const partitionRequestsById = function*<In, A, E, R, InE>(
 
   return [inputs, byIdMap] as const
 }
+
+function transactionKey<A>(entry: Request.Entry<A>): SqlClient.TransactionConnection["Service"] | undefined {
+  const conn = entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key)
+  if (!conn) return undefined
+  return Equal.byReferenceUnsafe(conn)
+}