effect-app 4.0.0-beta.26 → 4.0.0-beta.260

package/src/Schema/SpecialOpenApi.ts

@@ -0,0 +1,130 @@
+/**
+ * SpecialOpenApi — Deduplicates `components/schemas` entries in an OpenAPI spec
+ * and applies JSON Schema post-processing (null removal, allOf flattening).
+ *
+ * When `OpenApi.fromApi` generates the spec, different AST nodes sharing the
+ * same identifier can produce duplicate entries (e.g. "X" and "X1") in
+ * `components.schemas`. This module provides a transform function that
+ * collapses those duplicates, rewrites all `$ref` pointers accordingly,
+ * and post-processes schemas for better codegen compatibility.
+ *
+ * Usage with the OpenApi `Transform` annotation:
+ *
+ * ```ts
+ * import { OpenApi } from "effect/unstable"
+ * import { deduplicateOpenApiSchemas } from "./SpecialOpenApi.js"
+ *
+ * const api = HttpApi.make("myApi")
+ *   .pipe(HttpApi.annotateContext(OpenApi.annotations({ transform: deduplicateOpenApiSchemas })))
+ * ```
+ */
+
+import { postProcessJsonSchema } from "./SpecialJsonSchema.js"
+
+/**
+ * Deduplicates `components.schemas` entries in an OpenAPI spec.
+ *
+ * Entries sharing the same base identifier (e.g. "X" and "X1") whose JSON
+ * representations are identical are collapsed into a single canonical entry,
+ * and all `$ref` pointers throughout the spec are rewritten to point to
+ * the canonical key.
+ *
+ * Designed to be used as the `transform` option in `OpenApi.annotations`.
+ */
+export function deduplicateOpenApiSchemas(
+  spec: Record<string, any>
+): Record<string, any> {
+  const components = spec["components"] as Record<string, any> | undefined
+  if (!components) return spec
+  const schemas = components["schemas"] as Record<string, any> | undefined
+  if (!schemas) return spec
+
+  const keys = Object.keys(schemas)
+  if (keys.length === 0) return spec
+
+  // Group keys by base identifier (strip trailing digits)
+  const groups = new Map<string, Array<{ key: string; fingerprint: string }>>()
+  for (const key of keys) {
+    const base = getBaseIdentifier(key)
+    const fingerprint = JSON.stringify(schemas[key])
+    const group = groups.get(base)
+    if (group === undefined) {
+      groups.set(base, [{ key, fingerprint }])
+    } else {
+      group.push({ key, fingerprint })
+    }
+  }
+
+  // Build remapping from duplicate keys to canonical keys
+  const remapping = new Map<string, string>()
+  for (const [, group] of groups) {
+    if (group.length <= 1) continue
+    const seen = new Map<string, string>() // fingerprint -> canonical key
+    for (const entry of group) {
+      const canonical = seen.get(entry.fingerprint)
+      if (canonical !== undefined) {
+        remapping.set(entry.key, canonical)
+      } else {
+        seen.set(entry.fingerprint, entry.key)
+      }
+    }
+  }
+
+  if (remapping.size === 0) return postProcessJsonSchema(spec)
+
+  // Build new schemas object without duplicates
+  const newSchemas: Record<string, any> = {}
+  for (const key of keys) {
+    if (!remapping.has(key)) {
+      newSchemas[key] = schemas[key]
+    }
+  }
+
+  // Deep clone the spec, replace schemas, and rewrite all $ref pointers
+  const newSpec = structuredClone(spec)
+  newSpec["components"]["schemas"] = newSchemas
+  rewriteRefs(newSpec, remapping)
+
+  return postProcessJsonSchema(newSpec)
+}
+
+/**
+ * Extracts the base identifier from a schema key by stripping trailing
+ * digits appended by the gen() function.
+ * E.g. "X1" -> "X", "X" -> "X", "MyType2" -> "MyType"
+ */
+function getBaseIdentifier(key: string): string {
+  const match = key.match(/^(.+?)(\d+)$/)
+  return match ? match[1]! : key
+}
+
+/**
+ * Recursively rewrites `$ref` values in a JSON object tree.
+ * Mutates the object in-place (caller should pass a deep clone).
+ */
+function rewriteRefs(obj: any, remapping: Map<string, string>): void {
+  if (obj === null || typeof obj !== "object") return
+
+  if (Array.isArray(obj)) {
+    for (const item of obj) {
+      rewriteRefs(item, remapping)
+    }
+    return
+  }
+
+  if (typeof obj.$ref === "string") {
+    // OpenAPI refs look like "#/components/schemas/X1"
+    const prefix = "#/components/schemas/"
+    if (obj.$ref.startsWith(prefix)) {
+      const refKey = obj.$ref.slice(prefix.length)
+      const canonical = remapping.get(refKey)
+      if (canonical !== undefined) {
+        obj.$ref = prefix + canonical
+      }
+    }
+  }
+
+  for (const value of Object.values(obj)) {
+    rewriteRefs(value, remapping)
+  }
+}

package/src/Schema/brand.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
-import type { Option } from "effect"
 import * as B from "effect/Brand"
+import type * as Option from "effect/Option"
 import type * as Result from "effect/Result"
 import * as S from "effect/Schema"
 
@@ -35,11 +35,31 @@ type BrandAnnotations<C extends B.Brand<any>> =
       : {}
   )
 
+export interface BrandedSchema<S extends S.Top, C extends B.Brand<any>> extends
+  S.Bottom<
+    C,
+    S["Encoded"],
+    S["DecodingServices"],
+    S["EncodingServices"],
+    S["ast"],
+    BrandedSchema<S, C>,
+    S["~type.make.in"],
+    S["Iso"],
+    S["~type.parameters"],
+    C,
+    S["~type.mutability"],
+    S["~type.optionality"],
+    S["~type.constructor.default"],
+    S["~encoded.mutability"],
+    S["~encoded.optionality"]
+  >
+{}
+
 export const fromBrand = <C extends B.Brand<any>>(
   constructor: Constructor<C>,
   options?: BrandAnnotations<C>
 ) =>
-<Self extends S.Top>(self: Self): S.brand<Self["~rebuild.out"], B.Brand.Keys<C>> => {
+<Self extends S.Top>(self: Self): BrandedSchema<Self, C> => {
   const branded = S.fromBrand(options?.identifier ?? "Brand", constructor as any)(self as any)
   return options ? (branded as any).pipe(S.annotate(options)) : branded as any
 }

package/src/Schema/email.ts

@@ -12,11 +12,16 @@ export type Email = string & EmailBrand
 export const Email = S
   .String
   .pipe(
+    S.annotate({
+      title: "Email",
+      description: "an email according to RFC 5322",
+      format: "email"
+    }),
+    S.check(S.isMinLength(3), /* a@b */ S.isMaxLength(998)),
     S.refine(isValidEmail as Refinement<string, Email>, {
       identifier: "Email",
-      title: "Email",
       description: "an email according to RFC 5322",
-      jsonSchema: { format: "email", minLength: 3, /* a@b */ maxLength: 998 }
+      jsonSchema: { format: "email", minLength: 3, maxLength: 998 }
     }),
     S.annotate({
       toArbitrary: () => (fc) => fc.emailAddress().map((_) => _ as Email)