effect@3.13.3

Patch Changes

• #4502 cc5588d Thanks @gcanti! - Schema: More Accurate Return Types for DataFromSelf and Data.

  This update refines the return types of DataFromSelf and Data, making them clearer and more specific, especially when working with structured schemas.

  Before

  The return types were more generic, making it harder to see the underlying structure:

  import { Schema } from "effect"
  
  const struct = Schema.Struct({ a: Schema.NumberFromString })
  
  //       ┌─── Schema.DataFromSelf<Schema<{ readonly a: number; }, { readonly a: string; }>>
  //       ▼
  const schema1 = Schema.DataFromSelf(struct)
  
  //       ┌─── Schema.Data<Schema<{ readonly a: number; }, { readonly a: string; }>>
  //       ▼
  const schema2 = Schema.Data(struct)

  After

  Now, the return types clearly reflect the original schema structure:

  import { Schema } from "effect"
  
  const struct = Schema.Struct({ a: Schema.NumberFromString })
  
  //       ┌─── Schema.DataFromSelf<Schema.Struct<{ a: typeof Schema.NumberFromString; }>>
  //       ▼
  const schema1 = Schema.DataFromSelf(struct)
  
  //       ┌─── Schema.Data<Schema.Struct<{ a: typeof Schema.NumberFromString; }>>
  //       ▼
  const schema2 = Schema.Data(struct)

• #4510 623c8cd Thanks @gcanti! - Schema: More Accurate Return Type for compose.

  Before

  import { Schema } from "effect"
  
  //      ┌─── SchemaClass<number | null, string>
  //      ▼
  const schema = Schema.compose(
    Schema.NumberFromString,
    Schema.NullOr(Schema.Number)
  )
  
  // @ts-expect-error: Property 'from' does not exist
  schema.from
  
  // @ts-expect-error: Property 'to' does not exist
  schema.to

  After

  import { Schema } from "effect"
  
  //      ┌─── transform<typeof Schema.NumberFromString, Schema.NullOr<typeof Schema.Number>>
  //      ▼
  const schema = Schema.compose(
    Schema.NumberFromString,
    Schema.NullOr(Schema.Number)
  )
  
  //      ┌─── typeof Schema.NumberFromString
  //      ▼
  schema.from
  
  //      ┌─── Schema.NullOr<typeof Schema.Number>
  //      ▼
  schema.to

• #4488 00b4eb1 Thanks @gcanti! - Schema: more precise return types when filters are involved.

  Example (with Schema.maxLength)

  Before

  import { Schema } from "effect"
  
  //      ┌─── Schema.filter<Schema.Schema<string, string, never>>
  //      ▼
  const schema = Schema.String.pipe(Schema.maxLength(10))
  
  // Schema<string, string, never>
  schema.from

  After

  import { Schema } from "effect"
  
  //      ┌─── Schema.filter<typeof Schema.String>
  //      ▼
  const schema = Schema.String.pipe(Schema.maxLength(10))
  
  // typeof Schema.String
  schema.from

  String filters:

  • maxLength
  • minLength
  • length
  • pattern
  • startsWith
  • endsWith
  • includes
  • lowercased
  • capitalized
  • uncapitalized
  • uppercased
  • nonEmptyString
  • trimmed

  Number filters:

  • finite
  • greaterThan
  • greaterThanOrEqualTo
  • lessThan
  • lessThanOrEqualTo
  • int
  • multipleOf
  • between
  • nonNaN
  • positive
  • negative
  • nonPositive
  • nonNegative

  BigInt filters:

  • greaterThanBigInt
  • greaterThanOrEqualToBigInt
  • lessThanBigInt
  • lessThanOrEqualToBigInt
  • betweenBigInt
  • positiveBigInt
  • negativeBigInt
  • nonNegativeBigInt
  • nonPositiveBigInt

  Duration filters:

  • lessThanDuration
  • lessThanOrEqualToDuration
  • greaterThanDuration
  • greaterThanOrEqualToDuration
  • betweenDuration

  Array filters:

  • minItems
  • maxItems
  • itemsCount

  Date filters:

  • validDate
  • lessThanDate
  • lessThanOrEqualToDate
  • greaterThanDate
  • greaterThanOrEqualToDate
  • betweenDate

  BigDecimal filters:

  • greaterThanBigDecimal
  • greaterThanOrEqualToBigDecimal
  • lessThanBigDecimal
  • lessThanOrEqualToBigDecimal
  • positiveBigDecimal
  • nonNegativeBigDecimal
  • negativeBigDecimal
  • nonPositiveBigDecimal
  • betweenBigDecimal

• #4508 f2aee98 Thanks @gcanti! - Schema: More Accurate Return Types for ArrayEnsure and NonEmptyArrayEnsure.

  Before

  import { Schema } from "effect"
  
  const schema1 = Schema.ArrayEnsure(Schema.String)
  
  // @ts-expect-error: Property 'from' does not exist
  schema1.from
  
  const schema2 = Schema.NonEmptyArrayEnsure(Schema.String)
  
  // @ts-expect-error: Property 'from' does not exist
  schema2.from

  After

  import { Schema } from "effect"
  
  const schema1 = Schema.ArrayEnsure(Schema.String)
  
  //        ┌─── Schema.Union<[typeof Schema.String, Schema.Array$<typeof Schema.String>]>
  //        ▼
  schema1.from
  
  const schema2 = Schema.NonEmptyArrayEnsure(Schema.String)
  
  //        ┌─── Schema.Union<[typeof Schema.String, Schema.NonEmptyArray<typeof Schema.String>]>
  //        ▼
  schema2.from

• #4509 fb798eb Thanks @gcanti! - Schema: More Accurate Return Types for:

  • transformLiteral
  • clamp
  • clampBigInt
  • clampDuration
  • clampBigDecimal
  • head
  • headNonEmpty
  • headOrElse

• #4524 2251b15 Thanks @gcanti! - Schema: More Accurate Return Type for parseNumber.

  Before

  import { Schema } from "effect"
  
  const schema = Schema.parseNumber(Schema.String)
  
  //      ┌─── Schema<string>
  //      ▼
  schema.from

  After

  import { Schema } from "effect"
  
  const schema = Schema.parseNumber(Schema.String)
  
  //      ┌─── typeof Schema.String
  //      ▼
  schema.from

• #4483 2e15c1e Thanks @mikearnaldi! - Fix nested batching

• #4514 a4979db Thanks @gcanti! - Schema: add missing from property to brand interface.

  Before

  import { Schema } from "effect"
  
  const schema = Schema.String.pipe(Schema.brand("my-brand"))
  
  // @ts-expect-error: Property 'from' does not exist
  schema.from

  After

  import { Schema } from "effect"
  
  const schema = Schema.String.pipe(Schema.brand("my-brand"))
  
  //      ┌─── typeof Schema.String
  //      ▼
  schema.from

• #4496 b74255a Thanks @tim-smart! - ensure fibers can't be added to Fiber{Handle,Set,Map} during closing

• #4419 d7f6a5c Thanks @KhraksMamtsov! - Fix Context.Tag unification

• #4495 9dd8979 Thanks @KhraksMamtsov! - Simplify sortWith, sort, reverse, sortBy, unzip, dedupe signatures in Array module

• #4507 477b488 Thanks @gcanti! - Schema: More Accurate Return Type for parseJson(schema).

  Before

  import { Schema } from "effect"
  
  //      ┌─── Schema.SchemaClass<{ readonly a: number; }, string>
  //      ▼
  const schema = Schema.parseJson(
    Schema.Struct({
      a: Schema.NumberFromString
    })
  )
  
  // @ts-expect-error: Property 'to' does not exist
  schema.to

  After

  import { Schema } from "effect"
  
  //      ┌─── Schema.transform<Schema.SchemaClass<unknown, string, never>, Schema.Struct<{ a: typeof Schema.NumberFromString; }>>
  //      ▼
  const schema = Schema.parseJson(
    Schema.Struct({
      a: Schema.NumberFromString
    })
  )
  
  //      ┌─── Schema.Struct<{ a: typeof Schema.NumberFromString; }>
  //      ▼
  schema.to

• #4519 10932cb Thanks @gcanti! - Refactor JSONSchema to use additionalProperties instead of patternProperties for simple records, closes #4518.

  This update improves how records are represented in JSON Schema by replacing patternProperties with additionalProperties, resolving issues in OpenAPI schema generation.

  Why the change?

  • Fixes OpenAPI issues – Previously, records were represented using patternProperties, which caused problems with OpenAPI tools.
  • Better schema compatibility – Some tools, like openapi-ts, struggled with patternProperties, generating Record<string, never> instead of the correct type.
  • Fixes missing example values – When using patternProperties, OpenAPI failed to generate proper response examples, displaying only {}.
  • Simplifies schema modification – Users previously had to manually fix schemas with OpenApi.Transform, which was messy and lacked type safety.

  Before

  import { JSONSchema, Schema } from "effect"
  
  const schema = Schema.Record({ key: Schema.String, value: Schema.Number })
  
  console.log(JSON.stringify(JSONSchema.make(schema), null, 2))
  /*
  {
    "$schema": "http://json-schema.org/draft-07/schema#",
    "type": "object",
    "required": [],
    "properties": {},
    "patternProperties": {
      "": { // ❌ Empty string pattern
        "type": "number"
      }
    }
  }
  */

  After

  Now, additionalProperties is used instead, which properly represents an open-ended record:

  import { JSONSchema, Schema } from "effect"
  
  const schema = Schema.Record({ key: Schema.String, value: Schema.Number })
  
  console.log(JSON.stringify(JSONSchema.make(schema), null, 2))
  /*
  {
    "$schema": "http://json-schema.org/draft-07/schema#",
    "type": "object",
    "required": [],
    "properties": {},
    "additionalProperties": { // ✅ Represents unrestricted record keys
      "type": "number"
    }
  }
  */

• #4501 9f6c784 Thanks @gcanti! - Schema: Add Missing declare API Interface to Expose Type Parameters.

  Example

  import { Schema } from "effect"
  
  const schema = Schema.OptionFromSelf(Schema.String)
  
  //       ┌─── readonly [typeof Schema.String]
  //       ▼
  schema.typeParameters

• #4487 2c639ec Thanks @gcanti! - Schema: more precise return types when transformations are involved.

  • Chunk
  • NonEmptyChunk
  • Redacted
  • Option
  • OptionFromNullOr
  • OptionFromUndefinedOr
  • OptionFromNullishOr
  • Either
  • EitherFromUnion
  • ReadonlyMap
  • Map
  • HashMap
  • ReadonlySet
  • Set
  • HashSet
  • List
  • Cause
  • Exit
  • SortedSet
  • head
  • headNonEmpty
  • headOrElse

  Example (with Schema.Chunk)

  Before

  import { Schema } from "effect"
  
  const schema = Schema.Chunk(Schema.Number)
  
  // Property 'from' does not exist on type 'Chunk<typeof Number$>'
  schema.from

  After

  import { Schema } from "effect"
  
  const schema = Schema.Chunk(Schema.Number)
  
  // Schema.Array$<typeof Schema.Number>
  schema.from

• #4492 886aaa8 Thanks @gcanti! - Schema: Improve Literal return type — now returns SchemaClass instead of Schema