effect 3.2.8 → 3.3.0

package/src/Types.ts

@@ -4,6 +4,54 @@
  * @since 2.0.0
  */
 
+type _TupleOf<T, N extends number, R extends Array<unknown>> = R["length"] extends N ? R : _TupleOf<T, N, [T, ...R]>
+
+/**
+ * Represents a tuple with a fixed number of elements of type `T`.
+ *
+ * This type constructs a tuple that has exactly `N` elements of type `T`.
+ *
+ * @typeParam N - The number of elements in the tuple.
+ * @typeParam T - The type of elements in the tuple.
+ *
+ * @example
+ * import { TupleOf } from "effect/Types"
+ *
+ * // A tuple with exactly 3 numbers
+ * const example1: TupleOf<3, number> = [1, 2, 3]; // valid
+ * // @ts-expect-error
+ * const example2: TupleOf<3, number> = [1, 2]; // invalid
+ * // @ts-expect-error
+ * const example3: TupleOf<3, number> = [1, 2, 3, 4]; // invalid
+ *
+ * @category tuples
+ * @since 3.3.0
+ */
+export type TupleOf<N extends number, T> = N extends N ? number extends N ? Array<T> : _TupleOf<T, N, []> : never
+
+/**
+ * Represents a tuple with at least `N` elements of type `T`.
+ *
+ * This type constructs a tuple that has a fixed number of elements `N` of type `T` at the start,
+ * followed by any number (including zero) of additional elements of the same type `T`.
+ *
+ * @typeParam N - The minimum number of elements in the tuple.
+ * @typeParam T - The type of elements in the tuple.
+ *
+ * @example
+ * import { TupleOfAtLeast } from "effect/Types"
+ *
+ * // A tuple with at least 3 numbers
+ * const example1: TupleOfAtLeast<3, number> = [1, 2, 3]; // valid
+ * const example2: TupleOfAtLeast<3, number> = [1, 2, 3, 4, 5]; // valid
+ * // @ts-expect-error
+ * const example3: TupleOfAtLeast<3, number> = [1, 2]; // invalid
+ *
+ * @category tuples
+ * @since 3.3.0
+ */
+export type TupleOfAtLeast<N extends number, T> = [...TupleOf<N, T>, ...Array<T>]
+
 /**
  * Returns the tags in a type.
  * @example

package/src/Utils.ts

@@ -172,17 +172,20 @@ export interface Variance<in out F extends TypeLambda, in R, out O, out E> {
   readonly _E: Types.Covariant<E>
 }
 
-/**
- * @category models
- * @since 2.0.0
- */
 /**
  * @category models
  * @since 2.0.0
  */
 export interface Gen<F extends TypeLambda, Z> {
-  <K extends Variance<F, any, any, any> | YieldWrap<Kind<F, any, any, any, any>>, A>(
-    body: (resume: Z) => Generator<K, A, never>
+  <Self, K extends Variance<F, any, any, any> | YieldWrap<Kind<F, any, any, any, any>>, A>(
+    ...args:
+      | [
+        self: Self,
+        body: (this: Self, resume: Z) => Generator<K, A, never>
+      ]
+      | [
+        body: (resume: Z) => Generator<K, A, never>
+      ]
   ): Kind<
     F,
     [K] extends [Variance<F, infer R, any, any>] ? R

package/src/index.ts

@@ -614,6 +614,11 @@ export * as Record from "./Record.js"
  */
 export * as RedBlackTree from "./RedBlackTree.js"
 
+/**
+ * @since 3.3.0
+ */
+export * as Redacted from "./Redacted.js"
+
 /**
  * @since 2.0.0
  */
@@ -713,6 +718,7 @@ export * as ScopedRef from "./ScopedRef.js"
 
 /**
  * @since 2.0.0
+ * @deprecated
  */
 export * as Secret from "./Secret.js"
 

package/src/internal/cause.ts

@@ -983,8 +983,10 @@ class PrettyError extends globalThis.Error implements Cause.PrettyError {
     const prevLimit = Error.stackTraceLimit
     Error.stackTraceLimit = 0
     super(prettyErrorMessage(originalError))
+    if (this.message === "") {
+      this.message = "An error has occurred"
+    }
     Error.stackTraceLimit = prevLimit
-
     this.name = originalError instanceof Error ? originalError.name : "Error"
     if (typeof originalError === "object" && originalError !== null) {
       if (spanSymbol in originalError) {
@@ -998,21 +1000,13 @@ class PrettyError extends globalThis.Error implements Cause.PrettyError {
       })
     }
     this.stack = prettyErrorStack(
-      this.message,
+      `${this.name}: ${this.message}`,
       originalError instanceof Error && originalError.stack
         ? originalError.stack
         : "",
       this.span
     )
   }
-
-  toJSON() {
-    const out: any = { message: this.message, stack: this.stack }
-    if (this.span) {
-      out.span = this.span
-    }
-    return out
-  }
 }
 
 /**
@@ -1020,10 +1014,9 @@ class PrettyError extends globalThis.Error implements Cause.PrettyError {
  *
  * Rules:
  *
- * 1) If the input `u` is already a string, it's considered a message, and "Error" is added as a prefix.
- * 2) If `u` has a user-defined `toString()` method, it uses that method and adds "Error" as a prefix.
- * 3) If `u` is an object and its only (optional) properties are "name", "message", or "_tag", it constructs
- *    an error message based on those properties.
+ * 1) If the input `u` is already a string, it's considered a message.
+ * 2) If `u` is an Error instance with a message defined, it uses the message.
+ * 3) If `u` has a user-defined `toString()` method, it uses that method.
  * 4) Otherwise, it uses `JSON.stringify` to produce a string representation and uses it as the error message,
  *   with "Error" added as a prefix.
  *
@@ -1032,9 +1025,13 @@ class PrettyError extends globalThis.Error implements Cause.PrettyError {
 export const prettyErrorMessage = (u: unknown): string => {
   // 1)
   if (typeof u === "string") {
-    return `Error: ${u}`
+    return u
   }
   // 2)
+  if (typeof u === "object" && u !== null && u instanceof Error) {
+    return u.message
+  }
+  // 3)
   try {
     if (
       hasProperty(u, "toString") &&
@@ -1047,8 +1044,8 @@ export const prettyErrorMessage = (u: unknown): string => {
   } catch {
     // something's off, rollback to json
   }
-  // 3)
-  return `Error: ${JSON.stringify(u)}`
+  // 4)
+  return JSON.stringify(u)
 }
 
 const locationRegex = /\((.*)\)/

package/src/internal/clock.ts

@@ -40,15 +40,10 @@ export const globalClockScheduler: Clock.ClockScheduler = {
 
 const performanceNowNanos = (function() {
   const bigint1e6 = BigInt(1_000_000)
-
   if (typeof performance === "undefined") {
     return () => BigInt(Date.now()) * bigint1e6
   }
-
-  const origin = "timeOrigin" in performance && typeof performance.timeOrigin === "number" ?
-    BigInt(Math.round(performance.timeOrigin * 1_000_000)) :
-    (BigInt(Date.now()) * bigint1e6) - BigInt(Math.round(performance.now() * 1_000_000))
-
+  const origin = (BigInt(Date.now()) * bigint1e6) - BigInt(Math.round(performance.now() * 1_000_000))
   return () => origin + BigInt(Math.round(performance.now() * 1_000_000))
 })()
 const processOrPerformanceNow = (function() {

package/src/internal/config.ts

@@ -10,12 +10,14 @@ import * as HashSet from "../HashSet.js"
 import type * as LogLevel from "../LogLevel.js"
 import * as Option from "../Option.js"
 import { hasProperty, type Predicate, type Refinement } from "../Predicate.js"
+import type * as Redacted from "../Redacted.js"
 import type * as Secret from "../Secret.js"
 import * as configError from "./configError.js"
 import * as core from "./core.js"
 import * as defaultServices from "./defaultServices.js"
 import * as effectable from "./effectable.js"
 import * as OpCodes from "./opCodes/config.js"
+import * as redacted_ from "./redacted.js"
 import * as InternalSecret from "./secret.js"
 
 const ConfigSymbolKey = "effect/Config"
@@ -421,6 +423,15 @@ export const secret = (name?: string): Config.Config<Secret.Secret> => {
   return name === undefined ? config : nested(config, name)
 }
 
+/** @internal */
+export const redacted = (name?: string): Config.Config<Redacted.Redacted> => {
+  const config = primitive(
+    "a redacted property",
+    (text) => Either.right(redacted_.make(text))
+  )
+  return name === undefined ? config : nested(config, name)
+}
+
 /** @internal */
 export const hashSet = <A>(config: Config.Config<A>, name?: string): Config.Config<HashSet.HashSet<A>> => {
   const newConfig = map(chunk(config), HashSet.fromIterable)

package/src/internal/layer.ts

@@ -8,6 +8,7 @@ import type { FiberRef } from "../FiberRef.js"
 import * as FiberRefsPatch from "../FiberRefsPatch.js"
 import type { LazyArg } from "../Function.js"
 import { dual, pipe } from "../Function.js"
+import * as HashMap from "../HashMap.js"
 import type * as Layer from "../Layer.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty } from "../Predicate.js"
@@ -1108,10 +1109,72 @@ export const unwrapScoped = <A, E1, R1, E, R>(
   return flatMap(scoped(tag, self), (context) => Context.get(context, tag))
 }
 
+// -----------------------------------------------------------------------------
+// logging
+// -----------------------------------------------------------------------------
+
+export const annotateLogs = dual<
+  {
+    (key: string, value: unknown): <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>
+    (
+      values: Record<string, unknown>
+    ): <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>
+  },
+  {
+    <A, E, R>(self: Layer.Layer<A, E, R>, key: string, value: unknown): Layer.Layer<A, E, R>
+    <A, E, R>(self: Layer.Layer<A, E, R>, values: Record<string, unknown>): Layer.Layer<A, E, R>
+  }
+>(
+  (args) => isLayer(args[0]),
+  function<A, E, R>() {
+    const args = arguments
+    return fiberRefLocallyWith(
+      args[0] as Layer.Layer<A, E, R>,
+      core.currentLogAnnotations,
+      typeof args[1] === "string"
+        ? HashMap.set(args[1], args[2])
+        : (annotations) =>
+          Object.entries(args[1] as Record<string, unknown>).reduce(
+            (acc, [key, value]) => HashMap.set(acc, key, value),
+            annotations
+          )
+    )
+  }
+)
+
 // -----------------------------------------------------------------------------
 // tracing
 // -----------------------------------------------------------------------------
 
+export const annotateSpans = dual<
+  {
+    (key: string, value: unknown): <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>
+    (
+      values: Record<string, unknown>
+    ): <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>
+  },
+  {
+    <A, E, R>(self: Layer.Layer<A, E, R>, key: string, value: unknown): Layer.Layer<A, E, R>
+    <A, E, R>(self: Layer.Layer<A, E, R>, values: Record<string, unknown>): Layer.Layer<A, E, R>
+  }
+>(
+  (args) => isLayer(args[0]),
+  function<A, E, R>() {
+    const args = arguments
+    return fiberRefLocallyWith(
+      args[0] as Layer.Layer<A, E, R>,
+      core.currentTracerSpanAnnotations,
+      typeof args[1] === "string"
+        ? HashMap.set(args[1], args[2])
+        : (annotations) =>
+          Object.entries(args[1] as Record<string, unknown>).reduce(
+            (acc, [key, value]) => HashMap.set(acc, key, value),
+            annotations
+          )
+    )
+  }
+)
+
 /** @internal */
 export const withSpan: {
   (