effect 4.1.0 → 4.1.1

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/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = "4.1.0"
+export const version = "4.1.1"

package/src/jose/JoseError.ts

@@ -0,0 +1,329 @@
+/**
+ * The `JoseError` returned by the `effect/jose` modules, and the reasons it
+ * carries.
+ *
+ * Every failure is one `JoseError` whose `reason` says what went wrong. Reasons
+ * for configuration, transport, and key-import problems carry a `description`
+ * and, when there is one, a `cause`. Reasons for failed authentication carry
+ * nothing: they never describe tokens, claims, plaintext, or key material.
+ *
+ * **Gotchas**
+ *
+ * Map the error before it reaches a client, for example
+ * `SignatureVerificationFailed` to a 401. Sending verification detail to
+ * clients is how oracles leak.
+ *
+ * @stability unstable
+ * @since 4.1.1
+ */
+import * as Data from "../Data.ts"
+import * as Predicate from "../Predicate.ts"
+
+const TypeId = "~effect/jose/JoseError" as const
+const ReasonTypeId = "~effect/jose/JoseError/Reason" as const
+
+/**
+ * Reason for a malformed compact serialization, protected header, or payload,
+ * or for header parameters that are not supported, such as `crit`.
+ *
+ * @stability unstable
+ * @category errors
+ * @since 4.1.1
+ */
+export class InvalidToken extends Data.TaggedError("InvalidToken")<{
+  readonly description: string
+}> {
+  /**
+   * Marks this value as a `JoseError` reason for runtime guards.
+   *
+   * @since 4.1.1
+   */
+  readonly [ReasonTypeId] = ReasonTypeId
+
+  override get message(): string {
+    return this.description
+  }
+}
+
+/**
+ * Reason for key material that cannot be imported, or that does not fit the
+ * selected algorithm or operation.
+ *
+ * @stability unstable
+ * @category errors
+ * @since 4.1.1
+ */
+export class InvalidKey extends Data.TaggedError("InvalidKey")<{
+  readonly description: string
+  readonly cause?: unknown
+}> {
+  /**
+   * Marks this value as a `JoseError` reason for runtime guards.
+   *
+   * @since 4.1.1
+   */
+  readonly [ReasonTypeId] = ReasonTypeId
+
+  override get message(): string {
+    return this.description
+  }
+}
+
+/**
+ * Reason for an option or configuration value that the operation rejects
+ * before doing any work, such as a non-HTTPS key-set URL.
+ *
+ * @stability unstable
+ * @category errors
+ * @since 4.1.1
+ */
+export class InvalidArgument extends Data.TaggedError("InvalidArgument")<{
+  readonly description: string
+  readonly cause?: unknown
+}> {
+  /**
+   * Marks this value as a `JoseError` reason for runtime guards.
+   *
+   * @since 4.1.1
+   */
+  readonly [ReasonTypeId] = ReasonTypeId
+
+  override get message(): string {
+    return this.description
+  }
+}
+
+/**
+ * Reason for a token whose protected `alg` is not the key's algorithm or is
+ * outside the allowlist.
+ *
+ * @stability unstable
+ * @category errors
+ * @since 4.1.1
+ */
+export class AlgorithmNotAllowed extends Data.TaggedError("AlgorithmNotAllowed")<{}> {
+  /**
+   * Marks this value as a `JoseError` reason for runtime guards.
+   *
+   * @since 4.1.1
+   */
+  readonly [ReasonTypeId] = ReasonTypeId
+
+  override get message(): string {
+    return "The token algorithm is not allowed"
+  }
+}
+
+/**
+ * Reason for a signature that does not authenticate the token.
+ *
+ * @stability unstable
+ * @category errors
+ * @since 4.1.1
+ */
+export class SignatureVerificationFailed extends Data.TaggedError("SignatureVerificationFailed")<{}> {
+  /**
+   * Marks this value as a `JoseError` reason for runtime guards.
+   *
+   * @since 4.1.1
+   */
+  readonly [ReasonTypeId] = ReasonTypeId
+
+  override get message(): string {
+    return "Could not verify the signature"
+  }
+}
+
+/**
+ * Reason for ciphertext that fails authenticated decryption.
+ *
+ * @stability unstable
+ * @category errors
+ * @since 4.1.1
+ */
+export class DecryptionFailed extends Data.TaggedError("DecryptionFailed")<{}> {
+  /**
+   * Marks this value as a `JoseError` reason for runtime guards.
+   *
+   * @since 4.1.1
+   */
+  readonly [ReasonTypeId] = ReasonTypeId
+
+  override get message(): string {
+    return "Could not decrypt the token"
+  }
+}
+
+/**
+ * Reason for a key set with no key matching the algorithm and key id.
+ *
+ * @stability unstable
+ * @category errors
+ * @since 4.1.1
+ */
+export class KeyNotFound extends Data.TaggedError("KeyNotFound")<{}> {
+  /**
+   * Marks this value as a `JoseError` reason for runtime guards.
+   *
+   * @since 4.1.1
+   */
+  readonly [ReasonTypeId] = ReasonTypeId
+
+  override get message(): string {
+    return "No key matches the algorithm and key id"
+  }
+}
+
+/**
+ * Reason for a key set with more than one key matching the algorithm and key
+ * id.
+ *
+ * @stability unstable
+ * @category errors
+ * @since 4.1.1
+ */
+export class AmbiguousKey extends Data.TaggedError("AmbiguousKey")<{}> {
+  /**
+   * Marks this value as a `JoseError` reason for runtime guards.
+   *
+   * @since 4.1.1
+   */
+  readonly [ReasonTypeId] = ReasonTypeId
+
+  override get message(): string {
+    return "More than one key matches the algorithm and key id"
+  }
+}
+
+/**
+ * Reason for a remote key set that cannot be fetched or read, is cooling down
+ * after a failed refresh, or belongs to a closed layer.
+ *
+ * @stability unstable
+ * @category errors
+ * @since 4.1.1
+ */
+export class KeySetUnavailable extends Data.TaggedError("KeySetUnavailable")<{
+  readonly description: string
+  readonly cause?: unknown
+}> {
+  /**
+   * Marks this value as a `JoseError` reason for runtime guards.
+   *
+   * @since 4.1.1
+   */
+  readonly [ReasonTypeId] = ReasonTypeId
+
+  override get message(): string {
+    return this.description
+  }
+}
+
+/**
+ * Reason for a registered claim or `typ` header that is missing, malformed,
+ * different from the expected value, or outside its validity window.
+ *
+ * @stability unstable
+ * @category errors
+ * @since 4.1.1
+ */
+export class ClaimValidationFailed extends Data.TaggedError("ClaimValidationFailed")<{
+  readonly claim: "iss" | "sub" | "aud" | "exp" | "nbf" | "iat" | "jti" | "typ"
+  readonly reason: "invalid" | "missing" | "mismatch" | "expired" | "notYetValid" | "tooOld" | "future"
+}> {
+  /**
+   * Marks this value as a `JoseError` reason for runtime guards.
+   *
+   * @since 4.1.1
+   */
+  readonly [ReasonTypeId] = ReasonTypeId
+
+  override get message(): string {
+    return `The ${this.claim} claim failed validation: ${this.reason}`
+  }
+}
+
+/**
+ * Union of the reasons carried by `JoseError`.
+ *
+ * @stability unstable
+ * @category errors
+ * @since 4.1.1
+ */
+export type JoseErrorReason =
+  | InvalidToken
+  | InvalidKey
+  | InvalidArgument
+  | AlgorithmNotAllowed
+  | SignatureVerificationFailed
+  | DecryptionFailed
+  | KeyNotFound
+  | AmbiguousKey
+  | KeySetUnavailable
+  | ClaimValidationFailed
+
+/**
+ * Error returned by the `effect/jose` modules.
+ *
+ * **Example** (Rejecting a token with a bad signature)
+ *
+ * ```ts import.meta.vitest
+ * import { Effect } from "effect"
+ * import { JoseError } from "effect/jose"
+ *
+ * const verify = Effect.fail(
+ *   new JoseError.JoseError({ reason: new JoseError.SignatureVerificationFailed() })
+ * )
+ *
+ * const program = verify.pipe(
+ *   Effect.catchReason("JoseError", "SignatureVerificationFailed", () => Effect.succeed("rejected"))
+ * )
+ *
+ * await Effect.runPromise(program) // => "rejected"
+ * ```
+ *
+ * @see {@link isJoseError} for narrowing unknown values
+ *
+ * @stability unstable
+ * @category errors
+ * @since 4.1.1
+ */
+export class JoseError extends Data.TaggedError("JoseError")<{
+  readonly reason: JoseErrorReason
+}> {
+  /**
+   * Marks this value as a `JoseError` for runtime guards.
+   *
+   * @since 4.1.1
+   */
+  readonly [TypeId] = TypeId
+
+  /**
+   * The reason's cause, when it has one.
+   *
+   * @since 4.1.1
+   */
+  override readonly cause: unknown = "cause" in this.reason ? this.reason.cause : undefined
+
+  override get message(): string {
+    return this.reason.message
+  }
+}
+
+/**
+ * Checks whether a value is a `JoseError`.
+ *
+ * @stability unstable
+ * @category guards
+ * @since 4.1.1
+ */
+export const isJoseError = (u: unknown): u is JoseError => Predicate.hasProperty(u, TypeId)
+
+/**
+ * Checks whether a value is one of the reasons carried by `JoseError`.
+ *
+ * @stability unstable
+ * @category guards
+ * @since 4.1.1
+ */
+export const isJoseErrorReason = (u: unknown): u is JoseErrorReason => Predicate.hasProperty(u, ReasonTypeId)