effect 4.0.0-beta.59 → 4.0.0-beta.60

package/src/Duration.ts

@@ -87,6 +87,9 @@ export type Unit =
 /**
  * Valid input types that can be converted to a Duration.
  *
+ * String inputs accept values like `"10 seconds"`, `"500 millis"`,
+ * `"Infinity"`, and `"-Infinity"`.
+ *
  * @since 2.0.0
  * @category models
  */
@@ -96,6 +99,8 @@ export type Input =
   | bigint // nanos
   | readonly [seconds: number, nanos: number]
   | `${number} ${Unit}`
+  | "Infinity"
+  | "-Infinity"
   | DurationObject
 
 /**
@@ -140,7 +145,8 @@ const DURATION_REGEXP = /^(-?\d+(?:\.\d+)?)\s+(nanos?|micros?|millis?|seconds?|m
  *
  * const duration1 = Duration.fromInputUnsafe(1000) // 1000 milliseconds
  * const duration2 = Duration.fromInputUnsafe("5 seconds")
- * const duration3 = Duration.fromInputUnsafe([2, 500_000_000]) // 2 seconds and 500ms
+ * const duration3 = Duration.fromInputUnsafe("Infinity")
+ * const duration4 = Duration.fromInputUnsafe([2, 500_000_000]) // 2 seconds and 500ms
  * ```
  *
  * @since 2.0.0
@@ -153,6 +159,12 @@ export const fromInputUnsafe = (input: Input): Duration => {
     case "bigint":
       return nanos(input)
     case "string": {
+      if (input === "Infinity") {
+        return infinity
+      }
+      if (input === "-Infinity") {
+        return negativeInfinity
+      }
       const match = DURATION_REGEXP.exec(input)
       if (!match) break
       const [_, valueStr, unit] = match
@@ -666,8 +678,8 @@ export const weeks = (weeks: number): Duration => make(weeks * 604_800_000)
  * @since 2.0.0
  * @category getters
  */
-export const toMillis = (self: Duration): number =>
-  match(self, {
+export const toMillis = (self: Input): number =>
+  match(fromInputUnsafe(self), {
     onMillis: identity,
     onNanos: (nanos) => Number(nanos) / 1_000_000,
     onInfinity: () => Infinity,
@@ -688,8 +700,8 @@ export const toMillis = (self: Duration): number =>
  * @since 2.0.0
  * @category getters
  */
-export const toSeconds = (self: Duration): number =>
-  match(self, {
+export const toSeconds = (self: Input): number =>
+  match(fromInputUnsafe(self), {
     onMillis: (millis) => millis / 1_000,
     onNanos: (nanos) => Number(nanos) / 1_000_000_000,
     onInfinity: () => Infinity,
@@ -710,8 +722,8 @@ export const toSeconds = (self: Duration): number =>
  * @since 3.8.0
  * @category getters
  */
-export const toMinutes = (self: Duration): number =>
-  match(self, {
+export const toMinutes = (self: Input): number =>
+  match(fromInputUnsafe(self), {
     onMillis: (millis) => millis / 60_000,
     onNanos: (nanos) => Number(nanos) / 60_000_000_000,
     onInfinity: () => Infinity,
@@ -732,8 +744,8 @@ export const toMinutes = (self: Duration): number =>
  * @since 3.8.0
  * @category getters
  */
-export const toHours = (self: Duration): number =>
-  match(self, {
+export const toHours = (self: Input): number =>
+  match(fromInputUnsafe(self), {
     onMillis: (millis) => millis / 3_600_000,
     onNanos: (nanos) => Number(nanos) / 3_600_000_000_000,
     onInfinity: () => Infinity,
@@ -754,8 +766,8 @@ export const toHours = (self: Duration): number =>
  * @since 3.8.0
  * @category getters
  */
-export const toDays = (self: Duration): number =>
-  match(self, {
+export const toDays = (self: Input): number =>
+  match(fromInputUnsafe(self), {
     onMillis: (millis) => millis / 86_400_000,
     onNanos: (nanos) => Number(nanos) / 86_400_000_000_000,
     onInfinity: () => Infinity,
@@ -776,8 +788,8 @@ export const toDays = (self: Duration): number =>
  * @since 3.8.0
  * @category getters
  */
-export const toWeeks = (self: Duration): number =>
-  match(self, {
+export const toWeeks = (self: Input): number =>
+  match(fromInputUnsafe(self), {
     onMillis: (millis) => millis / 604_800_000,
     onNanos: (nanos) => Number(nanos) / 604_800_000_000_000,
     onInfinity: () => Infinity,
@@ -808,7 +820,8 @@ export const toWeeks = (self: Duration): number =>
  * @since 2.0.0
  * @category getters
  */
-export const toNanosUnsafe = (self: Duration): bigint => {
+export const toNanosUnsafe = (input: Input): bigint => {
+  const self = fromInputUnsafe(input)
   switch (self.value._tag) {
     case "Infinity":
     case "NegativeInfinity":
@@ -839,7 +852,7 @@ export const toNanosUnsafe = (self: Duration): bigint => {
  * @category getters
  * @since 4.0.0
  */
-export const toNanos: (self: Duration) => Option.Option<bigint> = Option.liftThrowable(toNanosUnsafe)
+export const toNanos: (self: Input) => Option.Option<bigint> = Option.liftThrowable(toNanosUnsafe)
 
 /**
  * Converts a Duration to high-resolution time format [seconds, nanoseconds].
@@ -856,7 +869,8 @@ export const toNanos: (self: Duration) => Option.Option<bigint> = Option.liftThr
  * @since 2.0.0
  * @category getters
  */
-export const toHrTime = (self: Duration): [seconds: number, nanos: number] => {
+export const toHrTime = (input: Input): [seconds: number, nanos: number] => {
+  const self = fromInputUnsafe(input)
   switch (self.value._tag) {
     case "Infinity":
       return [Infinity, 0]

package/src/Formatter.ts

@@ -362,8 +362,8 @@ function safeToString(input: any): string {
  *
  * Behavior:
  * - Does not mutate input.
- * - Uses `JSON.stringify` internally with a replacer that tracks seen
- *   objects.
+ * - Uses `JSON.stringify` internally with a replacer that tracks the
+ *   current object ancestry.
  * - Circular references are replaced with `undefined` (omitted from
  *   output).
  * - `Redactable` values are automatically redacted before serialization.
@@ -414,17 +414,23 @@ function safeToString(input: any): string {
 export function formatJson(input: unknown, options?: {
   readonly space?: number | string | undefined
 }): string {
-  let cache: Array<unknown> = []
-  const out = JSON.stringify(
+  const ancestors: Array<object> = []
+  return JSON.stringify(
     input,
-    (_key, value) =>
-      typeof value === "object" && value !== null
-        ? cache.includes(value)
-          ? undefined // circular reference
-          : cache.push(value) && redact(value)
-        : value,
+    function(this: unknown, _key: string, value: unknown) {
+      const redacted = redact(value)
+      if (typeof redacted !== "object" || redacted === null) {
+        return redacted
+      }
+      while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this) {
+        ancestors.pop()
+      }
+      if (ancestors.includes(redacted)) {
+        return undefined // circular reference
+      }
+      ancestors.push(redacted)
+      return redacted
+    },
     options?.space
   )
-  ;(cache as any) = undefined
-  return out
 }

package/src/Inspectable.ts

@@ -37,9 +37,8 @@
  *
  * @since 2.0.0
  */
-import { format } from "./Formatter.ts"
+import { format, formatJson } from "./Formatter.ts"
 import * as Predicate from "./Predicate.ts"
-import * as Redactable from "./Redactable.ts"
 import { redact } from "./Redactable.ts"
 
 /**
@@ -176,31 +175,12 @@ export const toStringUnknown = (u: unknown, whitespace: number | string | undefi
     return u
   }
   try {
-    return typeof u === "object" ? stringifyCircular(u, whitespace) : String(u)
+    return typeof u === "object" ? formatJson(u, { space: whitespace }) : String(u)
   } catch {
     return String(u)
   }
 }
 
-/**
- * @since 2.0.0
- */
-export const stringifyCircular = (obj: unknown, whitespace?: number | string | undefined): string => {
-  let cache: Array<unknown> = []
-  const retVal = JSON.stringify(
-    obj,
-    (_key, value) =>
-      typeof value === "object" && value !== null
-        ? cache.includes(value)
-          ? undefined // circular reference
-          : cache.push(value) && Redactable.redact(value)
-        : value,
-    whitespace
-  )
-  ;(cache as any) = undefined
-  return retVal
-}
-
 /**
  * A base prototype object that implements the {@link Inspectable} interface.
  *

package/src/Schema.ts

@@ -8862,6 +8862,35 @@ export const Duration: Duration = declare(
   }
 )
 
+const DurationString = String.annotate({ expected: "a string that will be decoded as a Duration" })
+
+/**
+ * Companion type for {@link DurationFromString}.
+ *
+ * @category Duration
+ * @since 4.0.0
+ */
+export interface DurationFromString extends decodeTo<Duration, String> {
+  readonly "Rebuild": DurationFromString
+}
+
+/**
+ * A transformation schema that parses a string into a `Duration`.
+ *
+ * Decoding:
+ * - A `string` is decoded as a `Duration`, accepting any format that
+ *   `Duration.fromInput` can parse.
+ *
+ * Encoding:
+ * - A `Duration` is encoded as a parseable `string`.
+ *
+ * @category Duration
+ * @since 4.0.0
+ */
+export const DurationFromString: DurationFromString = DurationString.pipe(
+  decodeTo(Duration, Transformation.durationFromString)
+)
+
 /**
  * Companion type for {@link DurationFromNanos}.
  *

package/src/SchemaTransformation.ts

@@ -35,7 +35,7 @@
  * - Trim/case strings → {@link trim}, {@link toLowerCase}, {@link toUpperCase}, {@link capitalize}, {@link uncapitalize}, {@link snakeToCamel}
  * - Parse key-value strings → {@link splitKeyValue}
  * - Coerce string ↔ number/bigint → {@link numberFromString}, {@link bigintFromString}
- * - Coerce string ↔ Date → {@link dateFromString}
+ * - Coerce string ↔ Date/Duration → {@link dateFromString}, {@link durationFromString}
  * - Decode durations → {@link durationFromNanos}, {@link durationFromMillis}
  * - Wrap nullable/optional as Option → {@link optionFromNullOr}, {@link optionFromOptionalKey}, {@link optionFromOptional}
  * - Parse URLs → {@link urlFromString}
@@ -915,6 +915,47 @@ export const dateFromString: Transformation<globalThis.Date, string> = new Trans
   Getter.transform(formatDate)
 )
 
+/**
+ * Decodes a `string` into a `Duration` and encodes a `Duration` back to a
+ * parseable `string`.
+ *
+ * When to use this:
+ * - Parsing human-readable duration strings from APIs, config, or user input.
+ *
+ * Behavior:
+ * - Decode: accepts any string that `Duration.fromInput` can parse, including
+ *   `"Infinity"` and `"-Infinity"`.
+ * - Encode: returns `String(duration)`, producing strings like `"2000 millis"`
+ *   or `"10 nanos"` that round-trip through the parser.
+ *
+ * **Example** (Duration from string)
+ *
+ * ```ts
+ * import { Schema, SchemaTransformation } from "effect"
+ *
+ * const schema = Schema.String.pipe(
+ *   Schema.decodeTo(Schema.Duration, SchemaTransformation.durationFromString)
+ * )
+ * ```
+ *
+ * See also:
+ * - {@link durationFromNanos}
+ * - {@link durationFromMillis}
+ *
+ * @since 4.0.0
+ */
+export const durationFromString: Transformation<Duration.Duration, string> = transformOrFail<
+  Duration.Duration,
+  string
+>({
+  decode: (s) =>
+    Option.match(Duration.fromInput(s as Duration.Input), {
+      onNone: () => Effect.fail(new Issue.InvalidValue(Option.some(s), { message: `Invalid Duration string: ${s}` })),
+      onSome: Effect.succeed
+    }),
+  encode: (duration) => Effect.succeed(globalThis.String(duration))
+})
+
 /**
  * Decodes a `bigint` (nanoseconds) into a `Duration` and encodes a
  * `Duration` back to `bigint` nanoseconds.
@@ -1250,7 +1291,7 @@ export const urlFromString: Transformation<URL, string> = transformOrFail<URL, s
   decode: (s) =>
     Effect.try({
       try: () => new URL(s),
-      catch: (e) => new Issue.InvalidValue(Option.some(s), { message: globalThis.String(e) })
+      catch: () => new Issue.InvalidValue(Option.some(s), { message: `Invalid URL string: ${s}` })
     }),
   encode: (url) => Effect.succeed(url.href)
 })
@@ -1592,7 +1633,8 @@ export const dateTimeUtcFromString: Transformation<DateTime.Utc, string> = trans
 >({
   decode: (s) => {
     return Option.match(DateTime.make(s), {
-      onNone: () => Effect.fail(new Issue.InvalidValue(Option.some(s), { message: "Invalid DateTime input" })),
+      onNone: () =>
+        Effect.fail(new Issue.InvalidValue(Option.some(s), { message: `Invalid UTC DateTime string: ${s}` })),
       onSome: (result) => Effect.succeed(DateTime.toUtc(result))
     })
   },
@@ -1609,7 +1651,7 @@ export const dateTimeZonedFromString: Transformation<DateTime.Zoned, string> = t
   decode: (s) => {
     return Option.match(DateTime.makeZonedFromString(s), {
       onNone: () =>
-        Effect.fail(new Issue.InvalidValue(Option.some(s), { message: `Invalid zoned DateTime string: ${s}` })),
+        Effect.fail(new Issue.InvalidValue(Option.some(s), { message: `Invalid Zoned DateTime string: ${s}` })),
       onSome: Effect.succeed
     })
   },

package/src/unstable/rpc/Rpc.ts

@@ -785,6 +785,141 @@ export const make = <
   }) as any
 }
 
+/**
+ * Create a custom Rpc constructor, that can transform the output schemas.
+ *
+ * ```typescript
+ * import { Schema } from "effect"
+ * import { Rpc } from "effect/unstable/rpc"
+ *
+ * // Create a custom Rpc wrapper definition by transforming the success and error
+ * // schemas.
+ * export interface RpcWithPagination extends Rpc.Custom {
+ *   readonly out: Rpc.Custom.Out<
+ *     Paginated<this["success"]>,
+ *     this["error"]
+ *   >
+ * }
+ *
+ * // The type definition for the transformed success schema.
+ * export interface Paginated<S extends Schema.Top> extends
+ *   Schema.Struct<{
+ *     readonly offset: Schema.Number
+ *     readonly total: Schema.Number
+ *     readonly results: Schema.$Array<S>
+ *   }>
+ * {}
+ *
+ * // You can then implement the schema transformation using `Rpc.custom`
+ * export const makePaginated = Rpc.custom<RpcWithPagination>((schemas) => ({
+ *   ...schemas,
+ *   success: Schema.Struct({
+ *     offset: Schema.Number,
+ *     total: Schema.Number,
+ *     results: Schema.Array(schemas.success)
+ *   })
+ * }))
+ *
+ * // You can then use the custom constructor in the same way `Rpc.make` is used.
+ * export const listAllRpc = makePaginated("listAll", {
+ *   success: Schema.String
+ * })
+ * ```
+ *
+ * @since 4.0.0
+ * @category Custom constructors
+ */
+export const custom = <Def extends Custom>(
+  f: (options: Custom.OutDefault) => (Def & Custom.OutDefault)["out"]
+) =>
+<
+  const Tag extends string,
+  Payload extends Schema.Top | Schema.Struct.Fields = Schema.Void,
+  Success extends Schema.Top = Schema.Void,
+  Error extends Schema.Top = Schema.Never,
+  const Stream extends boolean = false,
+  Out extends Custom.OutDefault = Custom.Kind<Def, Success, Error>
+>(tag: Tag, options?: {
+  readonly payload?: Payload
+  readonly success?: Success
+  readonly error?: Error
+  readonly defect?: DefectSchema
+  readonly stream?: Stream
+  readonly primaryKey?: [Payload] extends [Schema.Struct.Fields] ? ((
+      payload: Payload extends Schema.Struct.Fields ? Struct.Simplify<Schema.Struct<Payload>["Type"]> : Payload["Type"]
+    ) => string) :
+    never
+}): Rpc<
+  Tag,
+  Payload extends Schema.Struct.Fields ? Schema.Struct<Payload> : Payload,
+  Stream extends true ? RpcSchema.Stream<Out["success"], Out["error"]> : Out["success"],
+  Stream extends true ? typeof Schema.Never : Out["error"]
+> => {
+  const success = options?.success ?? Schema.Void
+  const error = options?.error ?? Schema.Never
+  const defect = options?.defect ?? Schema.Defect
+  const out = f({
+    success,
+    error,
+    defect
+  })
+  return make(tag, {
+    ...out,
+    primaryKey: options?.primaryKey,
+    payload: options?.payload,
+    stream: options?.stream
+  }) as any
+}
+
+/**
+ * @since 4.0.0
+ * @category Custom constructors
+ */
+export interface Custom {
+  readonly out: Custom.OutDefault
+  readonly success: Schema.Top
+  readonly error: Schema.Top
+  readonly defect: DefectSchema
+}
+
+/**
+ * @since 4.0.0
+ * @category Custom constructors
+ */
+export declare namespace Custom {
+  /**
+   * @since 4.0.0
+   * @category Custom constructors
+   */
+  export interface Out<
+    Success extends Schema.Top,
+    Error extends Schema.Top
+  > {
+    readonly success: Success
+    readonly error: Error
+    readonly defect: DefectSchema
+  }
+
+  /**
+   * @since 4.0.0
+   * @category Custom constructors
+   */
+  export type OutDefault = Out<Schema.Top, Schema.Top>
+
+  /**
+   * @since 4.0.0
+   * @category Custom constructors
+   */
+  export type Kind<
+    Def extends Custom,
+    Success extends Schema.Top,
+    Error extends Schema.Top
+  > = (Def & {
+    readonly success: Success
+    readonly error: Error
+  })["out"]
+}
+
 const exitSchemaCache = new WeakMap<Any, Schema.Exit<Schema.Top, Schema.Top, DefectSchema>>()
 
 /**