effect 4.0.0-beta.15 → 4.0.0-beta.16

package/src/Schema.ts

@@ -153,6 +153,7 @@ export interface Bottom<
    * @throws {Error} The issue is contained in the error cause.
    */
   makeUnsafe(input: this["~type.make.in"], options?: MakeOptions): this["Type"]
+  makeOption(input: this["~type.make.in"], options?: MakeOptions): Option_.Option<this["Type"]>
 }
 
 /**
@@ -5419,6 +5420,63 @@ export function OptionFromNullOr<S extends Top>(schema: S): OptionFromNullOr<S>
   ))
 }
 
+/**
+ * @since 4.0.0
+ */
+export interface OptionFromUndefinedOr<S extends Top> extends decodeTo<Option<toType<S>>, UndefinedOr<S>> {}
+
+/**
+ * Decodes an undefined-or value `T` to a required `Option<T>` value.
+ *
+ * Decoding:
+ * - `undefined` is decoded as `None`
+ * - other values are decoded as `Some`
+ *
+ * Encoding:
+ * - `None` is encoded as `undefined`
+ * - `Some` is encoded as the value
+ *
+ * @category Option
+ * @since 4.0.0
+ */
+export function OptionFromUndefinedOr<S extends Top>(schema: S): OptionFromUndefinedOr<S> {
+  return UndefinedOr(schema).pipe(decodeTo(
+    Option(toType(schema)),
+    Transformation.optionFromUndefinedOr()
+  ))
+}
+
+/**
+ * @since 4.0.0
+ */
+export interface OptionFromNullishOr<S extends Top> extends decodeTo<Option<toType<S>>, NullishOr<S>> {}
+
+/**
+ * Decodes a nullish value `T` to a required `Option<T>` value.
+ *
+ * Decoding:
+ * - `null` and `undefined` are decoded as `None`
+ * - other values are decoded as `Some`
+ *
+ * Encoding:
+ * - `None` is encoded as `null` or `undefined` depending on the provided `options.onNoneEncoding` (defaults to `undefined`)
+ * - `Some` is encoded as the value
+ *
+ * @category Option
+ * @since 4.0.0
+ */
+export function OptionFromNullishOr<S extends Top>(
+  schema: S,
+  options?: {
+    onNoneEncoding: null | undefined
+  }
+): OptionFromNullishOr<S> {
+  return NullishOr(schema).pipe(decodeTo(
+    Option(toType(schema)),
+    Transformation.optionFromNullishOr(options)
+  ))
+}
+
 /**
  * @since 4.0.0
  */
@@ -7978,6 +8036,9 @@ function makeClass<
     static makeUnsafe(input: S["~type.make.in"], options?: MakeOptions): Self {
       return new this(input, options)
     }
+    static makeOption(input: S["~type.make.in"], options?: MakeOptions): Option_.Option<Self> {
+      return Parser.makeOption(getClassSchema(this) as any)(input, options) as any
+    }
     static annotate(annotations: Annotations.Declaration<Self, readonly [S]>) {
       return this.rebuild(AST.annotate(this.ast, annotations))
     }

package/src/SchemaParser.ts

@@ -53,6 +53,17 @@ export function makeEffect<S extends Schema.Top>(schema: S) {
   }
 }
 
+/**
+ * @category Constructing
+ * @since 4.0.0
+ */
+export function makeOption<S extends Schema.Top>(schema: S) {
+  const parser = makeEffect(schema)
+  return (input: S["~type.make.in"], options?: Schema.MakeOptions): Option.Option<S["Type"]> => {
+    return Exit.getSuccess(Effect.runSyncExit(parser(input, options) as any))
+  }
+}
+
 /**
  * @category Constructing
  * @since 4.0.0

package/src/SchemaTransformation.ts

@@ -1006,8 +1006,7 @@ export const errorFromErrorJsonEncoded = (options?: {
  * ```
  *
  * See also:
- * - {@link optionFromOptionalKey}
- * - {@link optionFromOptional}
+ * - {@link optionFromNullishOr}
  *
  * @since 4.0.0
  */
@@ -1018,6 +1017,88 @@ export function optionFromNullOr<T>(): Transformation<Option.Option<T>, T | null
   })
 }
 
+/**
+ * Decodes `T | undefined` into `Option<T>` and encodes `Option<T>` back
+ * to `T | undefined`.
+ *
+ * When to use this:
+ * - Converting undefined-or API fields to `Option`.
+ *
+ * Behavior:
+ * - Decode: `undefined` → `Option.none()`, non-undefined → `Option.some(value)`.
+ * - Encode: `Option.none()` → `undefined`, `Option.some(value)` → `value`.
+ * - Pure and synchronous.
+ *
+ * **Example** (Option from undefined-or)
+ *
+ * ```ts
+ * import { Schema, SchemaTransformation } from "effect"
+ *
+ * const schema = Schema.UndefinedOr(Schema.String).pipe(
+ *   Schema.decodeTo(
+ *     Schema.Option(Schema.String),
+ *     SchemaTransformation.optionFromUndefinedOr()
+ *   )
+ * )
+ * ```
+ *
+ * See also:
+ * - {@link optionFromOptionalKey}
+ * - {@link optionFromOptional}
+ *
+ * @since 4.0.0
+ */
+export function optionFromUndefinedOr<T>(): Transformation<Option.Option<T>, T | undefined> {
+  return transform({
+    decode: Option.fromUndefinedOr,
+    encode: Option.getOrUndefined
+  })
+}
+
+/**
+ * Decodes `T | null | undefined` into `Option<T>` and encodes `Option<T>`
+ * back to `T | null` or `T | undefined` depending on the provided `options.onNoneEncoding` (defaults to `undefined`).
+ *
+ * When to use this:
+ * - Converting nullish API fields to `Option` when both `null` and
+ *   `undefined` represent absence.
+ *
+ * Behavior:
+ * - Decode: `null` or `undefined` → `Option.none()`, otherwise → `Option.some(value)`.
+ * - Encode: `Option.none()` → `null` or `undefined` (per `options.onNoneEncoding`),
+ *   `Option.some(value)` → `value`.
+ * - Pure and synchronous.
+ *
+ * **Example** (Option from nullish, encoding None as null)
+ *
+ * ```ts
+ * import { Schema, SchemaTransformation } from "effect"
+ *
+ * const schema = Schema.NullishOr(Schema.String).pipe(
+ *   Schema.decodeTo(
+ *     Schema.Option(Schema.String),
+ *     SchemaTransformation.optionFromNullishOr({ onNoneEncoding: null })
+ *   )
+ * )
+ * ```
+ *
+ * See also:
+ * - {@link optionFromNullOr}
+ * - {@link optionFromUndefinedOr}
+ *
+ * @since 4.0.0
+ */
+export function optionFromNullishOr<T>(
+  options?: {
+    onNoneEncoding: null | undefined
+  }
+): Transformation<Option.Option<T>, T | null | undefined> {
+  return transform({
+    decode: Option.fromNullishOr,
+    encode: options?.onNoneEncoding === null ? Option.getOrNull : Option.getOrUndefined
+  })
+}
+
 /**
  * Decodes an optional struct key into `Option<T>` and encodes `Option<T>`
  * back to an optional key.
@@ -1047,8 +1128,8 @@ export function optionFromNullOr<T>(): Transformation<Option.Option<T>, T | null
  * ```
  *
  * See also:
- * - {@link optionFromNullOr}
  * - {@link optionFromOptional}
+ * - {@link optionFromUndefinedOr}
  * - {@link transformOptional}
  *
  * @since 4.0.0
@@ -1088,8 +1169,8 @@ export function optionFromOptionalKey<T>(): Transformation<Option.Option<T>, T>
  * ```
  *
  * See also:
- * - {@link optionFromNullOr}
  * - {@link optionFromOptionalKey}
+ * - {@link optionFromUndefinedOr}
  * - {@link transformOptional}
  *
  * @since 4.0.0

package/src/internal/schema/schema.ts

@@ -31,5 +31,6 @@ export function make<S extends Schema.Top>(ast: S["ast"], options?: object): S {
   self.ast = ast
   self.rebuild = (ast: AST.AST) => make(ast, options)
   self.makeUnsafe = Parser.makeUnsafe(self)
+  self.makeOption = Parser.makeOption(self)
   return self
 }

package/src/unstable/httpapi/OpenApi.ts

@@ -635,9 +635,26 @@ function toEncodingAST(ast: AST.AST, _tag: HttpApiSchema.Encoding["_tag"]): AST.
       return Schema.String.ast
     case "FormUrlEncoded":
     case "Json":
-    case "Multipart":
       return ast
+    case "Multipart":
+      return persistedFileToBinaryEncoding(ast)
+  }
+}
+
+function persistedFileToBinaryEncoding(ast: AST.AST): AST.AST {
+  if (
+    AST.isDeclaration(ast) &&
+    ((ast.annotations as (Schema.Annotations.Declaration<unknown, readonly []> | undefined))?.typeConstructor?._tag ===
+      "effect/http/PersistedFile")
+  ) {
+    return Uint8ArrayEncoding.ast
+  }
+
+  if (typeof (ast as any)?.recur === "function") {
+    return (ast as any).recur(persistedFileToBinaryEncoding)
   }
+
+  return ast
 }
 
 const makeSecurityScheme = (security: HttpApiSecurity): OpenAPISecurityScheme => {