@effect/platform 0.68.6 → 0.69.1

package/src/OpenApi.ts

@@ -1,14 +1,15 @@
 /**
  * @since 1.0.0
  */
-import * as AST from "@effect/schema/AST"
-import * as Schema from "@effect/schema/Schema"
 import * as Context from "effect/Context"
-import { dual } from "effect/Function"
+import * as HashSet from "effect/HashSet"
 import * as Option from "effect/Option"
 import type { ReadonlyRecord } from "effect/Record"
+import * as Schema from "effect/Schema"
+import * as AST from "effect/SchemaAST"
 import type { DeepMutable, Mutable } from "effect/Types"
 import * as HttpApi from "./HttpApi.js"
+import * as HttpApiMiddleware from "./HttpApiMiddleware.js"
 import * as HttpApiSchema from "./HttpApiSchema.js"
 import type { HttpApiSecurity } from "./HttpApiSecurity.js"
 import * as HttpMethod from "./HttpMethod.js"
@@ -48,16 +49,24 @@ export class License extends Context.Tag("@effect/platform/OpenApi/License")<Lic
  * @since 1.0.0
  * @category annotations
  */
-export class Security extends Context.Tag("@effect/platform/OpenApi/Security")<Security, HttpApiSecurity>() {}
+export class ExternalDocs
+  extends Context.Tag("@effect/platform/OpenApi/ExternalDocs")<ExternalDocs, OpenAPISpecExternalDocs>()
+{}
 
 /**
  * @since 1.0.0
  * @category annotations
  */
-export class ExternalDocs
-  extends Context.Tag("@effect/platform/OpenApi/ExternalDocs")<ExternalDocs, OpenAPISpecExternalDocs>()
+export class Servers
+  extends Context.Tag("@effect/platform/OpenApi/Servers")<ExternalDocs, ReadonlyArray<OpenAPISpecServer>>()
 {}
 
+/**
+ * @since 1.0.0
+ * @category annotations
+ */
+export class Override extends Context.Tag("@effect/platform/OpenApi/Override")<Override, Record<string, unknown>>() {}
+
 /**
  * @since 1.0.0
  * @category annotations
@@ -68,8 +77,9 @@ export const annotations = (annotations: {
   readonly description?: string | undefined
   readonly version?: string | undefined
   readonly license?: OpenAPISpecLicense | undefined
-  readonly security?: HttpApiSecurity | undefined
   readonly externalDocs?: OpenAPISpecExternalDocs | undefined
+  readonly servers?: ReadonlyArray<OpenAPISpecServer> | undefined
+  readonly override?: Record<string, unknown> | undefined
 }): Context.Context<never> => {
   let context = Context.empty()
   if (annotations.identifier !== undefined) {
@@ -87,12 +97,15 @@ export const annotations = (annotations: {
   if (annotations.license !== undefined) {
     context = Context.add(context, License, annotations.license)
   }
-  if (annotations.security !== undefined) {
-    context = Context.add(context, Security, annotations.security)
-  }
   if (annotations.externalDocs !== undefined) {
     context = Context.add(context, ExternalDocs, annotations.externalDocs)
   }
+  if (annotations.servers !== undefined) {
+    context = Context.add(context, Servers, annotations.servers)
+  }
+  if (annotations.override !== undefined) {
+    context = Context.add(context, Override, annotations.override)
+  }
   return context
 }
 
@@ -104,67 +117,13 @@ export interface Annotatable {
   readonly annotations: Context.Context<never>
 }
 
-/**
- * @since 1.0.0
- * @category annotations
- */
-export const annotate: {
-  /**
-   * @since 1.0.0
-   * @category annotations
-   */
-  (
-    annotations: {
-      readonly identifier?: string | undefined
-      readonly title?: string | undefined
-      readonly description?: string | undefined
-      readonly version?: string | undefined
-      readonly license?: OpenAPISpecLicense | undefined
-      readonly security?: HttpApiSecurity | undefined
-      readonly externalDocs?: OpenAPISpecExternalDocs | undefined
-    }
-  ): <A extends Annotatable>(self: A) => A
-  /**
-   * @since 1.0.0
-   * @category annotations
-   */
-  <A extends Annotatable>(
-    self: A,
-    annotations: {
-      readonly identifier?: string | undefined
-      readonly title?: string | undefined
-      readonly description?: string | undefined
-      readonly version?: string | undefined
-      readonly license?: OpenAPISpecLicense | undefined
-      readonly security?: HttpApiSecurity | undefined
-      readonly externalDocs?: OpenAPISpecExternalDocs | undefined
-    }
-  ): A
-} = dual(2, <A extends Annotatable>(self: A, annotations_: {
-  readonly identifier?: string | undefined
-  readonly title?: string | undefined
-  readonly description?: string | undefined
-  readonly version?: string | undefined
-  readonly license?: OpenAPISpecLicense | undefined
-  readonly security?: HttpApiSecurity | undefined
-  readonly externalDocs?: OpenAPISpecExternalDocs | undefined
-}): A => {
-  const base = typeof self === "function" ? function() {} : self
-  Object.setPrototypeOf(base, Object.getPrototypeOf(self))
-  const context = Context.merge(
-    self.annotations,
-    annotations(annotations_)
-  )
-  return Object.assign(base, self, {
-    annotations: context
-  })
-})
-
 /**
  * @category constructors
  * @since 1.0.0
  */
-export const fromApi = <A extends HttpApi.HttpApi.Any>(api: A): OpenAPISpec => {
+export const fromApi = <A extends HttpApi.HttpApi.Any>(self: A): OpenAPISpec => {
+  const api = self as unknown as HttpApi.HttpApi.AnyWithProps
+  const jsonSchemaDefs: Record<string, JsonSchema.JsonSchema> = {}
   const spec: DeepMutable<OpenAPISpec> = {
     openapi: "3.0.3",
     info: {
@@ -174,22 +133,28 @@ export const fromApi = <A extends HttpApi.HttpApi.Any>(api: A): OpenAPISpec => {
     paths: {},
     tags: [],
     components: {
-      schemas: {},
+      schemas: jsonSchemaDefs,
       securitySchemes: {}
     },
     security: []
   }
-  const securityMap = new Map<HttpApiSecurity, string>()
-  let securityCount = 0
-  function registerSecurity(security: HttpApiSecurity): string {
-    if (securityMap.has(security)) {
-      return securityMap.get(security)!
+  function makeJsonSchemaOrRef(schema: Schema.Schema.All): JsonSchema.JsonSchema {
+    return JsonSchema.makeWithDefs(schema as any, {
+      defs: jsonSchemaDefs,
+      defsPath: "#/components/schemas/"
+    })
+  }
+  function registerSecurity(
+    tag: HttpApiMiddleware.TagClassSecurityAny,
+    name: string,
+    security: HttpApiSecurity
+  ): string {
+    const id = `${tag.key}/${name}`
+    if (spec.components!.securitySchemes![id]) {
+      return id
     }
-    const count = securityCount++
-    const id = `${security._tag}${count === 0 ? "" : count}`
     const scheme = makeSecurityScheme(security)
     spec.components!.securitySchemes![id] = scheme
-    securityMap.set(security, id)
     return id
   }
   Option.map(Context.getOption(api.annotations, Description), (description) => {
@@ -198,10 +163,22 @@ export const fromApi = <A extends HttpApi.HttpApi.Any>(api: A): OpenAPISpec => {
   Option.map(Context.getOption(api.annotations, License), (license) => {
     spec.info.license = license
   })
-  Option.map(Context.getOption(api.annotations, Security), (apiSecurity) => {
-    spec.security!.push({
-      [registerSecurity(apiSecurity)]: []
-    })
+  Option.map(Context.getOption(api.annotations, Servers), (servers) => {
+    spec.servers = servers as any
+  })
+  Option.map(Context.getOption(api.annotations, Override), (override) => {
+    Object.assign(spec, override)
+  })
+  HashSet.forEach(api.middlewares, (middleware) => {
+    if (!HttpApiMiddleware.isSecurity(middleware)) {
+      return
+    }
+    for (const [name, security] of Object.entries(middleware.security)) {
+      const id = registerSecurity(middleware, name, security)
+      spec.security!.push({
+        [id]: []
+      })
+    }
   })
   HttpApi.reflect(api as any, {
     onGroup({ group }) {
@@ -214,21 +191,24 @@ export const fromApi = <A extends HttpApi.HttpApi.Any>(api: A): OpenAPISpec => {
       Option.map(Context.getOption(group.annotations, ExternalDocs), (externalDocs) => {
         tag.externalDocs = externalDocs
       })
+      Option.map(Context.getOption(group.annotations, Override), (override) => {
+        Object.assign(tag, override)
+      })
       spec.tags!.push(tag)
     },
-    onEndpoint({ endpoint, errors, group, mergedAnnotations, successAST, successEncoding, successStatus }) {
+    onEndpoint({ endpoint, errors, group, middleware, successes }) {
       const path = endpoint.path.replace(/:(\w+)[^/]*/g, "{$1}")
       const method = endpoint.method.toLowerCase() as OpenAPISpecMethodName
       const op: DeepMutable<OpenAPISpecOperation> = {
         tags: [Context.getOrElse(group.annotations, Title, () => group.identifier)],
-        operationId: Context.getOrElse(endpoint.annotations, Identifier, () => `${group.identifier}.${endpoint.name}`),
+        operationId: Context.getOrElse(
+          endpoint.annotations,
+          Identifier,
+          () => group.topLevel ? endpoint.name : `${group.identifier}.${endpoint.name}`
+        ),
         parameters: [],
         security: [],
-        responses: {
-          [successStatus]: {
-            description: Option.getOrElse(getDescriptionOrIdentifier(successAST), () => "Success")
-          }
-        }
+        responses: {}
       }
       Option.map(Context.getOption(endpoint.annotations, Description), (description) => {
         op.description = description
@@ -236,10 +216,16 @@ export const fromApi = <A extends HttpApi.HttpApi.Any>(api: A): OpenAPISpec => {
       Option.map(Context.getOption(endpoint.annotations, ExternalDocs), (externalDocs) => {
         op.externalDocs = externalDocs
       })
-      Option.map(Context.getOption(mergedAnnotations, Security), (apiSecurity) => {
-        op.security!.push({
-          [registerSecurity(apiSecurity)]: []
-        })
+      HashSet.forEach(middleware, (middleware) => {
+        if (!HttpApiMiddleware.isSecurity(middleware)) {
+          return
+        }
+        for (const [name, security] of Object.entries(middleware.security)) {
+          const id = registerSecurity(middleware, name, security)
+          op.security!.push({
+            [id]: []
+          })
+        }
       })
       endpoint.payloadSchema.pipe(
         Option.filter(() => HttpMethod.hasBody(endpoint.method)),
@@ -247,24 +233,31 @@ export const fromApi = <A extends HttpApi.HttpApi.Any>(api: A): OpenAPISpec => {
           op.requestBody = {
             content: {
               [HttpApiSchema.getMultipart(schema.ast) ? "multipart/form-data" : "application/json"]: {
-                schema: JsonSchema.make(schema)
+                schema: makeJsonSchemaOrRef(schema)
               }
             },
             required: true
           }
         })
       )
-      successAST.pipe(
-        Option.map((ast) => {
-          op.responses![successStatus].content = {
-            [successEncoding.contentType]: {
-              schema: JsonSchema.make(Schema.make(ast))
+      for (const [status, ast] of successes) {
+        if (op.responses![status]) continue
+        op.responses![status] = {
+          description: Option.getOrElse(getDescriptionOrIdentifier(ast), () => "Success")
+        }
+        ast.pipe(
+          Option.filter((ast) => !HttpApiSchema.getEmptyDecodeable(ast)),
+          Option.map((ast) => {
+            op.responses![status].content = {
+              "application/json": {
+                schema: makeJsonSchemaOrRef(Schema.make(ast))
+              }
             }
-          }
-        })
-      )
+          })
+        )
+      }
       if (Option.isSome(endpoint.pathSchema)) {
-        const schema = JsonSchema.make(endpoint.pathSchema.value) as JsonSchema.Object
+        const schema = makeJsonSchemaOrRef(endpoint.pathSchema.value) as JsonSchema.Object
         if ("properties" in schema) {
           Object.entries(schema.properties).forEach(([name, jsonSchema]) => {
             op.parameters!.push({
@@ -277,7 +270,7 @@ export const fromApi = <A extends HttpApi.HttpApi.Any>(api: A): OpenAPISpec => {
         }
       }
       if (!HttpMethod.hasBody(endpoint.method) && Option.isSome(endpoint.payloadSchema)) {
-        const schema = JsonSchema.make(endpoint.payloadSchema.value) as JsonSchema.Object
+        const schema = makeJsonSchemaOrRef(endpoint.payloadSchema.value) as JsonSchema.Object
         if ("properties" in schema) {
           Object.entries(schema.properties).forEach(([name, jsonSchema]) => {
             op.parameters!.push({
@@ -290,7 +283,7 @@ export const fromApi = <A extends HttpApi.HttpApi.Any>(api: A): OpenAPISpec => {
         }
       }
       if (Option.isSome(endpoint.headersSchema)) {
-        const schema = JsonSchema.make(endpoint.headersSchema.value) as JsonSchema.Object
+        const schema = makeJsonSchemaOrRef(endpoint.headersSchema.value) as JsonSchema.Object
         if ("properties" in schema) {
           Object.entries(schema.properties).forEach(([name, jsonSchema]) => {
             op.parameters!.push({
@@ -302,6 +295,19 @@ export const fromApi = <A extends HttpApi.HttpApi.Any>(api: A): OpenAPISpec => {
           })
         }
       }
+      if (Option.isSome(endpoint.urlParamsSchema)) {
+        const schema = makeJsonSchemaOrRef(endpoint.urlParamsSchema.value) as JsonSchema.Object
+        if ("properties" in schema) {
+          Object.entries(schema.properties).forEach(([name, jsonSchema]) => {
+            op.parameters!.push({
+              name,
+              in: "query",
+              schema: jsonSchema,
+              required: schema.required.includes(name)
+            })
+          })
+        }
+      }
       for (const [status, ast] of errors) {
         if (op.responses![status]) continue
         op.responses![status] = {
@@ -312,7 +318,7 @@ export const fromApi = <A extends HttpApi.HttpApi.Any>(api: A): OpenAPISpec => {
           Option.map((ast) => {
             op.responses![status].content = {
               "application/json": {
-                schema: JsonSchema.make(Schema.make(ast))
+                schema: makeJsonSchemaOrRef(Schema.make(ast))
               }
             }
           })
@@ -321,6 +327,9 @@ export const fromApi = <A extends HttpApi.HttpApi.Any>(api: A): OpenAPISpec => {
       if (!spec.paths[path]) {
         spec.paths[path] = {}
       }
+      Option.map(Context.getOption(endpoint.annotations, Override), (override) => {
+        Object.assign(op, override)
+      })
       spec.paths[path][method] = op
     }
   })

package/src/OpenApiJsonSchema.ts

@@ -1,13 +1,13 @@
 /**
  * @since 1.0.0
  */
-import * as AST from "@effect/schema/AST"
-import type * as ParseResult from "@effect/schema/ParseResult"
-import type * as Schema from "@effect/schema/Schema"
 import * as Arr from "effect/Array"
 import * as Option from "effect/Option"
+import type * as ParseResult from "effect/ParseResult"
 import * as Predicate from "effect/Predicate"
 import * as Record from "effect/Record"
+import type * as Schema from "effect/Schema"
+import * as AST from "effect/SchemaAST"
 
 /**
  * @category model
@@ -213,19 +213,32 @@ export type Root = JsonSchema & {
  */
 export const make = <A, I, R>(schema: Schema.Schema<A, I, R>): Root => {
   const $defs: Record<string, any> = {}
-  const out = go(schema.ast, $defs, true, []) as Root
-  // clean up self-referencing entries
-  for (const id in $defs) {
-    if ($defs[id]["$ref"] === get$ref(id)) {
-      delete $defs[id]
-    }
-  }
+  const out = makeWithDefs(schema, { defs: $defs })
   if (!Record.isEmptyRecord($defs)) {
     out.$defs = $defs
   }
   return out
 }
 
+/**
+ * @category encoding
+ * @since 1.0.0
+ */
+export const makeWithDefs = <A, I, R>(schema: Schema.Schema<A, I, R>, options: {
+  readonly defs: Record<string, any>
+  readonly defsPath?: string
+}): Root => {
+  const defsPath = options.defsPath ?? "#/$defs/"
+  const getRef = (id: string) => `${defsPath}${id}`
+  const out = go(schema.ast, options.defs, true, [], { getRef }) as Root
+  for (const id in options.defs) {
+    if (options.defs[id]["$ref"] === getRef(id)) {
+      delete options.defs[id]
+    }
+  }
+  return out
+}
+
 const constAny: JsonSchema = { $id: "/schemas/any" }
 
 const constUnknown: JsonSchema = { $id: "/schemas/unknown" }
@@ -293,10 +306,6 @@ const pruneUndefinedKeyword = (ps: AST.PropertySignature): AST.AST | undefined =
   }
 }
 
-const DEFINITION_PREFIX = "#/$defs/"
-
-const get$ref = (id: string): string => `${DEFINITION_PREFIX}${id}`
-
 const getRefinementInnerTransformation = (ast: AST.Refinement): AST.AST | undefined => {
   switch (ast.from._tag) {
     case "Transformation":
@@ -312,7 +321,9 @@ const getRefinementInnerTransformation = (ast: AST.Refinement): AST.AST | undefi
   }
 }
 
-const isParseJsonTransformation = (ast: AST.AST): boolean => ast.annotations[AST.TypeAnnotationId] === ParseJsonTypeId
+const isParseJsonTransformation = (ast: AST.AST): boolean =>
+  ast._tag === "Transformation" &&
+  ast.from.annotations[AST.SchemaIdAnnotationId] === AST.ParseJsonSchemaId
 
 const isOverrideAnnotation = (jsonSchema: JsonSchema): boolean => {
   return ("type" in jsonSchema) || ("oneOf" in jsonSchema) || ("anyOf" in jsonSchema) || ("const" in jsonSchema) ||
@@ -323,7 +334,10 @@ const go = (
   ast: AST.AST,
   $defs: Record<string, JsonSchema>,
   handleIdentifier: boolean,
-  path: ReadonlyArray<PropertyKey>
+  path: ReadonlyArray<PropertyKey>,
+  options: {
+    readonly getRef: (id: string) => string
+  }
 ): JsonSchema => {
   const hook = AST.getJSONSchemaAnnotation(ast)
   if (Option.isSome(hook)) {
@@ -333,7 +347,7 @@ const go = (
       if (t === undefined) {
         try {
           return {
-            ...go(ast.from, $defs, true, path),
+            ...go(ast.from, $defs, true, path, options),
             ...getJsonSchemaAnnotations(ast),
             ...handler
           }
@@ -345,33 +359,42 @@ const go = (
         }
       } else if (!isOverrideAnnotation(handler)) {
         return {
-          ...go(t, $defs, true, path),
+          ...go(t, $defs, true, path, options),
           ...getJsonSchemaAnnotations(ast)
         }
       }
     }
     return handler
   }
-  const surrogate = getSurrogateAnnotation(ast)
-  if (Option.isSome(surrogate)) {
-    return {
-      ...(ast._tag === "Transformation" ? getJsonSchemaAnnotations(ast.to) : {}),
-      ...go(surrogate.value, $defs, handleIdentifier, path),
-      ...getJsonSchemaAnnotations(ast)
-    }
-  }
-  if (handleIdentifier && !AST.isTransformation(ast) && !AST.isRefinement(ast)) {
-    const identifier = getJSONIdentifier(ast)
+  const surrogate = AST.getSurrogateAnnotation(ast)
+  if (handleIdentifier && !AST.isRefinement(ast)) {
+    const identifier = AST.getJSONIdentifier(
+      Option.isSome(surrogate) ?
+        {
+          annotations: {
+            ...(ast._tag === "Transformation" ? ast.to.annotations : {}),
+            ...ast.annotations
+          }
+        } :
+        ast
+    )
     if (Option.isSome(identifier)) {
       const id = identifier.value
-      const out = { $ref: get$ref(id) }
+      const out = { $ref: options.getRef(id) }
       if (!Record.has($defs, id)) {
         $defs[id] = out
-        $defs[id] = go(ast, $defs, false, path)
+        $defs[id] = go(ast, $defs, false, path, options)
       }
       return out
     }
   }
+  if (Option.isSome(surrogate)) {
+    return {
+      ...(ast._tag === "Transformation" ? getJsonSchemaAnnotations(ast.to) : {}),
+      ...go(surrogate.value, $defs, handleIdentifier, path, options),
+      ...getJsonSchemaAnnotations(ast)
+    }
+  }
   switch (ast._tag) {
     case "Declaration":
       throw new Error(getJSONSchemaMissingAnnotationErrorMessage(path, ast))
@@ -429,11 +452,11 @@ const go = (
       throw new Error(getJSONSchemaMissingAnnotationErrorMessage(path, ast))
     case "TupleType": {
       const elements = ast.elements.map((e, i) => ({
-        ...go(e.type, $defs, true, path.concat(i)),
+        ...go(e.type, $defs, true, path.concat(i), options),
         ...getJsonSchemaAnnotations(e)
       }))
       const rest = ast.rest.map((annotatedAST) => ({
-        ...go(annotatedAST.type, $defs, true, path),
+        ...go(annotatedAST.type, $defs, true, path, options),
         ...getJsonSchemaAnnotations(annotatedAST)
       }))
       const output: Array = { type: "array" }
@@ -490,11 +513,11 @@ const go = (
         const parameter = is.parameter
         switch (parameter._tag) {
           case "StringKeyword": {
-            patternProperties = go(is.type, $defs, true, path)
+            patternProperties = go(is.type, $defs, true, path, options)
             break
           }
           case "TemplateLiteral": {
-            patternProperties = go(is.type, $defs, true, path)
+            patternProperties = go(is.type, $defs, true, path, options)
             propertyNames = {
               type: "string",
               pattern: AST.getTemplateLiteralRegExp(parameter).source
@@ -502,8 +525,8 @@ const go = (
             break
           }
           case "Refinement": {
-            patternProperties = go(is.type, $defs, true, path)
-            propertyNames = go(parameter, $defs, true, path)
+            patternProperties = go(is.type, $defs, true, path, options)
+            propertyNames = go(parameter, $defs, true, path, options)
             break
           }
           case "SymbolKeyword":
@@ -525,7 +548,7 @@ const go = (
         if (Predicate.isString(name)) {
           const pruned = pruneUndefinedKeyword(ps)
           output.properties[name] = {
-            ...go(pruned ? pruned : ps.type, $defs, true, path.concat(ps.name)),
+            ...go(pruned ? pruned : ps.type, $defs, true, path.concat(ps.name), options),
             ...getJsonSchemaAnnotations(ps)
           }
           // ---------------------------------------------
@@ -558,7 +581,7 @@ const go = (
       const enums: globalThis.Array<AST.LiteralValue> = []
       const anyOf: globalThis.Array<JsonSchema> = []
       for (const type of ast.types) {
-        const schema = go(type, $defs, true, path)
+        const schema = go(type, $defs, true, path, options)
         if ("enum" in schema) {
           if (Object.keys(schema).length > 1) {
             anyOf.push(schema)
@@ -591,7 +614,7 @@ const go = (
       if (AST.encodedBoundAST(ast) === ast) {
         throw new Error(getJSONSchemaMissingAnnotationErrorMessage(path, ast))
       }
-      return go(ast.from, $defs, true, path)
+      return go(ast.from, $defs, true, path, options)
     }
     case "TemplateLiteral": {
       const regex = AST.getTemplateLiteralRegExp(ast)
@@ -603,12 +626,12 @@ const go = (
       }
     }
     case "Suspend": {
-      const identifier = Option.orElse(getJSONIdentifier(ast), () => getJSONIdentifier(ast.f()))
+      const identifier = Option.orElse(AST.getJSONIdentifier(ast), () => AST.getJSONIdentifier(ast.f()))
       if (Option.isNone(identifier)) {
         throw new Error(getJSONSchemaMissingIdentifierAnnotationErrorMessage(path, ast))
       }
       return {
-        ...go(ast.f(), $defs, true, path),
+        ...go(ast.f(), $defs, true, path, options),
         ...getJsonSchemaAnnotations(ast)
       }
     }
@@ -617,17 +640,17 @@ const go = (
       // the 'to' side of the AST. This approach prevents the generation of useless schemas
       // derived from the 'from' side (type: string), ensuring the output matches the intended
       // complex schema type.
-      if (isParseJsonTransformation(ast.from)) {
+      if (isParseJsonTransformation(ast)) {
         return {
           type: "string",
           contentMediaType: "application/json",
-          contentSchema: go(ast.to, $defs, true, path),
+          contentSchema: go(ast.to, $defs, true, path, options),
           ...getJsonSchemaAnnotations(ast)
         }
       }
       return {
         ...getASTJsonSchemaAnnotations(ast.to),
-        ...go(ast.from, $defs, true, path),
+        ...go(ast.from, $defs, true, path, options),
         ...getJsonSchemaAnnotations(ast)
       }
     }
@@ -703,12 +726,3 @@ const formatPath = (path: ParseResult.Path): string =>
 const isNonEmpty = <A>(x: ParseResult.SingleOrNonEmpty<A>): x is Arr.NonEmptyReadonlyArray<A> => Array.isArray(x)
 
 const formatPropertyKey = (name: PropertyKey): string => typeof name === "string" ? JSON.stringify(name) : String(name)
-
-const ParseJsonTypeId: unique symbol = Symbol.for("@effect/schema/TypeId/ParseJson")
-const SurrogateAnnotationId = Symbol.for("@effect/schema/annotation/Surrogate")
-const JSONIdentifierAnnotationId = Symbol.for("@effect/schema/annotation/JSONIdentifier")
-
-const getSurrogateAnnotation = AST.getAnnotation<AST.AST>(SurrogateAnnotationId)
-const getJSONIdentifierAnnotation = AST.getAnnotation<string>(JSONIdentifierAnnotationId)
-const getJSONIdentifier = (annotated: AST.Annotated) =>
-  Option.orElse(getJSONIdentifierAnnotation(annotated), () => AST.getIdentifierAnnotation(annotated))

package/src/Transferable.ts

@@ -1,12 +1,12 @@
 /**
  * @since 1.0.0
  */
-import * as ParseResult from "@effect/schema/ParseResult"
-import * as Schema from "@effect/schema/Schema"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
 import * as Option from "effect/Option"
+import * as ParseResult from "effect/ParseResult"
+import * as Schema from "effect/Schema"
 
 /**
  * @since 1.0.0

package/src/UrlParams.ts

@@ -1,14 +1,14 @@
 /**
  * @since 1.0.0
  */
-import type { ParseOptions } from "@effect/schema/AST"
-import type * as ParseResult from "@effect/schema/ParseResult"
-import * as Schema from "@effect/schema/Schema"
 import * as Arr from "effect/Array"
 import type * as Effect from "effect/Effect"
 import * as Either from "effect/Either"
 import { dual } from "effect/Function"
 import * as Option from "effect/Option"
+import type * as ParseResult from "effect/ParseResult"
+import * as Schema from "effect/Schema"
+import type { ParseOptions } from "effect/SchemaAST"
 
 /**
  * @since 1.0.0