effect 3.9.2 → 3.10.0

package/src/internal/logger.ts

@@ -341,7 +341,7 @@ export const structuredMessage = (u: unknown): unknown => {
       return String(u)
     }
     default: {
-      return u
+      return Inspectable.toJSON(u)
     }
   }
 }
@@ -488,13 +488,13 @@ const prettyLoggerTty = (options: {
 
       if (messageIndex < message.length) {
         for (; messageIndex < message.length; messageIndex++) {
-          log(message[messageIndex])
+          log(Inspectable.redact(message[messageIndex]))
         }
       }
 
       if (HashMap.size(annotations) > 0) {
         for (const [key, value] of annotations) {
-          log(color(`${key}:`, colors.bold, colors.white), value)
+          log(color(`${key}:`, colors.bold, colors.white), Inspectable.redact(value))
         }
       }
 
@@ -553,16 +553,17 @@ const prettyLoggerBrowser = (options: {
 
       if (messageIndex < message.length) {
         for (; messageIndex < message.length; messageIndex++) {
-          console.log(message[messageIndex])
+          console.log(Inspectable.redact(message[messageIndex]))
         }
       }
 
       if (HashMap.size(annotations) > 0) {
         for (const [key, value] of annotations) {
+          const redacted = Inspectable.redact(value)
           if (options.colors) {
-            console.log(`%c${key}:`, "color:gray", value)
+            console.log(`%c${key}:`, "color:gray", redacted)
           } else {
-            console.log(`${key}:`, value)
+            console.log(`${key}:`, redacted)
           }
         }
       }

package/src/internal/redacted.ts

@@ -1,3 +1,4 @@
+import { NodeInspectSymbol } from "effect/Inspectable"
 import * as Equal from "../Equal.js"
 import { pipe } from "../Function.js"
 import { globalValue } from "../GlobalValue.js"
@@ -34,6 +35,9 @@ export const proto = {
   toJSON() {
     return "<redacted>"
   },
+  [NodeInspectSymbol]() {
+    return "<redacted>"
+  },
   [Hash.symbol]<T>(this: Redacted.Redacted<T>): number {
     return pipe(
       Hash.hash(RedactedSymbolKey),

package/src/internal/schema/errors.ts

@@ -0,0 +1,189 @@
+import * as array_ from "effect/Array"
+import type * as AST from "../../SchemaAST.js"
+import * as util_ from "./util.js"
+
+const getErrorMessage = (
+  reason: string,
+  details?: string,
+  path?: ReadonlyArray<PropertyKey>,
+  ast?: AST.AST
+): string => {
+  let out = reason
+
+  if (path && array_.isNonEmptyReadonlyArray(path)) {
+    out += `\nat path: ${util_.formatPath(path)}`
+  }
+
+  if (details !== undefined) {
+    out += `\ndetails: ${details}`
+  }
+
+  if (ast) {
+    out += `\nschema (${ast._tag}): ${ast}`
+  }
+
+  return out
+}
+
+// ---------------------------------------------
+// generic
+// ---------------------------------------------
+
+/** @internal */
+export const getInvalidArgumentErrorMessage = (details: string) => getErrorMessage("Invalid Argument", details)
+
+const getUnsupportedSchemaErrorMessage = (details?: string, path?: ReadonlyArray<PropertyKey>, ast?: AST.AST): string =>
+  getErrorMessage("Unsupported schema", details, path, ast)
+
+const getMissingAnnotationErrorMessage = (details?: string, path?: ReadonlyArray<PropertyKey>, ast?: AST.AST): string =>
+  getErrorMessage("Missing annotation", details, path, ast)
+
+// ---------------------------------------------
+// Arbitrary
+// ---------------------------------------------
+
+/** @internal */
+export const getArbitraryUnsupportedErrorMessage = (path: ReadonlyArray<PropertyKey>, ast: AST.AST) =>
+  getUnsupportedSchemaErrorMessage("Cannot build an Arbitrary for this schema", path, ast)
+
+/** @internal */
+export const getArbitraryMissingAnnotationErrorMessage = (
+  path: ReadonlyArray<PropertyKey>,
+  ast: AST.AST
+) =>
+  getMissingAnnotationErrorMessage(
+    `Generating an Arbitrary for this schema requires an "arbitrary" annotation`,
+    path,
+    ast
+  )
+
+/** @internal */
+export const getArbitraryEmptyEnumErrorMessage = (path: ReadonlyArray<PropertyKey>) =>
+  getErrorMessage("Empty Enums schema", "Generating an Arbitrary for this schema requires at least one enum", path)
+
+// ---------------------------------------------
+// Equivalence
+// ---------------------------------------------
+
+/** @internal */
+export const getEquivalenceUnsupportedErrorMessage = (ast: AST.AST, path: ReadonlyArray<PropertyKey>) =>
+  getUnsupportedSchemaErrorMessage("Cannot build an Equivalence", path, ast)
+
+// ---------------------------------------------
+// JSON Schema
+// ---------------------------------------------
+
+/** @internal */
+export const getJSONSchemaMissingAnnotationErrorMessage = (
+  path: ReadonlyArray<PropertyKey>,
+  ast: AST.AST
+) =>
+  getMissingAnnotationErrorMessage(
+    `Generating a JSON Schema for this schema requires a "jsonSchema" annotation`,
+    path,
+    ast
+  )
+
+/** @internal */
+export const getJSONSchemaMissingIdentifierAnnotationErrorMessage = (
+  path: ReadonlyArray<PropertyKey>,
+  ast: AST.AST
+) =>
+  getMissingAnnotationErrorMessage(
+    `Generating a JSON Schema for this schema requires an "identifier" annotation`,
+    path,
+    ast
+  )
+
+/** @internal */
+export const getJSONSchemaUnsupportedParameterErrorMessage = (
+  path: ReadonlyArray<PropertyKey>,
+  parameter: AST.AST
+): string => getErrorMessage("Unsupported index signature parameter", undefined, path, parameter)
+
+/** @internal */
+export const getJSONSchemaUnsupportedPostRestElementsErrorMessage = (path: ReadonlyArray<PropertyKey>): string =>
+  getErrorMessage(
+    "Generating a JSON Schema for post-rest elements is not currently supported. You're welcome to contribute by submitting a Pull Request",
+    undefined,
+    path
+  )
+
+/** @internal */
+export const getJSONSchemaUnsupportedKeyErrorMessage = (key: PropertyKey, path: ReadonlyArray<PropertyKey>): string =>
+  getErrorMessage("Unsupported key", `Cannot encode ${util_.formatPropertyKey(key)} key to JSON Schema`, path)
+
+// ---------------------------------------------
+// Pretty
+// ---------------------------------------------
+
+/** @internal */
+export const getPrettyMissingAnnotationErrorMessage = (
+  path: ReadonlyArray<PropertyKey>,
+  ast: AST.AST
+) => getMissingAnnotationErrorMessage(`Generating a Pretty for this schema requires a "pretty" annotation`, path, ast)
+
+/** @internal */
+export const getPrettyNeverErrorMessage = "Cannot pretty print a `never` value"
+
+/** @internal */
+export const getPrettyNoMatchingSchemaErrorMessage = (
+  actual: unknown,
+  path: ReadonlyArray<PropertyKey>,
+  ast: AST.AST
+) => getErrorMessage("Unexpected Error", `Cannot find a matching schema for ${util_.formatUnknown(actual)}`, path, ast)
+
+// ---------------------------------------------
+// Schema
+// ---------------------------------------------
+
+/** @internal */
+export const getSchemaExtendErrorMessage = (x: AST.AST, y: AST.AST, path: ReadonlyArray<PropertyKey>) =>
+  getErrorMessage("Unsupported schema or overlapping types", `cannot extend ${x} with ${y}`, path)
+
+/** @internal */
+export const getSchemaUnsupportedLiteralSpanErrorMessage = (ast: AST.AST) =>
+  getErrorMessage("Unsupported template literal span", undefined, undefined, ast)
+
+// ---------------------------------------------
+// AST
+// ---------------------------------------------
+
+/** @internal */
+export const getASTUnsupportedSchema = (ast: AST.AST) => getUnsupportedSchemaErrorMessage(undefined, undefined, ast)
+
+/** @internal */
+export const getASTUnsupportedKeySchema = (ast: AST.AST) =>
+  getErrorMessage("Unsupported key schema", undefined, undefined, ast)
+
+/** @internal */
+export const getASTUnsupportedLiteral = (literal: AST.LiteralValue) =>
+  getErrorMessage("Unsupported literal", `literal value: ${util_.formatUnknown(literal)}`)
+
+/** @internal */
+export const getASTDuplicateIndexSignatureErrorMessage = (type: "string" | "symbol"): string =>
+  getErrorMessage("Duplicate index signature", `${type} index signature`)
+
+/** @internal */
+export const getASTIndexSignatureParameterErrorMessage = getErrorMessage(
+  "Unsupported index signature parameter",
+  "An index signature parameter type must be `string`, `symbol`, a template literal type or a refinement of the previous types"
+)
+
+/** @internal */
+export const getASTRequiredElementFollowinAnOptionalElementErrorMessage = getErrorMessage(
+  "Invalid element",
+  "A required element cannot follow an optional element. ts(1257)"
+)
+
+/** @internal */
+export const getASTDuplicatePropertySignatureTransformationErrorMessage = (key: PropertyKey): string =>
+  getErrorMessage("Duplicate property signature transformation", `Duplicate key ${util_.formatUnknown(key)}`)
+
+/** @internal */
+export const getASTUnsupportedRenameSchema = (ast: AST.AST): string =>
+  getUnsupportedSchemaErrorMessage(undefined, undefined, ast)
+
+/** @internal */
+export const getASTDuplicatePropertySignatureErrorMessage = (key: PropertyKey): string =>
+  getErrorMessage("Duplicate property signature", `Duplicate key ${util_.formatUnknown(key)}`)

package/src/internal/schema/filters.ts

@@ -0,0 +1,86 @@
+import type * as Schema from "../../Schema.js"
+
+/** @internal */
+export const GreaterThanSchemaId: Schema.GreaterThanSchemaId = Symbol.for(
+  "effect/schema/GreaterThan"
+) as Schema.GreaterThanSchemaId
+
+/** @internal */
+export const GreaterThanOrEqualToSchemaId: Schema.GreaterThanOrEqualToSchemaId = Symbol.for(
+  "effect/schema/GreaterThanOrEqualTo"
+) as Schema.GreaterThanOrEqualToSchemaId
+
+/** @internal */
+export const LessThanSchemaId: Schema.LessThanSchemaId = Symbol.for(
+  "effect/schema/LessThan"
+) as Schema.LessThanSchemaId
+
+/** @internal */
+export const LessThanOrEqualToSchemaId: Schema.LessThanOrEqualToSchemaId = Symbol.for(
+  "effect/schema/LessThanOrEqualTo"
+) as Schema.LessThanOrEqualToSchemaId
+
+/** @internal */
+export const IntSchemaId: Schema.IntSchemaId = Symbol.for(
+  "effect/schema/Int"
+) as Schema.IntSchemaId
+
+/** @internal */
+export const BetweenSchemaId: Schema.BetweenSchemaId = Symbol.for(
+  "effect/schema/Between"
+) as Schema.BetweenSchemaId
+
+/** @internal */
+export const GreaterThanBigintSchemaId: Schema.GreaterThanBigIntSchemaId = Symbol.for(
+  "effect/schema/GreaterThanBigint"
+) as Schema.GreaterThanBigIntSchemaId
+
+/** @internal */
+export const GreaterThanOrEqualToBigIntSchemaId: Schema.GreaterThanOrEqualToBigIntSchemaId = Symbol.for(
+  "effect/schema/GreaterThanOrEqualToBigint"
+) as Schema.GreaterThanOrEqualToBigIntSchemaId
+
+/** @internal */
+export const LessThanBigIntSchemaId: Schema.LessThanBigIntSchemaId = Symbol.for(
+  "effect/schema/LessThanBigint"
+) as Schema.LessThanBigIntSchemaId
+
+/** @internal */
+export const LessThanOrEqualToBigIntSchemaId: Schema.LessThanOrEqualToBigIntSchemaId = Symbol.for(
+  "effect/schema/LessThanOrEqualToBigint"
+) as Schema.LessThanOrEqualToBigIntSchemaId
+
+/** @internal */
+export const BetweenBigintSchemaId: Schema.BetweenBigIntSchemaId = Symbol.for(
+  "effect/schema/BetweenBigint"
+) as Schema.BetweenBigIntSchemaId
+
+/** @internal */
+export const MinLengthSchemaId: Schema.MinLengthSchemaId = Symbol.for(
+  "effect/schema/MinLength"
+) as Schema.MinLengthSchemaId
+
+/** @internal */
+export const MaxLengthSchemaId: Schema.MaxLengthSchemaId = Symbol.for(
+  "effect/schema/MaxLength"
+) as Schema.MaxLengthSchemaId
+
+/** @internal */
+export const LengthSchemaId: Schema.LengthSchemaId = Symbol.for(
+  "effect/schema/Length"
+) as Schema.LengthSchemaId
+
+/** @internal */
+export const MinItemsSchemaId: Schema.MinItemsSchemaId = Symbol.for(
+  "effect/schema/MinItems"
+) as Schema.MinItemsSchemaId
+
+/** @internal */
+export const MaxItemsSchemaId: Schema.MaxItemsSchemaId = Symbol.for(
+  "effect/schema/MaxItems"
+) as Schema.MaxItemsSchemaId
+
+/** @internal */
+export const ItemsCountSchemaId: Schema.ItemsCountSchemaId = Symbol.for(
+  "effect/schema/ItemsCount"
+) as Schema.ItemsCountSchemaId

package/src/internal/schema/util.ts

@@ -0,0 +1,113 @@
+import * as array_ from "effect/Array"
+import * as Predicate from "effect/Predicate"
+import type * as ParseResult from "../../ParseResult.js"
+import type * as AST from "../../SchemaAST.js"
+
+/** @internal */
+export const getKeysForIndexSignature = (
+  input: { readonly [x: PropertyKey]: unknown },
+  parameter: AST.Parameter
+): ReadonlyArray<string> | ReadonlyArray<symbol> => {
+  switch (parameter._tag) {
+    case "StringKeyword":
+    case "TemplateLiteral":
+      return Object.keys(input)
+    case "SymbolKeyword":
+      return Object.getOwnPropertySymbols(input)
+    case "Refinement":
+      return getKeysForIndexSignature(input, parameter.from)
+  }
+}
+
+/**
+ * JavaScript does not store the insertion order of properties in a way that
+ * combines both string and symbol keys. The internal order groups string keys
+ * and symbol keys separately. Hence concatenating the keys is fine.
+ *
+ * @internal
+ */
+export const ownKeys = (o: object): Array<PropertyKey> =>
+  (Object.keys(o) as Array<PropertyKey>).concat(Object.getOwnPropertySymbols(o))
+
+/** @internal */
+export const memoizeThunk = <A>(f: () => A): () => A => {
+  let done = false
+  let a: A
+  return () => {
+    if (done) {
+      return a
+    }
+    a = f()
+    done = true
+    return a
+  }
+}
+
+/** @internal */
+export const formatDate = (date: Date): string => {
+  try {
+    return date.toISOString()
+  } catch (e) {
+    return String(date)
+  }
+}
+
+/** @internal */
+export const formatUnknown = (u: unknown): string => {
+  if (Predicate.isString(u)) {
+    return JSON.stringify(u)
+  } else if (
+    Predicate.isNumber(u)
+    || u == null
+    || Predicate.isBoolean(u)
+    || Predicate.isSymbol(u)
+  ) {
+    return String(u)
+  } else if (Predicate.isDate(u)) {
+    return formatDate(u)
+  } else if (Predicate.isBigInt(u)) {
+    return String(u) + "n"
+  } else if (
+    !array_.isArray(u)
+    && Predicate.hasProperty(u, "toString")
+    && Predicate.isFunction(u["toString"])
+    && u["toString"] !== Object.prototype.toString
+  ) {
+    return u["toString"]()
+  }
+  try {
+    JSON.stringify(u)
+    if (array_.isArray(u)) {
+      return `[${u.map(formatUnknown).join(",")}]`
+    } else {
+      return `{${
+        ownKeys(u).map((k) =>
+          `${Predicate.isString(k) ? JSON.stringify(k) : String(k)}:${formatUnknown((u as any)[k])}`
+        ).join(",")
+      }}`
+    }
+  } catch (e) {
+    return String(u)
+  }
+}
+
+/** @internal */
+export const formatPropertyKey = (name: PropertyKey): string =>
+  typeof name === "string" ? JSON.stringify(name) : String(name)
+
+/** @internal */
+export type SingleOrArray<A> = A | ReadonlyArray<A>
+
+/** @internal */
+export const isNonEmpty = <A>(x: ParseResult.SingleOrNonEmpty<A>): x is array_.NonEmptyReadonlyArray<A> =>
+  Array.isArray(x)
+
+/** @internal */
+export const isSingle = <A>(x: A | ReadonlyArray<A>): x is A => !Array.isArray(x)
+
+/** @internal */
+export const formatPathKey = (key: PropertyKey): string => `[${formatPropertyKey(key)}]`
+
+/** @internal */
+export const formatPath = (path: ParseResult.Path): string =>
+  isNonEmpty(path) ? path.map(formatPathKey).join("") : formatPathKey(path)

package/src/internal/stm/core.ts

@@ -15,11 +15,10 @@ import { pipeArguments } from "../../Pipeable.js"
 import { hasProperty } from "../../Predicate.js"
 import type * as Scheduler from "../../Scheduler.js"
 import type * as STM from "../../STM.js"
-import { StreamTypeId } from "../../Stream.js"
 import { YieldWrap } from "../../Utils.js"
 import { ChannelTypeId } from "../core-stream.js"
 import { withFiberRuntime } from "../core.js"
-import { effectVariance } from "../effectable.js"
+import { effectVariance, StreamTypeId } from "../effectable.js"
 import { OP_COMMIT } from "../opCodes/effect.js"
 import { SingleShotGen } from "../singleShotGen.js"
 import { SinkTypeId } from "../sink.js"

package/src/internal/stm/tPubSub.ts

@@ -201,6 +201,7 @@ class TPubSubSubscriptionImpl<in out A> implements TQueue.TDequeue<A> {
   capacity(): number {
     return this.requestedCapacity
   }
+
   size: STM.STM<number> = core.withSTMRuntime((runtime) => {
     let currentSubscriberHead = tRef.unsafeGet(this.subscriberHead, runtime.journal)
     if (currentSubscriberHead === undefined) {

package/src/internal/stm/tQueue.ts

@@ -3,7 +3,7 @@ import * as Chunk from "../../Chunk.js"
 import { dual, pipe } from "../../Function.js"
 import * as Option from "../../Option.js"
 import { hasProperty, type Predicate } from "../../Predicate.js"
-import * as STM from "../../STM.js"
+import type * as STM from "../../STM.js"
 import type * as TQueue from "../../TQueue.js"
 import type * as TRef from "../../TRef.js"
 import * as core from "./core.js"
@@ -99,7 +99,7 @@ class TQueueImpl<in out A> implements TQueue.TQueue<A> {
   size: STM.STM<number> = core.withSTMRuntime((runtime) => {
     const queue = tRef.unsafeGet(this.ref, runtime.journal)
     if (queue === undefined) {
-      return STM.interruptAs(runtime.fiberId)
+      return core.interruptAs(runtime.fiberId)
     }
     return core.succeed(queue.length)
   })

package/src/internal/stm/tRef.ts

@@ -1,5 +1,7 @@
 import { dual } from "../../Function.js"
 import * as Option from "../../Option.js"
+import type { Pipeable } from "../../Pipeable.js"
+import { pipeArguments } from "../../Pipeable.js"
 import type * as STM from "../../STM.js"
 import type * as TRef from "../../TRef.js"
 import * as core from "./core.js"
@@ -16,13 +18,13 @@ export const TRefTypeId: TRef.TRefTypeId = Symbol.for(
   TRefSymbolKey
 ) as TRef.TRefTypeId
 
-const tRefVariance = {
+export const tRefVariance = {
   /* c8 ignore next */
   _A: (_: any) => _
 }
 
 /** @internal */
-export class TRefImpl<in out A> implements TRef.TRef<A> {
+export class TRefImpl<in out A> implements TRef.TRef<A>, Pipeable {
   readonly [TRefTypeId] = tRefVariance
   /** @internal */
   todos: Map<TxnId.TxnId, Journal.Todo>
@@ -40,6 +42,9 @@ export class TRefImpl<in out A> implements TRef.TRef<A> {
       return retValue
     })
   }
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
 }
 
 /** @internal */