effect 4.0.0-beta.10 → 4.0.0-beta.12

package/src/Config.ts

@@ -886,18 +886,19 @@ export function schema<T, E>(codec: Schema.Codec<T, E>, path?: string | ConfigPr
   const decodeUnknownEffect = Parser.decodeUnknownEffect(toCodecStringTree)
   const toCodecStringTreeEncoded = AST.toEncoded(toCodecStringTree.ast)
   const defaultPath = typeof path === "string" ? [path] : path ?? []
-  return make((provider) =>
-    recur(toCodecStringTreeEncoded, provider, defaultPath).pipe(
+  return make((provider) => {
+    const path = provider.prefix ? [...provider.prefix, ...defaultPath] : defaultPath
+    return recur(toCodecStringTreeEncoded, provider, defaultPath).pipe(
       Effect.flatMapEager((tree) =>
-        decodeUnknownEffect(tree).pipe(Effect.mapErrorEager((issue) =>
-          new Schema.SchemaError(defaultPath.length > 0 ? new Issue.Pointer(defaultPath, issue) : issue)
-        ))
+        decodeUnknownEffect(tree).pipe(
+          Effect.mapErrorEager((issue) =>
+            new Schema.SchemaError(path.length > 0 ? new Issue.Pointer(path, issue) : issue)
+          )
+        )
       ),
-      Effect.mapErrorEager((cause) =>
-        new ConfigError(cause)
-      )
+      Effect.mapErrorEager((cause) => new ConfigError(cause))
     )
-  )
+  })
 }
 
 /** @internal */
@@ -1446,3 +1447,164 @@ export function url(name?: string) {
 export function date(name?: string) {
   return schema(Schema.DateValid, name)
 }
+
+/**
+ * Scopes a config under a named prefix.
+ *
+ * When to use:
+ * - Grouping related config keys under a common namespace (e.g.
+ *   `"database"`, `"redis"`).
+ * - Building reusable config fragments that callers nest at different paths.
+ *
+ * The prefix is prepended to every key the inner config reads. With
+ * `fromUnknown` this means an extra object level; with `fromEnv` it means
+ * a `_`-separated prefix on env var names.
+ *
+ * Multiple `nested` calls compose: the outermost name becomes the
+ * outermost path segment.
+ *
+ * **Example** (Nesting a struct config under `"database"`)
+ *
+ * ```ts
+ * import { Config, ConfigProvider, Effect } from "effect"
+ *
+ * const dbConfig = Config.all({
+ *   host: Config.string("host"),
+ *   port: Config.number("port")
+ * }).pipe(Config.nested("database"))
+ *
+ * const provider = ConfigProvider.fromUnknown({
+ *   database: { host: "localhost", port: "5432" }
+ * })
+ * // Effect.runSync(dbConfig.parse(provider))
+ * // { host: "localhost", port: 5432 }
+ * ```
+ *
+ * **Example** (Env vars with nested prefix)
+ *
+ * ```ts
+ * import { Config, ConfigProvider, Effect } from "effect"
+ *
+ * const host = Config.string("host").pipe(Config.nested("database"))
+ *
+ * const provider = ConfigProvider.fromEnv({
+ *   env: { database_host: "localhost" }
+ * })
+ * // Effect.runSync(host.parse(provider)) // "localhost"
+ * ```
+ *
+ * @see {@link all} – combine multiple configs into a struct
+ * @see {@link schema} – read structured config from a schema
+ *
+ * @category Combinators
+ * @since 4.0.0
+ */
+export const nested: {
+  /**
+   * Scopes a config under a named prefix.
+   *
+   * When to use:
+   * - Grouping related config keys under a common namespace (e.g.
+   *   `"database"`, `"redis"`).
+   * - Building reusable config fragments that callers nest at different paths.
+   *
+   * The prefix is prepended to every key the inner config reads. With
+   * `fromUnknown` this means an extra object level; with `fromEnv` it means
+   * a `_`-separated prefix on env var names.
+   *
+   * Multiple `nested` calls compose: the outermost name becomes the
+   * outermost path segment.
+   *
+   * **Example** (Nesting a struct config under `"database"`)
+   *
+   * ```ts
+   * import { Config, ConfigProvider, Effect } from "effect"
+   *
+   * const dbConfig = Config.all({
+   *   host: Config.string("host"),
+   *   port: Config.number("port")
+   * }).pipe(Config.nested("database"))
+   *
+   * const provider = ConfigProvider.fromUnknown({
+   *   database: { host: "localhost", port: "5432" }
+   * })
+   * // Effect.runSync(dbConfig.parse(provider))
+   * // { host: "localhost", port: 5432 }
+   * ```
+   *
+   * **Example** (Env vars with nested prefix)
+   *
+   * ```ts
+   * import { Config, ConfigProvider, Effect } from "effect"
+   *
+   * const host = Config.string("host").pipe(Config.nested("database"))
+   *
+   * const provider = ConfigProvider.fromEnv({
+   *   env: { database_host: "localhost" }
+   * })
+   * // Effect.runSync(host.parse(provider)) // "localhost"
+   * ```
+   *
+   * @see {@link all} – combine multiple configs into a struct
+   * @see {@link schema} – read structured config from a schema
+   *
+   * @category Combinators
+   * @since 4.0.0
+   */
+  (name: string): <A>(self: Config<A>) => Config<A>
+  /**
+   * Scopes a config under a named prefix.
+   *
+   * When to use:
+   * - Grouping related config keys under a common namespace (e.g.
+   *   `"database"`, `"redis"`).
+   * - Building reusable config fragments that callers nest at different paths.
+   *
+   * The prefix is prepended to every key the inner config reads. With
+   * `fromUnknown` this means an extra object level; with `fromEnv` it means
+   * a `_`-separated prefix on env var names.
+   *
+   * Multiple `nested` calls compose: the outermost name becomes the
+   * outermost path segment.
+   *
+   * **Example** (Nesting a struct config under `"database"`)
+   *
+   * ```ts
+   * import { Config, ConfigProvider, Effect } from "effect"
+   *
+   * const dbConfig = Config.all({
+   *   host: Config.string("host"),
+   *   port: Config.number("port")
+   * }).pipe(Config.nested("database"))
+   *
+   * const provider = ConfigProvider.fromUnknown({
+   *   database: { host: "localhost", port: "5432" }
+   * })
+   * // Effect.runSync(dbConfig.parse(provider))
+   * // { host: "localhost", port: 5432 }
+   * ```
+   *
+   * **Example** (Env vars with nested prefix)
+   *
+   * ```ts
+   * import { Config, ConfigProvider, Effect } from "effect"
+   *
+   * const host = Config.string("host").pipe(Config.nested("database"))
+   *
+   * const provider = ConfigProvider.fromEnv({
+   *   env: { database_host: "localhost" }
+   * })
+   * // Effect.runSync(host.parse(provider)) // "localhost"
+   * ```
+   *
+   * @see {@link all} – combine multiple configs into a struct
+   * @see {@link schema} – read structured config from a schema
+   *
+   * @category Combinators
+   * @since 4.0.0
+   */
+  <A>(self: Config<A>, name: string): Config<A>
+} = dual(
+  2,
+  <A>(self: Config<A>, name: string): Config<A> => make((provider) => self.parse(ConfigProvider.nested(provider, name)))
+)

package/src/Effect.ts

@@ -84,7 +84,7 @@ import * as internalRequest from "./internal/request.ts"
 import * as internalSchedule from "./internal/schedule.ts"
 import type * as Layer from "./Layer.ts"
 import type { Logger } from "./Logger.ts"
-import type { LogLevel } from "./LogLevel.ts"
+import type { Severity } from "./LogLevel.ts"
 import * as Metric from "./Metric.ts"
 import type { Option } from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
@@ -853,6 +853,214 @@ export const partition: {
   ): Effect<[excluded: Array<E>, satisfying: Array<B>], never, R>
 } = internal.partition
 
+/**
+ * Applies an effectful function to each element and accumulates all failures.
+ *
+ * This function always evaluates every element. If at least one effect fails,
+ * all failures are returned as a non-empty array and successes are discarded.
+ * If all effects succeed, it returns all collected successes.
+ *
+ * Use `discard: true` to ignore successful values while still validating all
+ * elements.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const program = Effect.validate([0, 1, 2, 3], (n) =>
+ *   n % 2 === 0 ? Effect.fail(`${n} is even`) : Effect.succeed(n)
+ * )
+ *
+ * Effect.runPromiseExit(program).then(console.log)
+ * // {
+ * //   _id: 'Exit',
+ * //   _tag: 'Failure',
+ * //   cause: {
+ * //     _id: 'Cause',
+ * //     reasons: [
+ * //       { _id: 'Reason', _tag: 'Fail', error: '0 is even' },
+ * //       { _id: 'Reason', _tag: 'Fail', error: '2 is even' }
+ * //     ]
+ * //   }
+ * // }
+ * ```
+ *
+ * @since 4.0.0
+ * @category Error Accumulation
+ */
+export const validate: {
+  /**
+   * Applies an effectful function to each element and accumulates all failures.
+   *
+   * This function always evaluates every element. If at least one effect fails,
+   * all failures are returned as a non-empty array and successes are discarded.
+   * If all effects succeed, it returns all collected successes.
+   *
+   * Use `discard: true` to ignore successful values while still validating all
+   * elements.
+   *
+   * @example
+   * ```ts
+   * import { Effect } from "effect"
+   *
+   * const program = Effect.validate([0, 1, 2, 3], (n) =>
+   *   n % 2 === 0 ? Effect.fail(`${n} is even`) : Effect.succeed(n)
+   * )
+   *
+   * Effect.runPromiseExit(program).then(console.log)
+   * // {
+   * //   _id: 'Exit',
+   * //   _tag: 'Failure',
+   * //   cause: {
+   * //     _id: 'Cause',
+   * //     reasons: [
+   * //       { _id: 'Reason', _tag: 'Fail', error: '0 is even' },
+   * //       { _id: 'Reason', _tag: 'Fail', error: '2 is even' }
+   * //     ]
+   * //   }
+   * // }
+   * ```
+   *
+   * @since 4.0.0
+   * @category Error Accumulation
+   */
+  <A, B, E, R>(
+    f: (a: A, i: number) => Effect<B, E, R>,
+    options?: {
+      readonly concurrency?: Concurrency | undefined
+      readonly discard?: false | undefined
+    } | undefined
+  ): (elements: Iterable<A>) => Effect<Array<B>, Arr.NonEmptyArray<E>, R>
+  /**
+   * Applies an effectful function to each element and accumulates all failures.
+   *
+   * This function always evaluates every element. If at least one effect fails,
+   * all failures are returned as a non-empty array and successes are discarded.
+   * If all effects succeed, it returns all collected successes.
+   *
+   * Use `discard: true` to ignore successful values while still validating all
+   * elements.
+   *
+   * @example
+   * ```ts
+   * import { Effect } from "effect"
+   *
+   * const program = Effect.validate([0, 1, 2, 3], (n) =>
+   *   n % 2 === 0 ? Effect.fail(`${n} is even`) : Effect.succeed(n)
+   * )
+   *
+   * Effect.runPromiseExit(program).then(console.log)
+   * // {
+   * //   _id: 'Exit',
+   * //   _tag: 'Failure',
+   * //   cause: {
+   * //     _id: 'Cause',
+   * //     reasons: [
+   * //       { _id: 'Reason', _tag: 'Fail', error: '0 is even' },
+   * //       { _id: 'Reason', _tag: 'Fail', error: '2 is even' }
+   * //     ]
+   * //   }
+   * // }
+   * ```
+   *
+   * @since 4.0.0
+   * @category Error Accumulation
+   */
+  <A, B, E, R>(
+    f: (a: A, i: number) => Effect<B, E, R>,
+    options: {
+      readonly concurrency?: Concurrency | undefined
+      readonly discard: true
+    }
+  ): (elements: Iterable<A>) => Effect<void, Arr.NonEmptyArray<E>, R>
+  /**
+   * Applies an effectful function to each element and accumulates all failures.
+   *
+   * This function always evaluates every element. If at least one effect fails,
+   * all failures are returned as a non-empty array and successes are discarded.
+   * If all effects succeed, it returns all collected successes.
+   *
+   * Use `discard: true` to ignore successful values while still validating all
+   * elements.
+   *
+   * @example
+   * ```ts
+   * import { Effect } from "effect"
+   *
+   * const program = Effect.validate([0, 1, 2, 3], (n) =>
+   *   n % 2 === 0 ? Effect.fail(`${n} is even`) : Effect.succeed(n)
+   * )
+   *
+   * Effect.runPromiseExit(program).then(console.log)
+   * // {
+   * //   _id: 'Exit',
+   * //   _tag: 'Failure',
+   * //   cause: {
+   * //     _id: 'Cause',
+   * //     reasons: [
+   * //       { _id: 'Reason', _tag: 'Fail', error: '0 is even' },
+   * //       { _id: 'Reason', _tag: 'Fail', error: '2 is even' }
+   * //     ]
+   * //   }
+   * // }
+   * ```
+   *
+   * @since 4.0.0
+   * @category Error Accumulation
+   */
+  <A, B, E, R>(
+    elements: Iterable<A>,
+    f: (a: A, i: number) => Effect<B, E, R>,
+    options?: {
+      readonly concurrency?: Concurrency | undefined
+      readonly discard?: false | undefined
+    } | undefined
+  ): Effect<Array<B>, Arr.NonEmptyArray<E>, R>
+  /**
+   * Applies an effectful function to each element and accumulates all failures.
+   *
+   * This function always evaluates every element. If at least one effect fails,
+   * all failures are returned as a non-empty array and successes are discarded.
+   * If all effects succeed, it returns all collected successes.
+   *
+   * Use `discard: true` to ignore successful values while still validating all
+   * elements.
+   *
+   * @example
+   * ```ts
+   * import { Effect } from "effect"
+   *
+   * const program = Effect.validate([0, 1, 2, 3], (n) =>
+   *   n % 2 === 0 ? Effect.fail(`${n} is even`) : Effect.succeed(n)
+   * )
+   *
+   * Effect.runPromiseExit(program).then(console.log)
+   * // {
+   * //   _id: 'Exit',
+   * //   _tag: 'Failure',
+   * //   cause: {
+   * //     _id: 'Cause',
+   * //     reasons: [
+   * //       { _id: 'Reason', _tag: 'Fail', error: '0 is even' },
+   * //       { _id: 'Reason', _tag: 'Fail', error: '2 is even' }
+   * //     ]
+   * //   }
+   * // }
+   * ```
+   *
+   * @since 4.0.0
+   * @category Error Accumulation
+   */
+  <A, B, E, R>(
+    elements: Iterable<A>,
+    f: (a: A, i: number) => Effect<B, E, R>,
+    options: {
+      readonly concurrency?: Concurrency | undefined
+      readonly discard: true
+    }
+  ): Effect<void, Arr.NonEmptyArray<E>, R>
+} = internal.validate
+
 /**
  * Executes an effectful operation for each element in an `Iterable`.
  *
@@ -6935,14 +7143,14 @@ export const sandbox: <A, E, R>(
  */
 export const ignore: <
   Arg extends Effect<any, any, any> | {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
   } | undefined = {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
   }
 >(
   effectOrOptions?: Arg,
   options?: {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
   } | undefined
 ) => [Arg] extends [Effect<infer _A, infer _E, infer _R>] ? Effect<void, never, _R>
   : <A, E, R>(self: Effect<A, E, R>) => Effect<void, never, R> = internal.ignore
@@ -6967,14 +7175,14 @@ export const ignore: <
  */
 export const ignoreCause: <
   Arg extends Effect<any, any, any> | {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
   } | undefined = {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
   }
 >(
   effectOrOptions?: Arg,
   options?: {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
   } | undefined
 ) => [Arg] extends [Effect<infer _A, infer _E, infer _R>] ? Effect<void, never, _R>
   : <A, E, R>(self: Effect<A, E, R>) => Effect<void, never, R> = internal.ignoreCause
@@ -7081,6 +7289,25 @@ export const withExecutionPlan: {
   ): Effect<A, E | PlanE, Exclude<R, Provides> | PlanR>
 } = internalExecutionPlan.withExecutionPlan
 
+/**
+ * Runs an effect and reports any errors to the configured `ErrorReporter`s.
+ *
+ * If the `defectsOnly` option is set to `true`, only defects (unrecoverable
+ * errors) will be reported, while regular failures will be ignored.
+ *
+ * @since 4.0.0
+ * @category Error Handling
+ */
+export const withErrorReporting: <
+  Arg extends Effect<any, any, any> | { readonly defectsOnly?: boolean | undefined } | undefined = {
+    readonly defectsOnly?: boolean | undefined
+  }
+>(
+  effectOrOptions: Arg,
+  options?: { readonly defectsOnly?: boolean | undefined } | undefined
+) => [Arg] extends [Effect<infer _A, infer _E, infer _R>] ? Arg : <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R> =
+  internal.withErrorReporting
+
 // -----------------------------------------------------------------------------
 // Fallback
 // -----------------------------------------------------------------------------
@@ -20191,7 +20418,7 @@ export const clockWith: <A, E, R>(
  * @since 2.0.0
  * @category Logging
  */
-export const logWithLevel: (level?: LogLevel) => (...message: ReadonlyArray<any>) => Effect<void> =
+export const logWithLevel: (level?: Severity) => (...message: ReadonlyArray<any>) => Effect<void> =
   internal.logWithLevel
 
 /**
@@ -20619,6 +20846,86 @@ export const annotateLogs = dual<
     })
 )
 
+/**
+ * Adds log annotations to the current scope.
+ *
+ * This differs from `annotateLogs`, which only annotates a specific effect.
+ * `annotateLogsScoped` updates annotations for the entire current `Scope` and
+ * restores the previous annotations when the scope closes.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const program = Effect.scoped(
+ *   Effect.gen(function*() {
+ *     yield* Effect.log("before")
+ *     yield* Effect.annotateLogsScoped({ requestId: "req-123" })
+ *     yield* Effect.log("inside scope")
+ *   })
+ * )
+ *
+ * Effect.runPromise(program)
+ * ```
+ *
+ * @since 4.0.0
+ * @category Logging
+ */
+export const annotateLogsScoped: {
+  /**
+   * Adds log annotations to the current scope.
+   *
+   * This differs from `annotateLogs`, which only annotates a specific effect.
+   * `annotateLogsScoped` updates annotations for the entire current `Scope` and
+   * restores the previous annotations when the scope closes.
+   *
+   * @example
+   * ```ts
+   * import { Effect } from "effect"
+   *
+   * const program = Effect.scoped(
+   *   Effect.gen(function*() {
+   *     yield* Effect.log("before")
+   *     yield* Effect.annotateLogsScoped({ requestId: "req-123" })
+   *     yield* Effect.log("inside scope")
+   *   })
+   * )
+   *
+   * Effect.runPromise(program)
+   * ```
+   *
+   * @since 4.0.0
+   * @category Logging
+   */
+  (key: string, value: unknown): Effect<void, never, Scope>
+  /**
+   * Adds log annotations to the current scope.
+   *
+   * This differs from `annotateLogs`, which only annotates a specific effect.
+   * `annotateLogsScoped` updates annotations for the entire current `Scope` and
+   * restores the previous annotations when the scope closes.
+   *
+   * @example
+   * ```ts
+   * import { Effect } from "effect"
+   *
+   * const program = Effect.scoped(
+   *   Effect.gen(function*() {
+   *     yield* Effect.log("before")
+   *     yield* Effect.annotateLogsScoped({ requestId: "req-123" })
+   *     yield* Effect.log("inside scope")
+   *   })
+   * )
+   *
+   * Effect.runPromise(program)
+   * ```
+   *
+   * @since 4.0.0
+   * @category Logging
+   */
+  (values: Record<string, unknown>): Effect<void, never, Scope>
+} = internal.annotateLogsScoped
+
 /**
  * Adds a span to each log line in this effect.
  *