effect-app 4.0.0-beta.24 → 4.0.0-beta.241

package/src/Schema/SpecialJsonSchema.ts

@@ -0,0 +1,139 @@
+/**
+ * SpecialJsonSchema — A variant of Schema.toJsonSchemaDocument that
+ * post-processes the output (e.g. flattens simple allOf).
+ */
+import type * as JsonSchema from "effect/JsonSchema"
+import type * as Schema from "effect/Schema"
+import * as SchemaRepresentation from "effect/SchemaRepresentation"
+
+/**
+ * Converts a schema to a JSON Schema Document (draft-2020-12), with
+ * post-processing that flattens simple allOf entries.
+ */
+export function specialJsonSchemaDocument(
+  schema: Schema.Top,
+  options?: Schema.ToJsonSchemaOptions
+): JsonSchema.Document<"draft-2020-12"> {
+  const doc = SchemaRepresentation.fromAST(schema.ast)
+  const jd = SchemaRepresentation.toJsonSchemaDocument(doc, options)
+  const processedDefs: JsonSchema.Definitions = {}
+  for (const [key, def] of Object.entries(jd.definitions)) {
+    processedDefs[key] = postProcessJsonSchema(def)
+  }
+  return {
+    dialect: "draft-2020-12",
+    schema: postProcessJsonSchema(jd.schema),
+    definitions: processedDefs
+  }
+}
+
+/**
+ * Flattens `allOf` entries into the parent when the parent already has a
+ * `type` and every `allOf` entry is a plain constraint object (no `$ref`,
+ * no `type`). Merged properties from `allOf` entries win on conflict.
+ */
+export function flattenSimpleAllOf(obj: unknown): unknown {
+  if (obj === null || typeof obj !== "object") return obj
+
+  if (globalThis.Array.isArray(obj)) {
+    return obj.map(flattenSimpleAllOf)
+  }
+
+  const record = obj as Record<string, unknown>
+  const result: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(record)) {
+    result[key] = flattenSimpleAllOf(value)
+  }
+
+  if (result["type"] && globalThis.Array.isArray(result["allOf"])) {
+    const allOf = result["allOf"] as Array<Record<string, unknown>>
+    const canFlatten = allOf.every((entry) =>
+      typeof entry === "object" && entry !== null && !("$ref" in entry) && !("type" in entry)
+    )
+    if (canFlatten) {
+      const { allOf: _, ...rest } = result
+      const merged: Record<string, unknown> = { ...rest }
+      for (const entry of allOf) {
+        Object.assign(merged, entry)
+      }
+      return merged
+    }
+  }
+
+  return result
+}
+
+/**
+ * Recursively removes `additionalProperties: false` from JSON Schema objects.
+ * Only removes when the value is exactly `false` -- other values are left intact.
+ */
+export function removeAdditionalPropertiesFalse(obj: unknown): unknown {
+  if (obj === null || typeof obj !== "object") return obj
+
+  if (globalThis.Array.isArray(obj)) {
+    return obj.map(removeAdditionalPropertiesFalse)
+  }
+
+  const record = obj as Record<string, unknown>
+  const result: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(record)) {
+    if (key === "additionalProperties" && value === false) continue
+    result[key] = removeAdditionalPropertiesFalse(value)
+  }
+
+  return result
+}
+
+/**
+ * Flattens nested `anyOf` entries: if an anyOf entry is itself just `{ anyOf: [...] }`
+ * with no other keys, its children are inlined. If only one item remains, the anyOf
+ * wrapper is removed entirely.
+ */
+export function flattenNestedAnyOf(obj: unknown): unknown {
+  if (obj === null || typeof obj !== "object") return obj
+  if (globalThis.Array.isArray(obj)) return obj.map(flattenNestedAnyOf)
+
+  const record = obj as Record<string, unknown>
+  const result: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(record)) {
+    result[key] = flattenNestedAnyOf(value)
+  }
+
+  if (globalThis.Array.isArray(result["anyOf"])) {
+    const anyOf = result["anyOf"] as Array<unknown>
+    const flattened: Array<unknown> = []
+    for (const entry of anyOf) {
+      if (
+        typeof entry === "object"
+        && entry !== null
+        && !globalThis.Array.isArray(entry)
+        && "anyOf" in entry
+        && Object.keys(entry).length === 1
+        && globalThis.Array.isArray((entry as Record<string, unknown>)["anyOf"])
+      ) {
+        flattened.push(...(entry as Record<string, unknown>)["anyOf"] as Array<unknown>)
+      } else {
+        flattened.push(entry)
+      }
+    }
+    if (flattened.length === 1) {
+      const { anyOf: _, ...rest } = result
+      const single = flattened[0]
+      if (typeof single === "object" && single !== null && !globalThis.Array.isArray(single)) {
+        return { ...rest, ...single }
+      }
+      return single
+    }
+    result["anyOf"] = flattened
+  }
+
+  return result
+}
+
+/**
+ * Applies JSON Schema post-processing: flattens simple allOf,
+ * flattens nested anyOf, then strips additionalProperties: false.
+ */
+export function postProcessJsonSchema(obj: JsonSchema.JsonSchema): JsonSchema.JsonSchema {
+  return removeAdditionalPropertiesFalse(flattenNestedAnyOf(flattenSimpleAllOf(obj))) as JsonSchema.JsonSchema
+}

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)