effect-app 4.0.0-beta.99 → 4.0.0

package/src/Schema/SchemaParser.ts

@@ -0,0 +1,12 @@
+import * as SchemaParser from "effect/SchemaParser"
+import { withDefaultParseOptions } from "./ext.ts"
+
+export * from "effect/SchemaParser"
+
+export const decodeEffectConcurrently: typeof SchemaParser.decodeEffect = withDefaultParseOptions(
+  SchemaParser.decodeEffect
+)
+
+export const decodeUnknownEffectConcurrently: typeof SchemaParser.decodeUnknownEffect = withDefaultParseOptions(
+  SchemaParser.decodeUnknownEffect
+)

package/src/Schema/SpecialJsonSchema.ts

@@ -2,7 +2,8 @@
  * SpecialJsonSchema — A variant of Schema.toJsonSchemaDocument that
  * post-processes the output (e.g. flattens simple allOf).
  */
-import { type JsonSchema, type Schema, SchemaRepresentation } from "effect"
+import type * as JsonSchema from "effect/JsonSchema"
+import * as Schema from "effect/Schema"
 
 /**
  * Converts a schema to a JSON Schema Document (draft-2020-12), with
@@ -12,8 +13,7 @@ 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 jd = Schema.toJsonSchemaDocument(schema, options)
   const processedDefs: JsonSchema.Definitions = {}
   for (const [key, def] of Object.entries(jd.definitions)) {
     processedDefs[key] = postProcessJsonSchema(def)
@@ -50,9 +50,9 @@ export function flattenSimpleAllOf(obj: unknown): unknown {
     )
     if (canFlatten) {
       const { allOf: _, ...rest } = result
-      let merged: Record<string, unknown> = { ...rest }
+      const merged: Record<string, unknown> = { ...rest }
       for (const entry of allOf) {
-        merged = { ...merged, ...entry }
+        Object.assign(merged, entry)
       }
       return merged
     }
@@ -62,8 +62,76 @@ export function flattenSimpleAllOf(obj: unknown): unknown {
 }
 
 /**
- * Applies JSON Schema post-processing: flattens simple allOf.
+ * 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 flattenSimpleAllOf(obj) as JsonSchema.JsonSchema
+  return removeAdditionalPropertiesFalse(flattenNestedAnyOf(flattenSimpleAllOf(obj))) as JsonSchema.JsonSchema
 }

package/src/Schema/SpecialOpenApi.ts

@@ -11,15 +11,15 @@
  * Usage with the OpenApi `Transform` annotation:
  *
  * ```ts
- * import { OpenApi } from "effect/unstable"
- * import { deduplicateOpenApiSchemas } from "./SpecialOpenApi.js"
+ * import { OpenApi } from "effect/http-api"
+ * import { deduplicateOpenApiSchemas } from "./SpecialOpenApi.ts"
  *
  * const api = HttpApi.make("myApi")
  *   .pipe(HttpApi.annotateContext(OpenApi.annotations({ transform: deduplicateOpenApiSchemas })))
  * ```
  */
 
-import { postProcessJsonSchema } from "./SpecialJsonSchema.js"
+import { postProcessJsonSchema } from "./SpecialJsonSchema.ts"
 
 /**
  * Deduplicates `components.schemas` entries in an OpenAPI spec.
@@ -70,7 +70,7 @@ export function deduplicateOpenApiSchemas(
     }
   }
 
-  if (remapping.size === 0) return postProcessJsonSchema(spec) as Record<string, any>
+  if (remapping.size === 0) return postProcessJsonSchema(spec)
 
   // Build new schemas object without duplicates
   const newSchemas: Record<string, any> = {}
@@ -85,7 +85,7 @@ export function deduplicateOpenApiSchemas(
   newSpec["components"]["schemas"] = newSchemas
   rewriteRefs(newSpec, remapping)
 
-  return postProcessJsonSchema(newSpec) as Record<string, any>
+  return postProcessJsonSchema(newSpec)
 }
 
 /**

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"
 
@@ -28,20 +28,35 @@ export interface Constructor<in out A extends B.Brand<any>> {
   is(a: Unbranded<A>): a is Unbranded<A> & A
 }
 
-type BrandAnnotations<C extends B.Brand<any>> =
-  & S.Annotations.Filter
-  & (
-    C extends string ? { readonly toArbitrary?: S.Annotations.ToArbitrary.Declaration<C, readonly []> }
-      : {}
-  )
+type BrandAnnotations = S.Annotations.Filter
+
+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>
+  _constructor: Constructor<C>,
+  options?: BrandAnnotations
 ) =>
-<Self extends S.Top>(self: Self): S.brand<Self["Rebuild"], B.Brand.Keys<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
+<Self extends S.Top>(self: Self): BrandedSchema<Self, C> => {
+  const branded = self.pipe(S.brand("Brand"))
+  return (options ? branded.pipe(S.annotate(options)) : branded) as BrandedSchema<Self, C>
 }
 
 export type Brands<P> = P extends B.Brand<any> ? B.Brand.Brands<P>

package/src/Schema/email.ts

@@ -2,8 +2,8 @@ import type { Refinement } from "effect-app/Function"
 import { isValidEmail } from "effect-app/validation"
 import * as S from "effect/Schema"
 import type { Simplify } from "effect/Types"
-import type { B } from "./schema.js"
-import type { NonEmptyStringBrand } from "./strings.js"
+import type { B } from "./schema.ts"
+import type { NonEmptyStringBrand } from "./strings.ts"
 
 export interface EmailBrand extends Simplify<NonEmptyStringBrand & B.Brand<"Email">> {}
 
@@ -20,11 +20,13 @@ export const Email = S
     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, maxLength: 998 }
-    }),
-    S.annotate({
-      toArbitrary: () => (fc) => fc.emailAddress().map((_) => _ as Email)
+      // JSON Schema minLength counts code points; isMinLength(3) is UTF-16 units (ceil(3/2)=2).
+      jsonSchema: { format: "email", minLength: 2, maxLength: 998 },
+      // Native Arbitrary cannot invert `isValidEmail`; without a constraint, rejection sampling
+      // discards (almost) every random string.
+      arbitraryConstraint: {
+        patterns: [{ source: "^[a-z]{3,10}@[a-z]{3,10}\\.(?:com|net|org|de)$", flags: "" }]
+      }
     })
   )