effect 4.0.6 → 4.0.7

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/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = "4.0.6"
+export const version = "4.0.7"