effect 4.0.2 → 4.0.4

package/dist/Schema.js

@@ -31,6 +31,7 @@ import * as HashSet_ from "./HashSet.js";
 import * as Cookies_ from "./http/Cookies.js";
 import * as Headers_ from "./http/Headers.js";
 import * as UrlParams_ from "./http/UrlParams.js";
+import { NodeInspectSymbol } from "./Inspectable.js";
 import * as core from "./internal/core.js";
 import { effectIsExit } from "./internal/effect.js";
 import * as InternalGraph from "./internal/graph.js";
@@ -48,6 +49,8 @@ import * as InternalToJsonSchemaDocument from "./internal/schema/toJsonSchemaDoc
 import * as InternalToRepresentation from "./internal/schema/toRepresentation.js";
 import { isSchemaError as isSchemaErrorInternal, SchemaErrorTypeId } from "./internal/schemaError.js";
 import { getStackTraceLimit, setStackTraceLimit } from "./internal/stackTraceLimit.js";
+import * as Dns_ from "./net/Dns.js";
+import * as Host_ from "./net/Host.js";
 import * as IpInterface_ from "./net/IpInterface.js";
 import * as IpNetwork_ from "./net/IpNetwork.js";
 import * as NetAddress_ from "./net/NetAddress.js";
@@ -376,6 +379,15 @@ export class SchemaError extends /*#__PURE__*/Data.TaggedError("SchemaError") {
   get message() {
     return SchemaIssue.defaultFormatter(this.issue);
   }
+  toJSON() {
+    return {
+      _tag: this._tag,
+      message: this.message
+    };
+  }
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
   toString() {
     return `SchemaError(${this.message})`;
   }
@@ -2147,6 +2159,13 @@ export function Record(key, value) {
  *
  * **Gotchas**
  *
+ * The base schema must have an object-shaped encoded type. Whole-object
+ * transformations are not supported, even with an empty rest array. Apply
+ * transformations such as `Schema.fromJsonString` to the completed
+ * `StructWithRest` schema instead. Object-shaped encoded types alone do not
+ * guarantee compatibility: unsupported encodings are still rejected at runtime.
+ * Transformations on individual fields remain supported.
+ *
  * TypeScript index signatures also apply to fixed keys. `StructWithRest` does
  * not reject incompatible fixed fields at the call site; use
  * `StructWithRest.ValidateRecords` when you want an explicit type-level
@@ -4528,7 +4547,8 @@ export function isMultipleOf(divisor, annotations) {
  *
  * JSON Schema:
  *
- * This check corresponds to the `type: "integer"` constraint in JSON Schema.
+ * This check corresponds to `type: "integer"` with `minimum: Number.MIN_SAFE_INTEGER`
+ * and `maximum: Number.MAX_SAFE_INTEGER` in JSON Schema.
  *
  * Arbitrary:
  *
@@ -4545,9 +4565,11 @@ export function isInt(annotations) {
       id: "effect/schema/isInt",
       payload: null
     },
-    toJsonSchema: () => [{
-      type: "integer"
-    }, true],
+    toJsonSchema: () => ({
+      type: "integer",
+      minimum: globalThis.Number.MIN_SAFE_INTEGER,
+      maximum: globalThis.Number.MAX_SAFE_INTEGER
+    }),
     toCode: () => ({
       runtime: "Schema.isInt()"
     }),
@@ -8160,6 +8182,113 @@ export const UnixPathAddressFromString = /*#__PURE__*/String.pipe(decodeTo(UnixP
 export const SocketAddress = /*#__PURE__*/declare(NetAddress_.isSocketAddress, {
   identifier: "SocketAddress"
 });
+/**
+ * Schema for normalized DNS domain names.
+ *
+ * **Details**
+ *
+ * Only names already in normalized form (lowercase ASCII, with
+ * internationalized labels in `xn--` form) are accepted. Use
+ * {@link DomainNameFromString} to normalize arbitrary input.
+ *
+ * @stability experimental
+ * @category schemas
+ * @since 4.0.0
+ */
+export const DomainName = /*#__PURE__*/String.check(makeFilter(Host_.isDomainName, {
+  expected: "a normalized domain name"
+})).pipe(brand("~effect/net/Host/DomainName")).annotate({
+  identifier: "DomainName"
+});
+/**
+ * Schema for DNS domain names decoded from strings, normalizing case and
+ * converting internationalized names to their ASCII form.
+ *
+ * @stability experimental
+ * @category schemas
+ * @since 4.0.0
+ */
+export const DomainNameFromString = /*#__PURE__*/netAddressFromString(DomainName, Host_.domainNameFromString, name => name, "DomainNameFromString");
+/**
+ * Schema for canonical scoped IPv6 literals such as `fe80::1%eth0`.
+ *
+ * @stability experimental
+ * @category schemas
+ * @since 4.0.0
+ */
+export const ScopedIpv6Literal = /*#__PURE__*/String.check(makeFilter(NetAddress_.isScopedIpv6Literal, {
+  expected: "a canonical scoped IPv6 literal"
+})).pipe(brand("~effect/net/NetAddress/ScopedIpv6Literal")).annotate({
+  identifier: "ScopedIpv6Literal"
+});
+/**
+ * Schema for scoped IPv6 literals decoded from strings, normalizing the address
+ * and numeric zones.
+ *
+ * @stability experimental
+ * @category schemas
+ * @since 4.0.0
+ */
+export const ScopedIpv6LiteralFromString = /*#__PURE__*/netAddressFromString(ScopedIpv6Literal, NetAddress_.scopedIpv6LiteralFromString, literal => literal, "ScopedIpv6LiteralFromString");
+/**
+ * Schema for hosts: numeric IP addresses, scoped IPv6 literals, or domain names.
+ *
+ * @stability experimental
+ * @category schemas
+ * @since 4.0.0
+ */
+export const Host = /*#__PURE__*/Union([IpAddress, ScopedIpv6Literal, DomainName]).annotate({
+  identifier: "Host"
+});
+/**
+ * Schema for hosts decoded from strings. Numeric IP strings decode to IP
+ * addresses; other strings decode to scoped IPv6 literals or domain names.
+ *
+ * @stability experimental
+ * @category schemas
+ * @since 4.0.0
+ */
+export const HostFromString = /*#__PURE__*/Union([IpAddressFromString, ScopedIpv6LiteralFromString, DomainNameFromString]).annotate({
+  identifier: "HostFromString"
+});
+/**
+ * Schema for already-constructed unresolved host and port values.
+ *
+ * @stability experimental
+ * @category schemas
+ * @since 4.0.0
+ */
+export const HostPort = /*#__PURE__*/declare(Host_.isHostPort, {
+  identifier: "HostPort"
+});
+/**
+ * Schema for unresolved endpoints encoded as `host:port` or `[IPv6]:port`
+ * strings.
+ *
+ * @stability experimental
+ * @category schemas
+ * @since 4.0.0
+ */
+export const HostPortFromString = /*#__PURE__*/netAddressFromString(HostPort, Host_.hostPortFromString, Host_.formatHostPort, "HostPortFromString");
+/**
+ * Schema for TCP and UDP port numbers from 0 through 65535.
+ *
+ * **Details**
+ *
+ * Port 0 is accepted because it asks the operating system to choose a port
+ * when binding, and it matches the port range of `InetAddress` and `HostPort`.
+ * `Config.Port` accepts only 1 through 65535.
+ *
+ * @stability experimental
+ * @category schemas
+ * @since 4.0.0
+ */
+export const Port = /*#__PURE__*/Int.check(/*#__PURE__*/isBetween({
+  minimum: 0,
+  maximum: 65535
+}, {
+  expected: "a port number"
+}));
 // -----------------------------------------------------------------------------
 // Duration schemas
 // -----------------------------------------------------------------------------
@@ -8324,6 +8453,235 @@ export const DurationFromNanos = /*#__PURE__*/BigInt.pipe(/*#__PURE__*/decodeTo(
  * @since 3.10.0
  */
 export const DurationFromMillis = /*#__PURE__*/Number.pipe(/*#__PURE__*/decodeTo(Duration, durationFromMillis));
+/**
+ * Schema for supported DNS record types such as `"A"` or `"SRV"`.
+ *
+ * @stability experimental
+ * @category schemas
+ * @since 4.0.0
+ */
+export const DnsRecordType = /*#__PURE__*/Literals(Dns_.recordTypes);
+// Addresses in JSON records must already be canonical; normalizing input is
+// left to the `*FromString` schemas.
+const dnsCanonicalAddress = (schema, parse) => String.pipe(decodeTo(schema, SchemaTransformation.transformEffect({
+  decode: (input, options) => {
+    const result = parse(input);
+    if (Result_.isFailure(result)) {
+      return Effect.fail(new SchemaIssue.InvalidValue({
+        message: result.failure.message
+      }, input, options));
+    }
+    return NetAddress_.formatIp(result.success) === input ? Effect.succeed(result.success) : Effect.fail(new SchemaIssue.InvalidValue({
+      message: "expected a canonical address"
+    }, input, options));
+  },
+  encode: address => Effect.succeed(NetAddress_.formatIp(address))
+})));
+const dnsUint8 = /*#__PURE__*/Int.check(/*#__PURE__*/isBetween({
+  minimum: 0,
+  maximum: 0xff
+}));
+const dnsUint16 = /*#__PURE__*/Int.check(/*#__PURE__*/isBetween({
+  minimum: 0,
+  maximum: 0xffff
+}));
+const dnsUint32 = /*#__PURE__*/Int.check(/*#__PURE__*/isBetween({
+  minimum: 0,
+  maximum: 0xffffffff
+}));
+// SOA timers are written as whole seconds, as in zone files.
+const dnsSeconds = /*#__PURE__*/dnsUint32.pipe(/*#__PURE__*/decodeTo(Duration, /*#__PURE__*/SchemaTransformation.transform({
+  decode: Duration_.seconds,
+  encode: Duration_.toSeconds
+})));
+// Each record type is an opaque value whose JSON form is a plain object tagged
+// by record type, such as `{ "_tag": "MX", "exchange": "mail.example.com", "priority": 10 }`.
+const dnsRecordOfType = (type, fields) => declare(u => Dns_.isDnsRecord(u) && u._tag === type, {
+  identifier: `Dns${type.charAt(0)}${type.slice(1).toLowerCase()}Record`,
+  toCodecJson: () => {
+    const json = TaggedStruct(type, fields);
+    return link()(json, SchemaTransformation.transformEffect({
+      decode: (input, options) => {
+        const {
+          _tag,
+          ...rest
+        } = input;
+        const result = Dns_.makeRecord(type, rest);
+        return Result_.isSuccess(result) ? Effect.succeed(result.success) : Effect.fail(new SchemaIssue.InvalidValue({
+          message: result.failure.message
+        }, input, options));
+      },
+      // Records hold only their tag and fields as own properties.
+      encode: record => Effect.succeed({
+        ...record
+      })
+    }));
+  }
+});
+/**
+ * Schema for already-constructed IPv4 address (`A`) DNS records.
+ *
+ * @stability experimental
+ * @category schemas
+ * @since 4.0.0
+ */
+export const DnsARecord = /*#__PURE__*/dnsRecordOfType("A", {
+  address: /*#__PURE__*/dnsCanonicalAddress(Ipv4Address, NetAddress_.ipv4FromString)
+});
+/**
+ * Schema for already-constructed IPv6 address (`AAAA`) DNS records.
+ *
+ * @stability experimental
+ * @category schemas
+ * @since 4.0.0
+ */
+export const DnsAaaaRecord = /*#__PURE__*/dnsRecordOfType("AAAA", {
+  address: /*#__PURE__*/dnsCanonicalAddress(Ipv6Address, NetAddress_.ipv6FromString)
+});
+/**
+ * Schema for already-constructed certification authority authorization (`CAA`) DNS records.
+ *
+ * @stability experimental
+ * @category schemas
+ * @since 4.0.0
+ */
+export const DnsCaaRecord = /*#__PURE__*/dnsRecordOfType("CAA", {
+  critical: Boolean,
+  tag: /*#__PURE__*/String.check(/*#__PURE__*/isPattern(/^[a-z0-9]+$/i)),
+  value: String
+});
+/**
+ * Schema for already-constructed canonical name (`CNAME`) DNS records.
+ *
+ * @stability experimental
+ * @category schemas
+ * @since 4.0.0
+ */
+export const DnsCnameRecord = /*#__PURE__*/dnsRecordOfType("CNAME", {
+  target: DomainName
+});
+/**
+ * Schema for already-constructed mail exchange (`MX`) DNS records.
+ *
+ * @stability experimental
+ * @category schemas
+ * @since 4.0.0
+ */
+export const DnsMxRecord = /*#__PURE__*/dnsRecordOfType("MX", {
+  exchange: DomainName,
+  priority: dnsUint16
+});
+/**
+ * Schema for already-constructed naming authority pointer (`NAPTR`) DNS records.
+ *
+ * @stability experimental
+ * @category schemas
+ * @since 4.0.0
+ */
+export const DnsNaptrRecord = /*#__PURE__*/dnsRecordOfType("NAPTR", {
+  order: dnsUint16,
+  preference: dnsUint16,
+  flags: String,
+  service: String,
+  regexp: String,
+  replacement: DomainName
+});
+/**
+ * Schema for already-constructed name server (`NS`) DNS records.
+ *
+ * @stability experimental
+ * @category schemas
+ * @since 4.0.0
+ */
+export const DnsNsRecord = /*#__PURE__*/dnsRecordOfType("NS", {
+  host: DomainName
+});
+/**
+ * Schema for already-constructed pointer (`PTR`) DNS records.
+ *
+ * @stability experimental
+ * @category schemas
+ * @since 4.0.0
+ */
+export const DnsPtrRecord = /*#__PURE__*/dnsRecordOfType("PTR", {
+  host: NonEmptyString
+});
+/**
+ * Schema for already-constructed start of authority (`SOA`) DNS records.
+ *
+ * @stability experimental
+ * @category schemas
+ * @since 4.0.0
+ */
+export const DnsSoaRecord = /*#__PURE__*/dnsRecordOfType("SOA", {
+  primary: DomainName,
+  admin: NonEmptyString,
+  serial: dnsUint32,
+  refresh: dnsSeconds,
+  retry: dnsSeconds,
+  expire: dnsSeconds,
+  minimum: dnsSeconds
+});
+/**
+ * Schema for already-constructed service locator (`SRV`) DNS records.
+ *
+ * @stability experimental
+ * @category schemas
+ * @since 4.0.0
+ */
+export const DnsSrvRecord = /*#__PURE__*/dnsRecordOfType("SRV", {
+  target: DomainName,
+  port: dnsUint16,
+  priority: dnsUint16,
+  weight: dnsUint16
+});
+/**
+ * Schema for already-constructed TLS authentication (`TLSA`) DNS records.
+ *
+ * **Details**
+ *
+ * The default JSON serializer encodes the certificate association `data` as a
+ * hex string.
+ *
+ * @stability experimental
+ * @category schemas
+ * @since 4.0.0
+ */
+export const DnsTlsaRecord = /*#__PURE__*/dnsRecordOfType("TLSA", {
+  certUsage: dnsUint8,
+  selector: dnsUint8,
+  matchingType: dnsUint8,
+  data: Uint8ArrayFromHex
+});
+/**
+ * Schema for already-constructed text (`TXT`) DNS records.
+ *
+ * @stability experimental
+ * @category schemas
+ * @since 4.0.0
+ */
+export const DnsTxtRecord = /*#__PURE__*/dnsRecordOfType("TXT", {
+  chunks: /*#__PURE__*/NonEmptyArray(String)
+});
+/**
+ * Schema for already-constructed DNS records of any supported record type.
+ *
+ * **Details**
+ *
+ * The default JSON serializer encodes records as objects tagged by record type,
+ * with addresses and names as canonical strings, SOA timers as whole seconds,
+ * and TLSA data as hex, such as
+ * `{ "_tag": "SRV", "target": "db.internal", "port": 5432, "priority": 10, "weight": 5 }`.
+ * Decoding accepts only canonical addresses and normalized domain names, and
+ * reports invalid fields with their path.
+ *
+ * @stability experimental
+ * @category schemas
+ * @since 4.0.0
+ */
+export const DnsRecord = /*#__PURE__*/Union([DnsARecord, DnsAaaaRecord, DnsCaaRecord, DnsCnameRecord, DnsMxRecord, DnsNaptrRecord, DnsNsRecord, DnsPtrRecord, DnsSoaRecord, DnsSrvRecord, DnsTlsaRecord, DnsTxtRecord]).annotate({
+  identifier: "DnsRecord"
+});
 /**
  * Creates a schema for `Exit` values using schemas for the success value, typed
  * failure, and unexpected defect channels.