effect 4.0.2 → 4.0.4

package/src/internal/dateTime.ts

@@ -934,10 +934,6 @@ export const subtractDuration: {
     mapEpochMillis(self, (millis) => millis - Duration.toMillis(Duration.fromInputUnsafe(duration)))
 )
 
-const addMillis = (date: Date, amount: number): void => {
-  date.setTime(date.getTime() + amount)
-}
-
 /** @internal */
 export const add: {
   (
@@ -949,20 +945,26 @@ export const add: {
   ): A
 } = dual(
   2,
-  (self: DateTime.DateTime, parts: Partial<DateTime.DateTime.PartsForMath>): DateTime.DateTime =>
-    mutate(self, (date) => {
+  (self: DateTime.DateTime, parts: Partial<DateTime.DateTime.PartsForMath>): DateTime.DateTime => {
+    // time units move the instant, calendar units move the wall clock
+    const shifted = mutateUtc(self, (date) => {
       if (parts.milliseconds) {
-        addMillis(date, parts.milliseconds)
+        date.setTime(date.getTime() + parts.milliseconds)
       }
       if (parts.seconds) {
-        addMillis(date, parts.seconds * 1000)
+        date.setTime(date.getTime() + parts.seconds * 1000)
       }
       if (parts.minutes) {
-        addMillis(date, parts.minutes * 60 * 1000)
+        date.setTime(date.getTime() + parts.minutes * 60 * 1000)
       }
       if (parts.hours) {
-        addMillis(date, parts.hours * 60 * 60 * 1000)
+        date.setTime(date.getTime() + parts.hours * 60 * 60 * 1000)
       }
+    })
+    if (!parts.days && !parts.weeks && !parts.months && !parts.years) {
+      return shifted
+    }
+    return mutate(shifted, (date) => {
       if (parts.days) {
         date.setUTCDate(date.getUTCDate() + parts.days)
       }
@@ -989,6 +991,7 @@ export const add: {
         }
       }
     })
+  }
 )
 
 /** @internal */

package/src/internal/effect.ts

@@ -1507,13 +1507,19 @@ const succeedPayload = function(this: { readonly payload: any }, _value: unknown
 // V8 includes the property name of a stored continuation in its stack trace.
 // Other engines need an explicit frame for the stack cleaner to cut at.
 const continuationMarksStack = (() => {
+  const limit = getStackTraceLimit()
+  if (limit === 0) return false
   const marker = "~effect/Effect/stackProbe"
   const probe = {
     [marker]: function stackProbe() {
-      return new Error().stack
+      return new Error()
     }
   }
-  return probe[marker]()?.includes("[as " + marker + "]") === true
+  // Only the probe frame is needed to detect the continuation property name.
+  setStackTraceLimit(1)
+  const error = probe[marker]()
+  setStackTraceLimit(limit)
+  return error.stack?.includes("[as " + marker + "]") === true
 })()
 const mapCont = function(this: { readonly payload: any }, value: any, fiber: FiberImpl) {
   const f = this.payload
@@ -4453,7 +4459,7 @@ export const cachedInvalidateWithTTL: {
 const infiniteTTL = constant(Infinity)
 
 interface CachedRun<A, E> {
-  fiber: FiberImpl<A, E> | undefined
+  readonly fiber: FiberImpl<A, E>
   awaiters: number
 }
 
@@ -4470,17 +4476,19 @@ const makeCachedUnsafe = <A, E, R>(
     onExitUnsafe(fiber, () => {
       // Abandon the run once every caller has left, unless it already finished.
       if (--run.awaiters > 0 || current !== run) return
-      // Detach it first so new callers start a fresh run instead of joining
-      // one that is being interrupted.
+      // Detach before interruption so new callers start a fresh run.
       current = undefined
-      return fiberInterrupt(run.fiber!)
+      return fiberInterrupt(run.fiber)
     })
-    return fiberJoin(run.fiber!)
+    return fiberJoin(run.fiber)
   }
 
   return [
     withFiber((fiber) => {
-      if (current !== undefined) return join(fiber, current)
+      if (current !== undefined) {
+        // A run joining itself is not an awaiter, so external callers can still abandon it.
+        return fiber === current.fiber ? fiberJoin(current.fiber) : join(fiber, current)
+      }
       if (
         exit !== undefined &&
         (expiresAt === Infinity || fiber.getRef(ClockRef).currentTimeMillisUnsafe() < expiresAt)
@@ -4489,10 +4497,11 @@ const makeCachedUnsafe = <A, E, R>(
       }
       exit = undefined
       const clock = fiber.getRef(ClockRef)
-      const run: CachedRun<A, E> = { fiber: undefined, awaiters: 0 }
+      const run: CachedRun<A, E> = { fiber: new FiberImpl(fiber.context), awaiters: 0 }
       current = run
-      run.fiber = forkUnsafe(
-        fiber,
+      // Join before evaluating, which may synchronously re-enter and interrupt other awaiters.
+      const joined = join(fiber, run)
+      run.fiber.evaluate(
         onExitPrimitive(self, (exit_) => {
           // An abandoned run must not overwrite or clear a replacement run.
           if (current !== run) return
@@ -4502,11 +4511,9 @@ const makeCachedUnsafe = <A, E, R>(
           const duration = ttlMillis(exit_)
           expiresAt = duration === Infinity ? Infinity : clock.currentTimeMillisUnsafe() + duration
           exit = exit_
-        }),
-        true,
-        true
+        }) as any
       )
-      return run.fiber._exit ?? join(fiber, run)
+      return run.fiber._exit ?? joined
     }),
     sync(() => {
       exit = undefined

package/src/internal/graphql.ts

@@ -0,0 +1,263 @@
+import { isReadonlyArrayNonEmpty, type NonEmptyReadonlyArray } from "../Array.ts"
+import * as Context from "../Context.ts"
+import * as Effect from "../Effect.ts"
+import type * as GraphQL from "../graphql/GraphQL.ts"
+import type { DocumentTemplate } from "../graphql/GraphQL.ts"
+import type { PartialResult } from "../graphql/GraphQLClient.ts"
+import {
+  DecodeError,
+  EncodeError,
+  GraphQLClientError,
+  type GraphQLError,
+  type Reason,
+  ResponseError
+} from "../graphql/GraphQLClientError.ts"
+import type { ExecutionResult, GraphQLRequest } from "../graphql/GraphQLProtocol.ts"
+import * as Schema from "../Schema.ts"
+
+/**
+ * Builds a response error with raw data and transport metadata.
+ *
+ * @internal
+ */
+export const responseError = (
+  result: ExecutionResult | undefined,
+  errors: NonEmptyReadonlyArray<GraphQLError>
+): ResponseError =>
+  new ResponseError({
+    errors,
+    ...(result?.data === undefined ? {} : { data: result.data as Schema.Json }),
+    ...(result?.extensions === undefined ? {} : { extensions: result.extensions }),
+    ...(result?.status === undefined ? {} : { status: result.status }),
+    ...(result?.headers === undefined ? {} : { headers: result.headers })
+  })
+
+/**
+ * Raw responses for partial results, used by resolvers to preserve error
+ * metadata. Mock client results have no entry.
+ *
+ * @internal
+ */
+export const partialResponses = new WeakMap<object, ExecutionResult>()
+
+/**
+ * Joins two printed pieces, adding a space only where two non-punctuators
+ * would otherwise touch. This is the generator printer's rule, so joining a
+ * generated template reproduces the printed document exactly.
+ */
+const concat = (left: string, right: string): string =>
+  /[\w"-]$/.test(left) && /^[\w"-]/.test(right) ? `${left} ${right}` : left + right
+
+const concatAll = (pieces: ReadonlyArray<string>): string => pieces.reduce(concat, "")
+
+/** Renders template parts, prefixing every name (the odd entries). */
+const renderParts = (parts: DocumentTemplate.Parts, prefix: string): string =>
+  parts.map((part, i) => i % 2 === 1 ? prefix + part : part).join("")
+
+const isShared = (fragment: DocumentTemplate.Fragment): boolean => fragment.body.length <= 1
+
+/**
+ * Renders the template once per prefix. The empty prefix renders it as
+ * written; any other prefix renames variables and per-slice fragments and
+ * aliases root fields to the prefixed response key.
+ */
+const render = (
+  kind: string,
+  name: string,
+  template: DocumentTemplate,
+  prefixes: ReadonlyArray<string>
+): string =>
+  concatAll([
+    kind,
+    name,
+    template.variables.length === 0 ? "" : `(${
+      concatAll(
+        prefixes.flatMap((prefix) =>
+          template.variables.map((variable) => `$${prefix}${variable.name}:${variable.body}`)
+        )
+      )
+    })`,
+    template.directives === undefined ? "" : renderParts(template.directives, ""),
+    `{${
+      concatAll(prefixes.flatMap((prefix) =>
+        template.selections.map((selection) => {
+          const key = prefix === "" ? selection.alias : `${prefix}${selection.alias ?? selection.name}`
+          return `${key === undefined ? "" : `${key}:`}${selection.name ?? ""}${renderParts(selection.body, prefix)}`
+        })
+      ))
+    }}`,
+    ...template.fragments.flatMap((fragment) =>
+      (isShared(fragment) ? [""] : prefixes).map((prefix) =>
+        concatAll(["fragment", prefix + fragment.name, renderParts(fragment.body, prefix)])
+      )
+    )
+  ])
+
+/**
+ * Joins a template into the document it was split from.
+ *
+ * @internal
+ */
+export const joinTemplate = (kind: string, name: string, template: DocumentTemplate): string =>
+  render(kind, name, template, [""])
+
+/**
+ * Why the template can't be sliced for any prefixes, if it can't: an operation
+ * directive references a variable, or a root selection is a fragment spread or
+ * inline fragment.
+ *
+ * @internal
+ */
+export const templateUnsliceableReason = (template: DocumentTemplate): string | undefined => {
+  if (template.directives !== undefined && template.directives.length > 1) {
+    return "its operation directives reference variables"
+  }
+  if (template.selections.some((selection) => selection.name === undefined)) {
+    return "it has a fragment spread or inline fragment at the root"
+  }
+  return undefined
+}
+
+/**
+ * Renders one operation that repeats the template once per prefix. Each
+ * slice's variables, root response keys and per-slice fragments are renamed
+ * with its prefix; operation directives and shared fragments appear once.
+ * Prefixes must start a GraphQL name, and none may be a prefix of another.
+ *
+ * Throws rather than producing an invalid document when the template is
+ * unsliceable (see {@link templateUnsliceableReason}) or a renamed fragment
+ * would take a shared fragment's name.
+ *
+ * @internal
+ */
+export const renderSlices = (
+  kind: string,
+  name: string,
+  template: DocumentTemplate,
+  prefixes: NonEmptyReadonlyArray<string>
+): string => {
+  const shared = new Set(template.fragments.filter(isShared).map((fragment) => fragment.name))
+  const collision = template.fragments
+    .flatMap((fragment) => isShared(fragment) ? [] : prefixes.map((prefix) => prefix + fragment.name))
+    .find((renamed) => shared.has(renamed))
+  const reason = templateUnsliceableReason(template) ??
+    (collision === undefined ? undefined : `fragment ${collision} would collide with a shared fragment`)
+  if (reason !== undefined) throw new Error(`Cannot render slices of operation ${name}: ${reason}`)
+  return render(kind, name, template, prefixes)
+}
+
+/**
+ * Forces POST for alias batches to avoid GET URL length limits.
+ *
+ * @internal
+ */
+export const ForcePost = Context.Reference<boolean>("effect/graphql/ForcePost", { defaultValue: () => false })
+
+/**
+ * JSON with object keys sorted, so equal JSON values give equal strings.
+ *
+ * @internal
+ */
+export const canonicalJson = (value: unknown): string =>
+  JSON.stringify(value, (_, value) =>
+    value !== null && typeof value === "object" && !Array.isArray(value)
+      ? Object.fromEntries(Object.keys(value).sort().map((key) => [key, value[key]]))
+      : value)
+
+/**
+ * Shared variable encoding, result decoding and client error mapping.
+ *
+ * @internal
+ */
+export const makeCodec = <Op extends GraphQL.Any>(operation: Op) => {
+  const fail = (reason: Reason) => new GraphQLClientError({ operation: operation.name, reason })
+  const schemaFail = (make: (description: string) => Reason) => (error: Schema.SchemaError) =>
+    Effect.fail(fail(make(error.message)))
+  const encode = Schema.encodeEffect(operation.variables)
+  const decode = Schema.decodeUnknownEffect(operation.result)
+
+  const encodeVariables = (
+    variables: GraphQL.Variables<Op> | undefined
+  ): Effect.Effect<unknown, GraphQLClientError, Op["variables"]["EncodingServices"]> =>
+    Effect.catch(encode(variables ?? {}), schemaFail((description) => new EncodeError({ description })))
+
+  const decodeData = (
+    data: unknown
+  ): Effect.Effect<GraphQL.Result<Op>, GraphQLClientError, Op["result"]["DecodingServices"]> =>
+    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.
+  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" })
+    ))
+  }
+
+  const decodeStrict = (
+    result: ExecutionResult
+  ): Effect.Effect<GraphQL.Result<Op>, GraphQLClientError, Op["result"]["DecodingServices"]> =>
+    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)
+    return Effect.map(decodeData(result.data), (data): PartialResult<GraphQL.Result<Op>> => {
+      const partial = { data, errors: result.errors ?? [] }
+      partialResponses.set(partial, result)
+      return partial
+    })
+  }
+
+  return { fail, schemaFail, encodeVariables, failResponse, decodeStrict, decodePartial } as const
+}
+
+/**
+ * Each real client method's runner for batches: its middleware and protocol,
+ * sending as POST. Mock and custom methods have none.
+ *
+ * @internal
+ */
+export const rawExecutors = new WeakMap<
+  object,
+  (request: GraphQLRequest) => Effect.Effect<ExecutionResult, unknown, unknown>
+>()
+
+/**
+ * Splits a batched response, removing prefixes from root keys and error paths.
+ * Returns undefined if an error matches no slice or data is null or missing.
+ *
+ * @internal
+ */
+export const splitSlices = (
+  result: ExecutionResult,
+  template: DocumentTemplate,
+  prefixes: ReadonlyArray<string>
+): ReadonlyArray<ExecutionResult> | undefined => {
+  const sliceErrors = prefixes.map((): Array<GraphQLError> => [])
+  for (const error of result.errors ?? []) {
+    const key = error.path?.[0]
+    // No prefix is a prefix of another, so at most one matches.
+    const index = typeof key === "string" ? prefixes.findIndex((prefix) => key.startsWith(prefix)) : -1
+    if (index === -1) return undefined
+    sliceErrors[index].push(
+      { ...error, path: [(key as string).slice(prefixes[index].length), ...error.path!.slice(1)] } as GraphQLError
+    )
+  }
+  if (result.data === null || result.data === undefined) return undefined
+  const data = result.data as Record<string, unknown>
+  return prefixes.map((prefix, i) => {
+    const sliceData: Record<string, unknown> = {}
+    for (const selection of template.selections) {
+      const key = (selection.alias ?? selection.name)!
+      if (Object.hasOwn(data, prefix + key)) sliceData[key] = data[prefix + key]
+    }
+    return { ...result, data: sliceData, errors: sliceErrors[i] }
+  })
+}

package/src/internal/graphqlHeaders.ts

@@ -0,0 +1,11 @@
+import * as Headers from "../http/Headers.ts"
+import * as Schema from "../Schema.ts"
+import * as SchemaGetter from "../SchemaGetter.ts"
+
+// Keep headers branded at runtime while encoding only their string entries.
+export const HeadersSchema = Schema.Record(Schema.String, Schema.String).pipe(
+  Schema.decodeTo(Schema.declare<Headers.Headers>(Headers.isHeaders), {
+    decode: SchemaGetter.transform(Headers.fromInput),
+    encode: SchemaGetter.transform((headers) => ({ ...headers }))
+  })
+)

package/src/internal/request.ts

@@ -4,6 +4,8 @@ import type { Effect } from "../Effect.ts"
 import type { Exit } from "../Exit.ts"
 import type { Fiber } from "../Fiber.ts"
 import { dual } from "../Function.ts"
+import * as MutableHashMap from "../MutableHashMap.ts"
+import * as Option from "../Option.ts"
 import type * as Request from "../Request.ts"
 import { makeEntry } from "../Request.ts"
 import type { RequestResolver } from "../RequestResolver.ts"
@@ -67,10 +69,36 @@ export const requestUnsafe = <A extends Request.Any>(
   return () => removeEntryUnsafe(options.resolver, entry)
 }
 
+/**
+ * Pending batches of resolvers whose `batchKey` is in this set match keys with
+ * `Equal` instead of by reference.
+ *
+ * @internal
+ */
+export const equalBatchKeys = new WeakSet<Function>()
+
+interface BatchMap {
+  get(key: unknown): Batch | undefined
+  has(key: unknown): boolean
+  set(key: unknown, batch: Batch): void
+  delete(key: unknown): void
+}
+
+const makeBatchMap = (resolver: RequestResolver<any>): BatchMap => {
+  if (!equalBatchKeys.has(resolver.batchKey)) return new Map()
+  const map = MutableHashMap.empty<unknown, Batch>()
+  return {
+    get: (key) => Option.getOrUndefined(MutableHashMap.get(map, key)),
+    has: (key) => MutableHashMap.has(map, key),
+    set: (key, batch) => MutableHashMap.set(map, key, batch),
+    delete: (key) => MutableHashMap.remove(map, key)
+  }
+}
+
 interface Batch {
   key: unknown
   resolver: RequestResolver<any>
-  map: Map<unknown, Batch>
+  map: BatchMap
   readonly entrySet: Set<Request.Entry<any>>
   readonly entries: Set<Request.Entry<any>>
   readonly delayEffect: Effect<void>
@@ -79,7 +107,7 @@ interface Batch {
 }
 
 const batchPool: Array<Batch> = []
-const pendingBatches = new WeakMap<RequestResolver<any>, Map<unknown, Batch>>()
+const pendingBatches = new WeakMap<RequestResolver<any>, BatchMap>()
 
 const addEntry = <A extends Request.Any>(
   resolver: RequestResolver<A>,
@@ -93,7 +121,7 @@ const addEntry = <A extends Request.Any>(
 ) => {
   let batchMap = pendingBatches.get(resolver)
   if (!batchMap) {
-    batchMap = new Map<object, Batch>()
+    batchMap = makeBatchMap(resolver)
     pendingBatches.set(resolver, batchMap)
   }
   let batch: Batch | undefined

package/src/internal/schema/toCodeDocument.ts

@@ -48,6 +48,8 @@ function renderEmittableAnnotation(input: unknown): string | undefined {
   return entries.length === 0 ? "{}" : `{ ${entries.join(", ")} }`
 }
 
+const canonicalFiniteCheck = `Schema.isFinite().annotate({ "expected": "a finite number" })`
+
 function renderAnnotations(
   annotations: Schema.Annotations.Annotations | undefined
 ): string | undefined {
@@ -341,7 +343,11 @@ export function toCodeDocument(
     let runtime = base.runtime + runtimeAnnotate(representation.annotations)
     for (let index = 0; index < representation.checks.length; index++) {
       const check = representation.checks[index]
-      runtime += `.check(${compileCheck(check, [...path, "checks", index])})`
+      const compiledCheck = compileCheck(check, [...path, "checks", index])
+      // Only collapse a bare number's leading canonical check.
+      runtime = runtime === "Schema.Number" && compiledCheck === canonicalFiniteCheck
+        ? "Schema.Finite"
+        : `${runtime}.check(${compiledCheck})`
     }
     return makeCode(runtime, base.Type)
   }

package/src/internal/schema/toJsonSchemaDocument.ts

@@ -121,6 +121,37 @@ function hasNoCollisions(left: JsonSchema.JsonSchema, rightKeys: ReadonlyArray<s
   return typeof left.$ref !== "string" && rightKeys.every((key) => !Object.hasOwn(left, key))
 }
 
+// Every bound on one schema object applies, so a repeated bound reduces to its tighter value.
+const lowerBoundKeywords = "|minimum|exclusiveMinimum|minLength|minItems|minProperties|"
+const upperBoundKeywords = "|maximum|exclusiveMaximum|maxLength|maxItems|maxProperties|"
+
+// Tightens repeated bounds and drops an inclusive or exclusive bound implied by the other on the same side. Returns
+// `undefined` for a `$ref` schema or a non-bound collision, so the caller falls back to `allOf`.
+function mergeInlineCheck(
+  left: JsonSchema.JsonSchema,
+  right: JsonSchema.JsonSchema,
+  rightKeys: ReadonlyArray<string>
+): JsonSchema.JsonSchema | undefined {
+  if (typeof left.$ref === "string") return undefined
+  const out: JsonSchema.JsonSchema = { ...left, ...right }
+  for (const key of rightKeys) {
+    if (!Object.hasOwn(left, key)) continue
+    const a = left[key]
+    const b = right[key]
+    if (typeof a !== "number" || typeof b !== "number") return undefined
+    if (lowerBoundKeywords.includes(`|${key}|`)) out[key] = Math.max(a, b)
+    else if (upperBoundKeywords.includes(`|${key}|`)) out[key] = Math.min(a, b)
+    else return undefined
+  }
+  if (typeof out.minimum === "number" && typeof out.exclusiveMinimum === "number") {
+    delete out[out.exclusiveMinimum >= out.minimum ? "minimum" : "exclusiveMinimum"]
+  }
+  if (typeof out.maximum === "number" && typeof out.exclusiveMaximum === "number") {
+    delete out[out.exclusiveMaximum <= out.maximum ? "maximum" : "exclusiveMaximum"]
+  }
+  return out
+}
+
 // `format` and `content*` can affect validation, so they are not treated as pure annotations.
 const promotableAnnotationKeywords = "|title|description|default|examples|readOnly|writeOnly|"
 const inlineableAnnotatedCheckKeywords = inlineableCheckKeywords + promotableAnnotationKeywords
@@ -149,8 +180,9 @@ function appendJsonSchema(
         : appendJsonSchema(base, extracted.schema, inlineCheck)
     }
   }
-  if (inlineCheck && hasNoCollisions(left, rightKeys)) {
-    return { ...left, ...right }
+  if (inlineCheck) {
+    const merged = mergeInlineCheck(left, right, rightKeys)
+    if (merged !== undefined) return merged
   }
   const members = Array.isArray(right.allOf) && rightKeys.length === 1 ? right.allOf : [right]
   if (Array.isArray(left.allOf)) {

package/src/internal/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = "4.0.2"
+export const version = "4.0.4"