effect 4.0.6 → 4.1.0

package/src/internal/schema/toRepresentation.ts

@@ -4,6 +4,7 @@ import * as SchemaAST from "../../SchemaAST.ts"
 import type * as SchemaRepresentation from "../../SchemaRepresentation.ts"
 import * as InternalRecord from "../record.ts"
 import * as InternalAnnotations from "./annotations.ts"
+import * as InternalContent from "./content.ts"
 
 const defaultReferencePolicy: SchemaRepresentation.ReferencePolicy = ({ identifier }) => identifier
 
@@ -15,9 +16,17 @@ interface ReferenceCandidate {
   readonly ast: SchemaAST.AST
   readonly identifier: string | undefined
   readonly fallback: string | undefined
+  readonly content: Content | undefined
   occurrences: number
-  isRecursive: boolean
-  reference: string | undefined
+  visiting?: boolean | undefined
+  isRecursive?: boolean | undefined
+  reference?: string | undefined
+  emitted?: boolean | undefined
+}
+
+interface Content {
+  readonly mediaType: string
+  readonly schema?: ReferenceCandidate | undefined
 }
 
 function annotationsField<A>(annotations: A | undefined): { readonly annotations: A } | undefined {
@@ -39,16 +48,14 @@ export function toRepresentations(
   options?: SchemaRepresentation.ToRepresentationOptions
 ): SchemaRepresentation.MultiDocument {
   const references: Record<string, SchemaRepresentation.Representation> = {}
-  const referenceOwners = new Map<string, ReferenceCandidate>()
-  const buildingReferences = new Set<string>()
-  const candidates = new Map<SchemaAST.AST, Map<string | undefined, ReferenceCandidate>>()
-  const visitingCandidates = new Set<ReferenceCandidate>()
+  const usedReferences = new Set<string>()
+  const candidates = new Map<SchemaAST.AST, Array<ReferenceCandidate>>()
 
   for (const ast of asts) visit(ast)
 
   const referencePolicy = options?.referencePolicy ?? defaultReferencePolicy
-  for (const candidatesByIdentifier of candidates.values()) {
-    for (const candidate of candidatesByIdentifier.values()) {
+  for (const variants of candidates.values()) {
+    for (const candidate of variants) {
       const requestedReference = referencePolicy({
         ast: candidate.ast,
         occurrences: candidate.occurrences,
@@ -59,25 +66,24 @@ export function toRepresentations(
             !requestedReference.endsWith("_")
           ? "_"
           : ""
-        candidate.reference = getReference(requestedReference, candidate, separator)
+        candidate.reference = getReference(requestedReference, separator)
       } else if (candidate.isRecursive) {
-        candidate.reference = getReference(`${candidate.ast._tag}_`, candidate, "")
+        candidate.reference = getReference(`${candidate.ast._tag}_`, "")
       }
     }
   }
 
-  const representations = Arr.map(asts, (ast) => recur(ast))
+  const representations = Arr.map(asts, recur)
 
   return { representations, references }
 
-  function getReference(prefix: string, owner: ReferenceCandidate, separator = "_"): string {
+  function getReference(prefix: string, separator: string): string {
     let candidate = prefix
     let suffix = 0
-    while (referenceOwners.has(candidate)) {
-      if (referenceOwners.get(candidate) === owner) return candidate
+    while (usedReferences.has(candidate)) {
       candidate = `${prefix}${separator}${++suffix}`
     }
-    referenceOwners.set(candidate, owner)
+    usedReferences.add(candidate)
     return candidate
   }
 
@@ -99,18 +105,27 @@ export function toRepresentations(
       : SchemaAST.annotate(ast, { identifier: reference })
   }
 
-  function makeReference(reference: string, ast: SchemaAST.AST): SchemaRepresentation.Reference {
-    if (!Object.hasOwn(references, reference) && !buildingReferences.has(reference)) {
-      buildingReferences.add(reference)
-      const representation = on(ast)
-      buildingReferences.delete(reference)
-      InternalRecord.assignProperty(references, reference, representation)
+  function getCandidate(
+    input: SchemaAST.AST,
+    encodingLength = input.encoding?.length ?? 0
+  ): ReferenceCandidate {
+    let ast = input
+    let content: Content | undefined
+    while (ast.encoding !== undefined && encodingLength > 0) {
+      const last = ast.encoding[encodingLength - 1]
+      // Only retain content when this operation produces the final string.
+      if (last.to.encoding === undefined && last.to._tag === "String") {
+        const metadata = InternalContent.getContent(last.transformation.encode)
+        if (metadata !== undefined) {
+          content = {
+            mediaType: metadata.mediaType,
+            schema: metadata.preserveSchema ? getCandidate(ast, encodingLength - 1) : undefined
+          }
+        }
+      }
+      ast = last.to
+      encodingLength = ast.encoding?.length ?? 0
     }
-    return { _tag: "Reference", $ref: reference }
-  }
-
-  function getCandidate(input: SchemaAST.AST): ReferenceCandidate {
-    const ast = SchemaAST.getLastEncoding(input)
     const owner = SchemaAST.getContextOwner(ast)
     let identifier = InternalAnnotations.resolveIdentifier(ast)
     const fallback = identifier === undefined
@@ -118,46 +133,48 @@ export function toRepresentations(
         InternalAnnotations.resolveIdentifierFallback(ast)
       : undefined
     if (fallback !== undefined) identifier = `${fallback}Encoded`
-    let candidatesByIdentifier = candidates.get(owner)
-    if (candidatesByIdentifier === undefined) {
-      candidatesByIdentifier = new Map()
-      candidates.set(owner, candidatesByIdentifier)
+    let variants = candidates.get(owner)
+    if (variants === undefined) {
+      variants = []
+      candidates.set(owner, variants)
     }
-    let candidate = candidatesByIdentifier.get(identifier)
+    let candidate = variants.find((candidate) =>
+      candidate.identifier === identifier &&
+      candidate.content?.mediaType === content?.mediaType &&
+      candidate.content?.schema === content?.schema
+    )
     if (candidate === undefined) {
       candidate = {
         ast: owner,
         identifier,
         fallback,
-        occurrences: 0,
-        isRecursive: false,
-        reference: undefined
+        content,
+        occurrences: 0
       }
-      candidatesByIdentifier.set(identifier, candidate)
+      variants.push(candidate)
     }
     return candidate
   }
 
-  function visit(input: SchemaAST.AST): void {
-    const candidate = getCandidate(input)
+  function visit(input: SchemaAST.AST): SchemaAST.AST {
+    visitCandidate(getCandidate(input))
+    return input
+  }
+
+  function visitCandidate(candidate: ReferenceCandidate): void {
     const ast = candidate.ast
     candidate.occurrences++
-    if (visitingCandidates.has(candidate)) {
+    if (candidate.visiting) {
       candidate.isRecursive = true
       return
     }
     if (candidate.occurrences > 1) return
-    visitingCandidates.add(candidate)
+    candidate.visiting = true
+    if (candidate.content?.schema !== undefined) visitCandidate(candidate.content.schema)
     visitChecks(ast.checks)
     switch (ast._tag) {
-      case "Declaration":
-      case "Arrays":
-      case "Objects":
-      case "Union":
-        ast.recur((child) => {
-          visit(child)
-          return child
-        })
+      default:
+        if ("recur" in ast) ast.recur(visit)
         break
       case "TemplateLiteral":
         ast.parts.forEach(visit)
@@ -166,7 +183,7 @@ export function toRepresentations(
         visit(ast.thunk())
         break
     }
-    visitingCandidates.delete(candidate)
+    candidate.visiting = false
   }
 
   function visitChecks(checks: SchemaAST.Checks | undefined): void {
@@ -177,74 +194,74 @@ export function toRepresentations(
   }
 
   function recur(input: SchemaAST.AST): SchemaRepresentation.Representation {
-    const candidate = getCandidate(input)
+    return recurCandidate(getCandidate(input))
+  }
+
+  function recurCandidate(candidate: ReferenceCandidate): SchemaRepresentation.Representation {
     const ast = candidate.ast
     const reference = candidate.reference
     if (reference !== undefined) {
-      const annotated = candidate.identifier === undefined ? ast : annotateReference(ast, candidate, reference)
-      return makeReference(reference, annotated)
+      if (!candidate.emitted) {
+        candidate.emitted = true
+        const annotated = candidate.identifier === undefined ? ast : annotateReference(ast, candidate, reference)
+        const representation = on(annotated, candidate.content)
+        InternalRecord.assignProperty(references, reference, representation)
+      }
+      return { _tag: "Reference", $ref: reference }
     }
-    return on(ast)
+    return on(ast, candidate.content)
   }
 
-  function on(ast: SchemaAST.AST): SchemaRepresentation.Representation {
-    const checks = fromChecks(ast.checks)
+  function on(ast: SchemaAST.AST, content: Content | undefined): SchemaRepresentation.Representation {
+    const common = {
+      checks: ast.checks?.map(fromCheck) ?? [],
+      ...(ast._tag === "Declaration" ? fromAnnotations(ast.annotations) : annotationsField(ast.annotations))
+    }
     switch (ast._tag) {
       case "Declaration":
         return {
-          _tag: "Declaration",
-          typeParameters: ast.typeParameters.map((ast) => recur(ast)),
-          checks,
-          ...fromDeclarationAnnotations(ast.annotations)
+          _tag: ast._tag,
+          typeParameters: ast.typeParameters.map(recur),
+          ...common
         }
-      case "Null":
-      case "Undefined":
-      case "Void":
-      case "Never":
-      case "Unknown":
-      case "Any":
-      case "String":
-      case "Boolean":
-      case "Number":
-      case "BigInt":
-      case "Symbol":
-      case "ObjectKeyword":
+      default:
         return {
           _tag: ast._tag,
-          checks,
-          ...annotationsField(ast.annotations)
+          ...(content === undefined ? undefined : {
+            content: {
+              mediaType: content.mediaType,
+              ...(content.schema === undefined ? undefined : { schema: recurCandidate(content.schema) })
+            }
+          }),
+          ...common
         }
       case "Literal":
         return {
-          _tag: "Literal",
+          _tag: ast._tag,
           literal: ast.literal,
-          checks,
-          ...annotationsField(ast.annotations)
+          ...common
         }
       case "UniqueSymbol":
         return {
-          _tag: "UniqueSymbol",
+          _tag: ast._tag,
           symbol: ast.symbol,
-          checks,
-          ...annotationsField(ast.annotations)
+          ...common
         }
       case "Enum":
         return {
-          _tag: "Enum",
+          _tag: ast._tag,
           enums: ast.enums,
-          checks,
-          ...annotationsField(ast.annotations)
+          ...common
         }
       case "TemplateLiteral":
         return {
-          _tag: "TemplateLiteral",
-          parts: ast.parts.map((ast) => recur(ast)),
-          checks,
-          ...annotationsField(ast.annotations)
+          _tag: ast._tag,
+          parts: ast.parts.map(recur),
+          ...common
         }
       case "Arrays":
         return {
-          _tag: "Arrays",
+          _tag: ast._tag,
           elements: ast.elements.map((element) => {
             const projected = SchemaAST.getLastEncoding(element)
             const annotations = projected.context?.annotations
@@ -254,13 +271,12 @@ export function toRepresentations(
               ...annotationsField(annotations)
             }
           }),
-          rest: ast.rest.map((ast) => recur(ast)),
-          checks,
-          ...annotationsField(ast.annotations)
+          rest: ast.rest.map(recur),
+          ...common
         }
       case "Objects":
         return {
-          _tag: "Objects",
+          _tag: ast._tag,
           propertySignatures: ast.propertySignatures.map((property) => {
             const projected = SchemaAST.getLastEncoding(property.type)
             const annotations = projected.context?.annotations
@@ -276,83 +292,49 @@ export function toRepresentations(
             parameter: recur(index.parameter),
             type: recur(index.type)
           })),
-          checks,
-          ...annotationsField(ast.annotations)
+          ...common
         }
       case "Union":
         return {
-          _tag: "Union",
-          types: ast.types.map((ast) => recur(ast)),
+          _tag: ast._tag,
+          types: ast.types.map(recur),
           ...(ast.options === undefined ? {} : { options: ast.options }),
-          checks,
-          ...annotationsField(ast.annotations)
+          ...common
         }
       case "Suspend":
         return {
-          _tag: "Suspend",
+          _tag: ast._tag,
+          ...common,
           checks: [],
-          thunk: recur(ast.thunk()),
-          ...annotationsField(ast.annotations)
+          thunk: recur(ast.thunk())
         }
     }
   }
 
-  function fromChecks(
-    checks: readonly [SchemaAST.Check<any>, ...Array<SchemaAST.Check<any>>] | undefined
-  ): Array<SchemaRepresentation.Check> {
-    return checks?.map(fromCheck) ?? []
-  }
-
   function fromCheck(
     check: SchemaAST.Check<any>
   ): SchemaRepresentation.Check {
-    switch (check._tag) {
-      case "Filter":
-        return {
-          _tag: "Filter",
-          aborted: check.aborted,
-          ...fromCheckAnnotations(check.annotations)
-        }
-      case "FilterGroup":
-        return {
-          _tag: "FilterGroup",
-          checks: Arr.map(check.checks, fromCheck),
-          ...fromCheckAnnotations(check.annotations)
-        }
-    }
-  }
-
-  function fromDeclarationAnnotations<
-    A extends Schema.Annotations.Annotations & {
-      readonly representation?: SchemaRepresentation.RepresentationAnnotation | undefined
-    }
-  >(annotations: A | undefined): {
-    readonly representation?: SchemaRepresentation.RepresentationAnnotation | undefined
-    readonly annotations?: Omit<A, "representation"> | undefined
-  } | undefined {
-    if (annotations === undefined) return undefined
-    const { representation, ...ordinary } = annotations
     return {
-      ...(representation === undefined ? undefined : { representation }),
-      ...(Object.keys(ordinary).length === 0 ? undefined : { annotations: ordinary })
+      ...(check._tag === "Filter"
+        ? { _tag: check._tag, aborted: check.aborted }
+        : { _tag: check._tag, checks: Arr.map(check.checks, fromCheck) }),
+      ...fromAnnotations(check.annotations, true)
     }
   }
 
-  function fromCheckAnnotations<
+  function fromAnnotations<
     A extends Schema.Annotations.Annotations & {
       readonly representation?: SchemaRepresentation.CheckRepresentationAnnotation<SchemaAST.AST> | undefined
     }
-  >(annotations: A | undefined): {
+  >(annotations: A | undefined, projectSchemas = false): {
     readonly representation?: CheckRepresentationAnnotation | undefined
     readonly annotations?: Omit<A, "representation"> | undefined
   } | undefined {
     if (annotations === undefined) return undefined
     const { representation, ...ordinary } = annotations
-    const projected = representation === undefined
-      ? undefined
-      : representation.schemas === undefined
-      ? representation as CheckRepresentationAnnotation
-      : { ...representation, schemas: representation.schemas.map((schema) => recur(SchemaAST.toType(schema))) }
+    const projected = projectSchemas && representation?.schemas !== undefined
+      ? { ...representation, schemas: representation.schemas.map((schema) => recur(SchemaAST.toType(schema))) }
+      : representation as CheckRepresentationAnnotation | undefined
     return {
       ...(projected === undefined ? undefined : { representation: projected }),
       ...(Object.keys(ordinary).length === 0 ? undefined : { annotations: ordinary })

package/src/internal/sql.ts

@@ -0,0 +1,14 @@
+import * as Context from "../Context.ts"
+
+/**
+ * The transaction service of the innermost transaction started with
+ * `SqlClient.makeWithTransaction`. `SqlResolver` reads it to find that
+ * transaction when the request's context has no `SqlClient` for it. Removing
+ * the service from a context also hides the transaction from this lookup.
+ *
+ * @internal
+ */
+export const CurrentTransactionService = Context.Reference<Context.Key<any, object> | undefined>(
+  "effect/sql/CurrentTransactionService",
+  { defaultValue: () => undefined }
+)

package/src/internal/trie.ts

@@ -21,6 +21,7 @@ type TraversalFilter<K, V> = (k: K, v: V) => boolean
 /** @internal */
 export interface TrieImpl<in out V> extends TR.Trie<V> {
   readonly _root: Node<V> | undefined
+  readonly _empty: Entry<V> | undefined
   readonly _count: number
 }
 
@@ -70,15 +71,17 @@ const TrieProto: TR.Trie<unknown> = {
   }
 }
 
-const makeImpl = <V>(root: Node<V> | undefined): TrieImpl<V> => {
+const makeImpl = <V>(root: Node<V> | undefined, emptyEntry: Entry<V> | undefined): TrieImpl<V> => {
   const trie = Object.create(TrieProto)
   trie._root = root
-  trie._count = root?.count ?? 0
+  trie._empty = emptyEntry
+  trie._count = (root?.count ?? 0) + (emptyEntry === undefined ? 0 : 1)
   return trie
 }
 
 class TrieIterator<in out V, out T> implements IterableIterator<T> {
   stack: Array<[Node<V>, string, boolean]> = []
+  emptyEntry: Entry<V> | undefined
   readonly f: TraversalMap<string, V, T>
   readonly filter: TraversalFilter<string, V>
 
@@ -89,6 +92,7 @@ class TrieIterator<in out V, out T> implements IterableIterator<T> {
   ) {
     this.f = f
     this.filter = filter
+    this.emptyEntry = trie._empty
     const root = trie._root !== undefined ? trie._root : undefined
     if (root !== undefined) {
       this.stack.push([root, "", false])
@@ -96,6 +100,13 @@ class TrieIterator<in out V, out T> implements IterableIterator<T> {
   }
 
   next(): IteratorResult<T> {
+    const emptyEntry = this.emptyEntry
+    if (emptyEntry !== undefined) {
+      this.emptyEntry = undefined
+      if (this.filter("", emptyEntry.value)) {
+        return { done: false, value: this.f("", emptyEntry.value) }
+      }
+    }
     while (this.stack.length > 0) {
       const [node, keyString, isAdded] = this.stack.pop()!
 
@@ -140,7 +151,7 @@ export const isTrie: {
 } = (u: unknown): u is TR.Trie<unknown> => hasProperty(u, TrieTypeId)
 
 /** @internal */
-export const empty = <V = never>(): TR.Trie<V> => makeImpl<V>(undefined)
+export const empty = <V = never>(): TR.Trie<V> => makeImpl<V>(undefined, undefined)
 
 /** @internal */
 export const fromIterable = <V>(entries: Iterable<readonly [string, V]>) => {
@@ -163,7 +174,7 @@ export const insert = dual<
   <V>(key: string, value: V) => (self: TR.Trie<V>) => TR.Trie<V>,
   <V>(self: TR.Trie<V>, key: string, value: V) => TR.Trie<V>
 >(3, <V>(self: TR.Trie<V>, key: string, value: V) => {
-  if (key.length === 0) return self
+  if (key.length === 0) return makeImpl((self as TrieImpl<V>)._root, { value })
 
   // -1:left | 0:mid | 1:right
   const dStack: Array<Ordering.Ordering> = []
@@ -255,11 +266,11 @@ export const insert = dual<
   }
 
   nStack[0].count = count
-  return makeImpl(nStack[0])
+  return makeImpl(nStack[0], (self as TrieImpl<V>)._empty)
 })
 
 /** @internal */
-export const size = <V>(self: TR.Trie<V>): number => (self as TrieImpl<V>)._root?.count ?? 0
+export const size = <V>(self: TR.Trie<V>): number => (self as TrieImpl<V>)._count
 
 /** @internal */
 export const isEmpty = <V>(self: TR.Trie<V>): boolean => size(self) === 0
@@ -394,8 +405,12 @@ export const get = dual<
 >(
   2,
   <V>(self: TR.Trie<V>, key: string) => {
+    if (key.length === 0) {
+      const emptyEntry = (self as TrieImpl<V>)._empty
+      return emptyEntry === undefined ? Option.none() : Option.some(emptyEntry.value)
+    }
     let n: Node<V> | undefined = (self as TrieImpl<V>)._root
-    if (n === undefined || key.length === 0) return Option.none()
+    if (n === undefined) return Option.none()
     let cIndex = 0
     while (cIndex < key.length) {
       const c = key[cIndex]
@@ -453,8 +468,11 @@ export const remove = dual<
 >(
   2,
   <V>(self: TR.Trie<V>, key: string) => {
+    if (key.length === 0) {
+      return (self as TrieImpl<V>)._empty === undefined ? self : makeImpl((self as TrieImpl<V>)._root, undefined)
+    }
     let n: Node<V> | undefined = (self as TrieImpl<V>)._root
-    if (n === undefined || key.length === 0) return self
+    if (n === undefined) return self
 
     const count = n.count - 1
     // -1:left | 0:mid | 1:right
@@ -554,7 +572,7 @@ export const remove = dual<
     }
 
     nStack[0].count = count
-    return makeImpl(nStack[0])
+    return makeImpl(nStack[0], (self as TrieImpl<V>)._empty)
   }
 )
 
@@ -589,8 +607,12 @@ export const modify = dual<
 >(
   3,
   <V>(self: TR.Trie<V>, key: string, f: (v: V) => V): TR.Trie<V> => {
+    if (key.length === 0) {
+      const emptyEntry = (self as TrieImpl<V>)._empty
+      return emptyEntry === undefined ? self : makeImpl((self as TrieImpl<V>)._root, { value: f(emptyEntry.value) })
+    }
     let n: Node<V> | undefined = (self as TrieImpl<V>)._root
-    if (n === undefined || key.length === 0) return self
+    if (n === undefined) return self
 
     // -1:left | 0:mid | 1:right
     const dStack: Array<Ordering.Ordering> = []
@@ -689,7 +711,7 @@ export const modify = dual<
       }
     }
 
-    return makeImpl(nStack[0])
+    return makeImpl(nStack[0], (self as TrieImpl<V>)._empty)
   }
 )
 
@@ -700,9 +722,12 @@ export const longestPrefixOf = dual<
 >(
   2,
   <V>(self: TR.Trie<V>, key: string): Option.Option<[string, V]> => {
+    const emptyEntry = (self as TrieImpl<V>)._empty
+    let longestPrefixNode: Option.Option<[string, V]> = emptyEntry === undefined
+      ? Option.none()
+      : Option.some(["", emptyEntry.value])
     let n: Node<V> | undefined = (self as TrieImpl<V>)._root
-    if (n === undefined || key.length === 0) return Option.none()
-    let longestPrefixNode: Option.Option<[string, V]> = Option.none()
+    if (n === undefined || key.length === 0) return longestPrefixNode
     let cIndex = 0
     while (cIndex < key.length) {
       const c = key[cIndex]
@@ -735,10 +760,14 @@ export const longestPrefixOf = dual<
   }
 )
 
+interface Entry<V> {
+  readonly value: V
+}
+
 interface Node<V> {
   key: string
   count: number
-  value?: { readonly value: V } | undefined
+  value?: Entry<V> | undefined
   left?: Node<V> | undefined
   mid?: Node<V> | undefined
   right?: Node<V> | undefined

package/src/internal/ulid.ts

@@ -28,3 +28,47 @@ export const ulidString = (timestampMillis: number, bytes: Uint8Array): string =
 
   return out
 }
+
+/**
+ * Makes a ULID generator in the ULID spec's monotonic mode: within a
+ * millisecond, or when the clock moves back, the 80-bit random part of the last
+ * ULID is incremented. The ordering ends at the maximum timestamp, 2^48 − 1 ms,
+ * which overflow cannot advance. `randomBytes` is only called for fresh
+ * randomness.
+ *
+ * @internal
+ */
+export const makeMonotonic = () => {
+  let lastTimestamp = -1
+  const random = new Uint8Array(10)
+  return (timestampMillis: number, randomBytes: () => Uint8Array): string => {
+    const timestamp = timestampMillis >= 0 ? Math.min(Math.trunc(timestampMillis), maxTimestamp) : 0
+    if (timestamp > lastTimestamp) {
+      lastTimestamp = timestamp
+      random.set(randomBytes())
+    } else if (!increment(random)) {
+      lastTimestamp = Math.min(lastTimestamp + 1, maxTimestamp)
+      random.set(randomBytes())
+    }
+    return ulidString(lastTimestamp, random)
+  }
+}
+
+// Returns false when the bytes overflow, leaving them all zero.
+const increment = (bytes: Uint8Array): boolean => {
+  for (let i = bytes.length - 1; i >= 0; i--) {
+    if (bytes[i] !== 0xff) {
+      bytes[i]++
+      return true
+    }
+    bytes[i] = 0
+  }
+  return false
+}
+
+/**
+ * The ULID ordering state shared by every `Date.now()` caller in the realm.
+ *
+ * @internal
+ */
+export const monotonic = makeMonotonic()