effect 4.0.7 → 4.1.1

package/src/internal/graphql.ts

@@ -1,4 +1,5 @@
 import { isReadonlyArrayNonEmpty, type NonEmptyReadonlyArray } from "../Array.ts"
+import * as Clock from "../Clock.ts"
 import * as Context from "../Context.ts"
 import * as Effect from "../Effect.ts"
 import type * as GraphQL from "../graphql/GraphQL.ts"
@@ -10,10 +11,12 @@ import {
   GraphQLClientError,
   type GraphQLError,
   type Reason,
-  ResponseError
+  ResponseError,
+  TransportError
 } from "../graphql/GraphQLClientError.ts"
 import type { ExecutionResult, GraphQLProtocol, GraphQLRequest } from "../graphql/GraphQLProtocol.ts"
 import * as Schema from "../Schema.ts"
+import { parseRetryAfter } from "./graphqlHeaders.ts"
 
 /**
  * Builds a response error with raw data and transport metadata.
@@ -32,6 +35,10 @@ export const responseError = (
     ...(result?.headers === undefined ? {} : { headers: result.headers })
   })
 
+/** A result without an HTTP status, such as a graphql-ws event, counts as 2xx. */
+const isStatusOk = (result: ExecutionResult): boolean =>
+  result.status === undefined || (result.status >= 200 && result.status < 300)
+
 /**
  * Raw responses for partial results, used by resolvers to preserve error
  * metadata. Mock client results have no entry.
@@ -210,27 +217,38 @@ export const makeCodec = <Op extends GraphQL.Any>(operation: Op) => {
     Effect.catch(decode(data), schemaFail((description) => new DecodeError({ description })))
 
   // GraphQL requires errors when data is null or missing. Check before decoding,
-  // since schemas such as Schema.Json accept null.
+  // since schemas such as Schema.Json accept null. A non-2xx result never
+  // succeeds: without errors it is a TransportError carrying the HTTP metadata.
   const failResponse = (result: ExecutionResult): Effect.Effect<never, GraphQLClientError> => {
     const errors = result.errors ?? []
-    return Effect.fail(fail(
-      isReadonlyArrayNonEmpty(errors)
-        ? responseError(result, errors)
-        : new DecodeError({ description: "data is null or missing without errors" })
-    ))
+    if (isReadonlyArrayNonEmpty(errors)) return Effect.fail(fail(responseError(result, errors)))
+    if (isStatusOk(result)) {
+      return Effect.fail(fail(new DecodeError({ description: "data is null or missing without errors" })))
+    }
+    return Clock.clockWith((clock) =>
+      Effect.fail(fail(
+        new TransportError({
+          description: `HTTP ${result.status} response without GraphQL errors`,
+          status: result.status,
+          headers: result.headers,
+          retryAfter: parseRetryAfter(result.headers?.["retry-after"], clock.currentTimeMillisUnsafe())
+        })
+      ))
+    )
   }
 
   const decodeStrict = (
     result: ExecutionResult
   ): Effect.Effect<GraphQL.Result<Op>, GraphQLClientError, Op["result"]["DecodingServices"]> =>
-    isReadonlyArrayNonEmpty(result.errors ?? []) || result.data === null || result.data === undefined
+    !isStatusOk(result) || isReadonlyArrayNonEmpty(result.errors ?? []) || result.data === null ||
+      result.data === undefined
       ? failResponse(result)
       : decodeData(result.data)
 
   const decodePartial = (
     result: ExecutionResult
   ): Effect.Effect<PartialResult<GraphQL.Result<Op>>, GraphQLClientError, Op["result"]["DecodingServices"]> => {
-    if (result.data === null || result.data === undefined) return failResponse(result)
+    if (!isStatusOk(result) || result.data === null || result.data === undefined) return failResponse(result)
     return Effect.map(decodeData(result.data), (data): PartialResult<GraphQL.Result<Op>> => {
       const partial = { data, errors: result.errors ?? [] }
       partialResponses.set(partial, result)

package/src/internal/graphqlHeaders.ts

@@ -1,4 +1,6 @@
+import type * as Duration from "../Duration.ts"
 import * as Headers from "../http/Headers.ts"
+import * as Result from "../Result.ts"
 import * as Schema from "../Schema.ts"
 import * as SchemaGetter from "../SchemaGetter.ts"
 
@@ -9,3 +11,14 @@ export const HeadersSchema = Schema.Record(Schema.String, Schema.String).pipe(
     encode: SchemaGetter.transform((headers) => ({ ...headers }))
   })
 )
+
+/**
+ * Parses a `Retry-After` header value, either whole seconds or an HTTP date,
+ * into a `Duration` measured from `now` (epoch milliseconds). Anything else,
+ * such as `1.5` or `-1`, yields `undefined`.
+ */
+export const parseRetryAfter = (value: string | undefined, now: number): Duration.Duration | undefined => {
+  if (value === undefined) return undefined
+  const retryAfter = Headers.parseRetryAfter(value)
+  return Result.isSuccess(retryAfter) ? Headers.retryAfterDelay(retryAfter.success, now) : undefined
+}

package/src/internal/matcher.ts

@@ -511,6 +511,23 @@ export const tags = discriminators("_tag")
 /** @internal */
 export const tagsExhaustive = discriminatorsExhaustive("_tag")
 
+/** @internal */
+export const literals = (fields: object) => {
+  const predicate = makeWhen(
+    (arg: any) =>
+      (typeof arg === "string" || typeof arg === "number") && Object.hasOwn(fields, arg) &&
+      (fields as any)[arg] !== undefined,
+    (data: any) => (fields as any)[data](data)
+  )
+  return (self: any): any => self.add(predicate)
+}
+
+/** @internal */
+export const literalsExhaustive = (fields: object) => {
+  const addCases = literals(fields)
+  return (matcher: any): any => exhaustive(addCases(matcher))
+}
+
 /** @internal */
 export const not = <
   R,

package/src/internal/persistence.ts

@@ -1,2 +1,13 @@
 /** @internal */
 export const sqlCleanupBatchSize = 1000
+
+/**
+ * Key prefix for a persistence store. The store id is escaped so the namespace
+ * always ends at its first `:`, and distinct store / key pairs never collide.
+ *
+ * @internal
+ */
+export const storeNamespace = (storeId: string): string => `${storeId.replace(/%/g, "%25").replace(/:/g, "%3A")}:`
+
+/** @internal */
+export const escapeRedisGlob = (pattern: string): string => pattern.replace(/[\\*?[\]]/g, "\\$&")

package/src/internal/rcRef.ts

@@ -225,7 +225,10 @@ const release = <A, E>(self: RcRefImpl<A, E>, state: State.Acquired<A>): Effect.
     Effect.flatMap(restore(Effect.sleep(idleTimeToLive)), () => {
       if (self.state === state && state.refCount === 0) {
         self.state = stateEmpty
-        return Scope.close(state.scope, Exit.void)
+        return Effect.ignoreCause(Scope.close(state.scope, Exit.void), {
+          log: "Unhandled",
+          message: "Unhandled error in RcRef finalizer"
+        })
       }
       return Effect.void
     })

package/src/internal/request.ts

@@ -96,10 +96,10 @@ const makeBatchMap = (resolver: RequestResolver<any>): BatchMap => {
 }
 
 interface Batch {
-  key: unknown
-  context: Context.Context<never>
-  resolver: RequestResolver<any>
-  map: BatchMap
+  readonly key: unknown
+  readonly context: Context.Context<never>
+  readonly resolver: RequestResolver<any>
+  readonly map: BatchMap
   readonly entrySet: Set<Request.Entry<any>>
   readonly entries: Set<Request.Entry<any>>
   readonly delayEffect: Effect<void>
@@ -107,9 +107,53 @@ interface Batch {
   fiber?: Fiber<unknown, unknown> | undefined
 }
 
-const batchPool: Array<Batch> = []
 const pendingBatches = new WeakMap<RequestResolver<any>, BatchMap>()
 
+// Batches are built outside `addEntry` so their callbacks do not share a closure
+// context with per-request entries, which would keep completed requests alive.
+const makeBatch = (
+  key: unknown,
+  context: Context.Context<never>,
+  resolver: RequestResolver<any>,
+  map: BatchMap
+): Batch => {
+  const batch: Batch = {
+    key,
+    context,
+    resolver,
+    map,
+    entrySet: new Set(),
+    entries: new Set(),
+    delayEffect: effect.flatMap(
+      withFiber((delayFiber) => {
+        // Reentrant delay callbacks may fill the batch and interrupt this fiber.
+        batch.fiber = delayFiber
+        return batch.resolver.delay
+      }),
+      (_) => runBatch(batch)
+    ) as Effect<void>,
+    run: effect.onExit(
+      effect.suspend(() =>
+        batch.resolver.runAll(Array.from(batch.entries) as NonEmptyArray<Request.Entry<any>>, batch.key)
+      ),
+      (exit) => {
+        for (const entry of batch.entrySet) {
+          entry.completeUnsafe(
+            exit._tag === "Success"
+              ? exitDie(
+                new Error("Effect.request: RequestResolver did not complete request", { cause: entry.request })
+              )
+              : exit
+          )
+        }
+        batch.entries.clear()
+        return effect.void
+      }
+    )
+  }
+  return batch
+}
+
 const addEntry = <A extends Request.Any>(
   resolver: RequestResolver<A>,
   request: A,
@@ -146,58 +190,7 @@ const addEntry = <A extends Request.Any>(
   batch = batchMap.get(key)
   const isNewBatch = batch === undefined
   if (!batch) {
-    if (batchPool.length > 0) {
-      batch = batchPool.pop()!
-      batch.key = key
-      batch.context = fiber.context
-      batch.resolver = resolver
-      batch.map = batchMap
-    } else {
-      const newBatch: Batch = {
-        key,
-        context: fiber.context,
-        resolver,
-        map: batchMap,
-        entrySet: new Set(),
-        entries: new Set(),
-        delayEffect: effect.flatMap(
-          withFiber((delayFiber) => {
-            // Reentrant delay callbacks may fill the batch and interrupt this fiber.
-            newBatch.fiber = delayFiber
-            return newBatch.resolver.delay
-          }),
-          (_) => runBatch(newBatch)
-        ) as Effect<void>,
-        run: effect.onExit(
-          effect.suspend(() =>
-            newBatch.resolver.runAll(Array.from(newBatch.entries) as NonEmptyArray<Request.Entry<any>>, newBatch.key)
-          ),
-          (exit) => {
-            for (const entry of newBatch.entrySet) {
-              entry.completeUnsafe(
-                exit._tag === "Success"
-                  ? exitDie(
-                    new Error("Effect.request: RequestResolver did not complete request", { cause: entry.request })
-                  )
-                  : exit
-              )
-            }
-            newBatch.entries.clear()
-            if (batchPool.length < 128) {
-              newBatch.entrySet.clear()
-              newBatch.key = undefined
-              newBatch.context = undefined as any
-              newBatch.fiber = undefined
-              newBatch.resolver = undefined as any
-              newBatch.map = undefined as any
-              batchPool.push(newBatch)
-            }
-            return effect.void
-          }
-        )
-      }
-      batch = newBatch
-    }
+    batch = makeBatch(key, fiber.context, resolver, batchMap)
     batchMap.set(key, batch)
   }
 
@@ -205,7 +198,7 @@ const addEntry = <A extends Request.Any>(
   batch.entries.add(entry)
   if (isNewBatch) {
     const delayFiber = effect.runForkWith(fiber.context)(batch.delayEffect, { scheduler: fiber.cache.scheduler })
-    // A synchronous delay may have already run and recycled this batch.
+    // A synchronous delay may have already run this batch.
     if (completed || batchMap.get(key) !== batch) return entry
     batch.fiber = delayFiber
   }

package/src/internal/schema/fromJsonSchemaDocument.ts

@@ -755,8 +755,9 @@ export function fromJsonSchemaMultiDocument(
         return out
       }
       case "Union":
-        return representation.types.length > 1 ||
-          representation.types.some(hasChoices)
+        // Finite primitive literal sets intersect without expansion, so they can be duplicated across branches.
+        return !isLiteralSet(representation) &&
+          (representation.types.length > 1 || representation.types.some(hasChoices))
       case "Arrays":
         return representation.elements.some((element) => hasChoices(element.type)) ||
           representation.rest.some(hasChoices)
@@ -796,18 +797,20 @@ export function fromJsonSchemaMultiDocument(
     return representation.literal
   }
 
+  function isLiteralSet(union: ImportedUnion): boolean {
+    return (union.options?.mode ?? "anyOf") === "anyOf" &&
+      union.types.every((type) => literalValue(type) !== undefined)
+  }
+
   function intersectLiteralUnions(
     left: ImportedUnion,
     right: ImportedUnion,
     path: Path
   ): ImportedJsonSchemaRepresentation | undefined {
-    if ((left.options?.mode ?? "anyOf") !== "anyOf" || (right.options?.mode ?? "anyOf") !== "anyOf") {
-      return undefined
-    }
-    const rightByValue = new Map<string | number | boolean | null, ImportedJsonSchemaRepresentation>()
+    if (!isLiteralSet(left) || !isLiteralSet(right)) return undefined
+    const rightByValue = new Map<ReturnType<typeof literalValue>, ImportedJsonSchemaRepresentation>()
     for (const representation of right.types) {
       const value = literalValue(representation)
-      if (value === undefined) return undefined
       const previous = rightByValue.get(value)
       rightByValue.set(value, {
         ...representation,
@@ -816,9 +819,7 @@ export function fromJsonSchemaMultiDocument(
     }
     const types: Array<ImportedJsonSchemaRepresentation> = []
     for (const representation of left.types) {
-      const value = literalValue(representation)
-      if (value === undefined) return undefined
-      const match = rightByValue.get(value)
+      const match = rightByValue.get(literalValue(representation))
       if (match !== undefined) types.push(intersect(representation, annotate(match, right), path))
     }
     return makeUnion(left, types)

package/src/internal/schema/toCodeDocument.ts

@@ -16,6 +16,10 @@ export function makeCode(runtime: string, Type: string): SchemaRepresentation.Co
   return { runtime, Type }
 }
 
+function formatObjectLiteralKey(key: PropertyKey, formatted = formatPropertyKey(key)): string {
+  return key === "__proto__" ? `[${formatted}]` : formatted
+}
+
 function renderEmittableAnnotation(input: unknown): string | undefined {
   if (
     input === null ||
@@ -43,7 +47,7 @@ function renderEmittableAnnotation(input: unknown): string | undefined {
   for (const [key, value] of Object.entries(input)) {
     const rendered = renderEmittableAnnotation(value)
     if (rendered === undefined) return undefined
-    entries.push(`${formatPropertyKey(key)}: ${rendered}`)
+    entries.push(`${formatObjectLiteralKey(key)}: ${rendered}`)
   }
   return entries.length === 0 ? "{}" : `{ ${entries.join(", ")} }`
 }
@@ -63,7 +67,7 @@ function renderAnnotations(
   for (const [key, value] of Object.entries(annotations)) {
     if (InternalAnnotations.annotationExcludedKeys.has(key)) continue
     const rendered = renderEmittableAnnotation(value)
-    if (rendered !== undefined) entries.push(`${formatPropertyKey(key)}: ${rendered}`)
+    if (rendered !== undefined) entries.push(`${formatObjectLiteralKey(key)}: ${rendered}`)
   }
   return entries.length === 0 ? undefined : `{ ${entries.join(", ")} }`
 }
@@ -499,7 +503,7 @@ export function toCodeDocument(
           if (property.isMutable) runtime = `Schema.mutableKey(${runtime})`
           if (property.isOptional) runtime = `Schema.optionalKey(${runtime})`
           runtime += runtimeAnnotate(property.annotations, "annotateKey")
-          const runtimeName = property.name === "__proto__" ? `[${name}]` : name
+          const runtimeName = formatObjectLiteralKey(property.name, name)
           const typeName = `${property.isMutable ? "" : "readonly "}${name}${property.isOptional ? "?" : ""}`
           return {
             code: makeCode(`${runtimeName}: ${runtime}`, `${typeName}: ${type.Type}`)

package/src/internal/trie.ts

@@ -21,6 +21,7 @@ type TraversalFilter<K, V> = (k: K, v: V) => boolean
 /** @internal */
 export interface TrieImpl<in out V> extends TR.Trie<V> {
   readonly _root: Node<V> | undefined
+  readonly _empty: Entry<V> | undefined
   readonly _count: number
 }
 
@@ -70,15 +71,17 @@ const TrieProto: TR.Trie<unknown> = {
   }
 }
 
-const makeImpl = <V>(root: Node<V> | undefined): TrieImpl<V> => {
+const makeImpl = <V>(root: Node<V> | undefined, emptyEntry: Entry<V> | undefined): TrieImpl<V> => {
   const trie = Object.create(TrieProto)
   trie._root = root
-  trie._count = root?.count ?? 0
+  trie._empty = emptyEntry
+  trie._count = (root?.count ?? 0) + (emptyEntry === undefined ? 0 : 1)
   return trie
 }
 
 class TrieIterator<in out V, out T> implements IterableIterator<T> {
   stack: Array<[Node<V>, string, boolean]> = []
+  emptyEntry: Entry<V> | undefined
   readonly f: TraversalMap<string, V, T>
   readonly filter: TraversalFilter<string, V>
 
@@ -89,6 +92,7 @@ class TrieIterator<in out V, out T> implements IterableIterator<T> {
   ) {
     this.f = f
     this.filter = filter
+    this.emptyEntry = trie._empty
     const root = trie._root !== undefined ? trie._root : undefined
     if (root !== undefined) {
       this.stack.push([root, "", false])
@@ -96,6 +100,13 @@ class TrieIterator<in out V, out T> implements IterableIterator<T> {
   }
 
   next(): IteratorResult<T> {
+    const emptyEntry = this.emptyEntry
+    if (emptyEntry !== undefined) {
+      this.emptyEntry = undefined
+      if (this.filter("", emptyEntry.value)) {
+        return { done: false, value: this.f("", emptyEntry.value) }
+      }
+    }
     while (this.stack.length > 0) {
       const [node, keyString, isAdded] = this.stack.pop()!
 
@@ -140,7 +151,7 @@ export const isTrie: {
 } = (u: unknown): u is TR.Trie<unknown> => hasProperty(u, TrieTypeId)
 
 /** @internal */
-export const empty = <V = never>(): TR.Trie<V> => makeImpl<V>(undefined)
+export const empty = <V = never>(): TR.Trie<V> => makeImpl<V>(undefined, undefined)
 
 /** @internal */
 export const fromIterable = <V>(entries: Iterable<readonly [string, V]>) => {
@@ -163,7 +174,7 @@ export const insert = dual<
   <V>(key: string, value: V) => (self: TR.Trie<V>) => TR.Trie<V>,
   <V>(self: TR.Trie<V>, key: string, value: V) => TR.Trie<V>
 >(3, <V>(self: TR.Trie<V>, key: string, value: V) => {
-  if (key.length === 0) return self
+  if (key.length === 0) return makeImpl((self as TrieImpl<V>)._root, { value })
 
   // -1:left | 0:mid | 1:right
   const dStack: Array<Ordering.Ordering> = []
@@ -255,11 +266,11 @@ export const insert = dual<
   }
 
   nStack[0].count = count
-  return makeImpl(nStack[0])
+  return makeImpl(nStack[0], (self as TrieImpl<V>)._empty)
 })
 
 /** @internal */
-export const size = <V>(self: TR.Trie<V>): number => (self as TrieImpl<V>)._root?.count ?? 0
+export const size = <V>(self: TR.Trie<V>): number => (self as TrieImpl<V>)._count
 
 /** @internal */
 export const isEmpty = <V>(self: TR.Trie<V>): boolean => size(self) === 0
@@ -394,8 +405,12 @@ export const get = dual<
 >(
   2,
   <V>(self: TR.Trie<V>, key: string) => {
+    if (key.length === 0) {
+      const emptyEntry = (self as TrieImpl<V>)._empty
+      return emptyEntry === undefined ? Option.none() : Option.some(emptyEntry.value)
+    }
     let n: Node<V> | undefined = (self as TrieImpl<V>)._root
-    if (n === undefined || key.length === 0) return Option.none()
+    if (n === undefined) return Option.none()
     let cIndex = 0
     while (cIndex < key.length) {
       const c = key[cIndex]
@@ -453,8 +468,11 @@ export const remove = dual<
 >(
   2,
   <V>(self: TR.Trie<V>, key: string) => {
+    if (key.length === 0) {
+      return (self as TrieImpl<V>)._empty === undefined ? self : makeImpl((self as TrieImpl<V>)._root, undefined)
+    }
     let n: Node<V> | undefined = (self as TrieImpl<V>)._root
-    if (n === undefined || key.length === 0) return self
+    if (n === undefined) return self
 
     const count = n.count - 1
     // -1:left | 0:mid | 1:right
@@ -554,7 +572,7 @@ export const remove = dual<
     }
 
     nStack[0].count = count
-    return makeImpl(nStack[0])
+    return makeImpl(nStack[0], (self as TrieImpl<V>)._empty)
   }
 )
 
@@ -589,8 +607,12 @@ export const modify = dual<
 >(
   3,
   <V>(self: TR.Trie<V>, key: string, f: (v: V) => V): TR.Trie<V> => {
+    if (key.length === 0) {
+      const emptyEntry = (self as TrieImpl<V>)._empty
+      return emptyEntry === undefined ? self : makeImpl((self as TrieImpl<V>)._root, { value: f(emptyEntry.value) })
+    }
     let n: Node<V> | undefined = (self as TrieImpl<V>)._root
-    if (n === undefined || key.length === 0) return self
+    if (n === undefined) return self
 
     // -1:left | 0:mid | 1:right
     const dStack: Array<Ordering.Ordering> = []
@@ -689,7 +711,7 @@ export const modify = dual<
       }
     }
 
-    return makeImpl(nStack[0])
+    return makeImpl(nStack[0], (self as TrieImpl<V>)._empty)
   }
 )
 
@@ -700,9 +722,12 @@ export const longestPrefixOf = dual<
 >(
   2,
   <V>(self: TR.Trie<V>, key: string): Option.Option<[string, V]> => {
+    const emptyEntry = (self as TrieImpl<V>)._empty
+    let longestPrefixNode: Option.Option<[string, V]> = emptyEntry === undefined
+      ? Option.none()
+      : Option.some(["", emptyEntry.value])
     let n: Node<V> | undefined = (self as TrieImpl<V>)._root
-    if (n === undefined || key.length === 0) return Option.none()
-    let longestPrefixNode: Option.Option<[string, V]> = Option.none()
+    if (n === undefined || key.length === 0) return longestPrefixNode
     let cIndex = 0
     while (cIndex < key.length) {
       const c = key[cIndex]
@@ -735,10 +760,14 @@ export const longestPrefixOf = dual<
   }
 )
 
+interface Entry<V> {
+  readonly value: V
+}
+
 interface Node<V> {
   key: string
   count: number
-  value?: { readonly value: V } | undefined
+  value?: Entry<V> | undefined
   left?: Node<V> | undefined
   mid?: Node<V> | undefined
   right?: Node<V> | undefined

package/src/internal/ulid.ts

@@ -28,3 +28,47 @@ export const ulidString = (timestampMillis: number, bytes: Uint8Array): string =
 
   return out
 }
+
+/**
+ * Makes a ULID generator in the ULID spec's monotonic mode: within a
+ * millisecond, or when the clock moves back, the 80-bit random part of the last
+ * ULID is incremented. The ordering ends at the maximum timestamp, 2^48 − 1 ms,
+ * which overflow cannot advance. `randomBytes` is only called for fresh
+ * randomness.
+ *
+ * @internal
+ */
+export const makeMonotonic = () => {
+  let lastTimestamp = -1
+  const random = new Uint8Array(10)
+  return (timestampMillis: number, randomBytes: () => Uint8Array): string => {
+    const timestamp = timestampMillis >= 0 ? Math.min(Math.trunc(timestampMillis), maxTimestamp) : 0
+    if (timestamp > lastTimestamp) {
+      lastTimestamp = timestamp
+      random.set(randomBytes())
+    } else if (!increment(random)) {
+      lastTimestamp = Math.min(lastTimestamp + 1, maxTimestamp)
+      random.set(randomBytes())
+    }
+    return ulidString(lastTimestamp, random)
+  }
+}
+
+// Returns false when the bytes overflow, leaving them all zero.
+const increment = (bytes: Uint8Array): boolean => {
+  for (let i = bytes.length - 1; i >= 0; i--) {
+    if (bytes[i] !== 0xff) {
+      bytes[i]++
+      return true
+    }
+    bytes[i] = 0
+  }
+  return false
+}
+
+/**
+ * The ULID ordering state shared by every `Date.now()` caller in the realm.
+ *
+ * @internal
+ */
+export const monotonic = makeMonotonic()