refactor: remove enforce support and whitelist typed options

Replace explicit enforce rejection with a whitelist approach that only
passes supported typed option keys (type, null, default) to TypedStructor.
Unsupported options like enforce are silently ignored.

Author: fahchen

AGENTS.md

@@ -52,7 +52,7 @@ EctoTypedSchema generates `@type` specs from Ecto schema definitions by combinin
 
 ## Supported Features You Must Preserve
 
-- Schema-level defaults: `null`, `enforce`, plus `type_kind` and `type_name`
+- Schema-level defaults: `null`, plus `type_kind` and `type_name`
 - Type parameters via `parameter/2` with declaration-order preservation
 - TypedStructor plugin forwarding via `plugin/2` with declaration-order preservation
 - Through-association type generation for fields absent from `__changeset__/0`

README.md

@@ -50,8 +50,8 @@ end
 - **Zero-annotation inference** -- Ecto types mapped to typespecs automatically (`:string` -> `String.t()`, `:integer` -> `integer()`, etc.)
 - **Association-aware** -- `belongs_to`, `has_many`, `has_one`, `many_to_many`, and embeds all generate correct types
 - **Ecto runtime semantics** -- primary keys non-nullable, `has_many`/`embeds_many` default to `[]`, and most other fields nullable
-- **Fine-grained control** -- override per-field with `typed: [null: false]`, `typed: [type: ...]`, or `typed: [enforce: true]` (type-level requiredness)
-- **Schema-level defaults** -- set `null:`, `enforce:`, `type_kind:`, `type_name:` for all fields at once
+- **Fine-grained control** -- override per-field with `typed: [null: false]` or `typed: [type: ...]`
+- **Schema-level defaults** -- set `null:`, `type_kind:`, `type_name:` for all fields at once
 - **Through associations** -- resolved at compile time with fallback warning
 - **Plugin system** -- forward [TypedStructor plugins](https://hexdocs.pm/typed_structor/TypedStructor.Plugin.html) into the generated type block
 - **Embedded schemas** -- `typed_embedded_schema` works the same way, without `__meta__`

lib/ecto_typed_schema.ex

@@ -15,18 +15,13 @@ defmodule EctoTypedSchema do
              | --- | --- |
              | `type:` | Override the inferred type entirely |
              | `null:` | `false` removes `\\| nil` from the type |
-             | `enforce:` | `true` treats the field as required for type generation (non-nullable unless `default:` is set) |
              | `default:` | Type metadata default; non-nil defaults imply non-nullable (runtime defaults come from Ecto `default:`) |
 
              ```elixir
-             field :email, :string, typed: [null: false, enforce: true]
+             field :email, :string, typed: [null: false]
              field :role, :string, typed: [type: :admin | :user]
              ```
 
-             `EctoTypedSchema` uses `TypedStructor` in `define_struct: false` mode, so
-             `typed: [enforce: true]` affects generated types but does not set runtime
-             `@enforce_keys`.
-
              For `belongs_to`, the `:foreign_key` sub-option controls the FK field's type:
 
              ```elixir
@@ -41,7 +36,7 @@ defmodule EctoTypedSchema do
              defaults to every field (per-field `typed:` options override):
 
              ```elixir
-             typed_schema "users", null: false, enforce: true do
+             typed_schema "users", null: false do
                field :name, :string
                field :bio, :string, typed: [null: true]  # override: nullable
              end
@@ -50,7 +45,6 @@ defmodule EctoTypedSchema do
              | Option | Effect |
              | --- | --- |
              | `null:` | Default nullability for all fields |
-             | `enforce:` | Default type-level requiredness for all fields (does not set runtime `@enforce_keys`) |
              | `type_kind:` | `:opaque`, `:typep`, etc. (default `:type`) |
              | `type_name:` | Custom type name (default `:t`) |
              """)
@@ -103,7 +97,8 @@ defmodule EctoTypedSchema do
       |> Map.new()
 
     schema_opts = Module.get_attribute(env.module, :ecto_typed_schema_opts, [])
-    schema_defaults = Keyword.take(schema_opts, [:enforce, :null])
+
+    schema_defaults = Keyword.take(schema_opts, [:null])
     primary_keys = Module.get_attribute(env.module, :ecto_primary_keys, [])
 
     fields_ast = build_fields_ast(changeset_info, override_map, schema_defaults, primary_keys)
@@ -253,15 +248,15 @@ defmodule EctoTypedSchema do
       typed_structor unquote(opts) do
         unquote(plugins)
         unquote(parameters)
-        field :__meta__, Ecto.Schema.Metadata.t(__MODULE__), enforce: true
+        field :__meta__, Ecto.Schema.Metadata.t(__MODULE__), null: false
         unquote(fields)
         unquote(additional_fields)
       end
     end
   end
 
-  # Merges precomputed schema-level defaults (`:enforce`, `:null`) with
-  # per-field options. Field-level options take precedence.
+  # Merges precomputed schema-level defaults (`:null`) with per-field options.
+  # Field-level options take precedence.
   @spec merge_schema_opts(keyword(), keyword()) :: keyword()
   defp merge_schema_opts(field_opts, schema_defaults) do
     Keyword.merge(schema_defaults, field_opts)
@@ -477,7 +472,7 @@ defmodule EctoTypedSchema do
   ## Examples
 
       field :name, :string
-      field :email, :string, typed: [null: false, enforce: true]
+      field :email, :string, typed: [null: false]
       field :role, Ecto.Enum, values: [:admin, :user, :guest]
   """
   defmacro field(name, type \\ :string, opts \\ []),
@@ -605,7 +600,7 @@ defmodule EctoTypedSchema do
 
   ## Examples
 
-      embeds_many :addresses, Address, typed: [enforce: true]
+      embeds_many :addresses, Address
 
       embeds_many :line_items, LineItem, primary_key: false do
         field :product_name, :string
@@ -670,8 +665,6 @@ defmodule EctoTypedSchema do
   Options that apply as defaults to every field (individual fields
   can override via their `:typed` option):
 
-    * `:enforce` - if `true`, marks fields as required for type generation
-      (non-nullable unless a default is present)
     * `:null` - if `false`, makes all field types non-nullable
     * `:type_kind` - the kind of type to generate (e.g., `:opaque`)
     * `:type_name` - custom name for the generated type (default: `:t`)
@@ -755,8 +748,6 @@ defmodule EctoTypedSchema do
   Options that apply as defaults to every field (individual fields
   can override via their `:typed` option):
 
-    * `:enforce` - if `true`, marks fields as required for type generation
-      (non-nullable unless a default is present)
     * `:null` - if `false`, makes all field types non-nullable
     * `:type_kind` - the kind of type to generate (e.g., `:opaque`)
     * `:type_name` - custom name for the generated type (default: `:t`)

lib/ecto_typed_schema/field_macros.ex

@@ -18,7 +18,7 @@ defmodule EctoTypedSchema.FieldMacros do
   @spec field(atom(), atom() | module(), keyword()) :: Macro.t()
   defmacro field(name, type \\ :string, opts \\ []) do
     {typed, opts} = Keyword.pop(opts, :typed, [])
-    validate_typed_option!(name, typed)
+    typed = sanitize_typed_opts(typed)
 
     # Propagate non-nil Ecto defaults to typed opts so TypedStructor sees them,
     # unless the field is explicitly nullable (null: true).
@@ -50,34 +50,31 @@ defmodule EctoTypedSchema.FieldMacros do
     end
   end
 
-  @spec validate_typed_option!(atom(), term()) :: :ok
-  defp validate_typed_option!(field_name, typed) do
-    unless Keyword.keyword?(typed) do
-      raise ArgumentError,
-            "field :#{field_name} option :typed must be a keyword list, got: #{inspect(typed)}"
-    end
+  @supported_typed_keys [:type, :null, :default, :enum_values, :through, :foreign_key]
 
-    :ok
-  end
+  @spec sanitize_typed_opts(keyword()) :: keyword()
+  defp sanitize_typed_opts(typed), do: Keyword.take(typed, @supported_typed_keys)
 
   @spec belongs_to(atom(), module(), keyword()) :: Macro.t()
   defmacro belongs_to(name, schema, opts \\ []) do
     {typed, opts} = Keyword.pop(opts, :typed, [])
-    validate_typed_option!(name, typed)
+    typed = sanitize_typed_opts(typed)
     {foreign_key_typed, typed} = Keyword.pop(typed, :foreign_key, [])
 
-    # Propagate null/enforce from association to FK unless FK explicitly overrides
-    foreign_key_typed =
-      typed
-      |> Keyword.take([:null, :enforce])
-      |> Keyword.merge(foreign_key_typed)
-
     foreign_key =
       case Keyword.fetch(opts, :foreign_key) do
         :error -> :"#{name}_id"
         {:ok, value} -> value
       end
 
+    foreign_key_typed = sanitize_typed_opts(foreign_key_typed)
+
+    # Propagate null from association to FK unless FK explicitly overrides
+    foreign_key_typed =
+      typed
+      |> Keyword.take([:null])
+      |> Keyword.merge(foreign_key_typed)
+
     define_field = Keyword.get(opts, :define_field, true)
 
     quote location: :keep do
@@ -94,7 +91,7 @@ defmodule EctoTypedSchema.FieldMacros do
   @spec has_one(atom(), module() | keyword(), keyword()) :: Macro.t()
   defmacro has_one(name, schema, opts \\ []) do
     {typed, schema, opts} = extract_has_typed_opts(schema, opts)
-    validate_typed_option!(name, typed)
+    typed = sanitize_typed_opts(typed)
 
     quote location: :keep do
       @ecto_typed_schema_typed {unquote(name), unquote(Macro.escape(typed))}
@@ -106,7 +103,7 @@ defmodule EctoTypedSchema.FieldMacros do
   @spec embeds_one(atom(), module(), keyword()) :: Macro.t()
   defmacro embeds_one(name, schema, opts \\ []) do
     {typed, opts} = Keyword.pop(opts, :typed, [])
-    validate_typed_option!(name, typed)
+    typed = sanitize_typed_opts(typed)
 
     quote location: :keep do
       @ecto_typed_schema_typed {unquote(name), unquote(Macro.escape(typed))}
@@ -118,7 +115,7 @@ defmodule EctoTypedSchema.FieldMacros do
   @spec embeds_one(atom(), module(), keyword(), keyword()) :: Macro.t()
   defmacro embeds_one(name, schema, opts, do: block) do
     {typed, opts} = Keyword.pop(opts, :typed, [])
-    validate_typed_option!(name, typed)
+    typed = sanitize_typed_opts(typed)
 
     quote location: :keep do
       @ecto_typed_schema_typed {unquote(name), unquote(Macro.escape(typed))}
@@ -130,7 +127,7 @@ defmodule EctoTypedSchema.FieldMacros do
   @spec embeds_many(atom(), module(), keyword()) :: Macro.t()
   defmacro embeds_many(name, schema, opts \\ []) do
     {typed, opts} = Keyword.pop(opts, :typed, [])
-    validate_typed_option!(name, typed)
+    typed = sanitize_typed_opts(typed)
 
     quote location: :keep do
       @ecto_typed_schema_typed {unquote(name), unquote(Macro.escape(typed))}
@@ -142,7 +139,7 @@ defmodule EctoTypedSchema.FieldMacros do
   @spec embeds_many(atom(), module(), keyword(), keyword()) :: Macro.t()
   defmacro embeds_many(name, schema, opts, do: block) do
     {typed, opts} = Keyword.pop(opts, :typed, [])
-    validate_typed_option!(name, typed)
+    typed = sanitize_typed_opts(typed)
 
     quote location: :keep do
       @ecto_typed_schema_typed {unquote(name), unquote(Macro.escape(typed))}
@@ -154,7 +151,7 @@ defmodule EctoTypedSchema.FieldMacros do
   @spec has_many(atom(), module() | keyword(), keyword()) :: Macro.t()
   defmacro has_many(name, schema, opts \\ []) do
     {typed, schema, opts} = extract_has_typed_opts(schema, opts)
-    validate_typed_option!(name, typed)
+    typed = sanitize_typed_opts(typed)
 
     quote location: :keep do
       @ecto_typed_schema_typed {unquote(name), unquote(Macro.escape(typed))}
@@ -166,7 +163,7 @@ defmodule EctoTypedSchema.FieldMacros do
   @spec many_to_many(atom(), module(), keyword()) :: Macro.t()
   defmacro many_to_many(name, schema, opts \\ []) do
     {typed, opts} = Keyword.pop(opts, :typed, [])
-    validate_typed_option!(name, typed)
+    typed = sanitize_typed_opts(typed)
 
     quote location: :keep do
       @ecto_typed_schema_typed {unquote(name), unquote(Macro.escape(typed))}
@@ -178,7 +175,7 @@ defmodule EctoTypedSchema.FieldMacros do
   @spec timestamps(keyword()) :: Macro.t()
   defmacro timestamps(opts \\ []) do
     {typed, opts} = Keyword.pop(opts, :typed, [])
-    validate_typed_option!(:timestamps, typed)
+    typed = sanitize_typed_opts(typed)
 
     quote location: :keep do
       # Merge @timestamps_opts (if defined) with explicit opts.

test/ecto_typed_schema/types/belongs_to_test.exs

@@ -118,41 +118,6 @@ defmodule EctoTypedSchema.Types.BelongsToTest do
     end
   end
 
-  describe "with enforce: true" do
-    test "makes association non-nullable", ctx do
-      expected_types =
-        with_tmpmodule Schema, ctx do
-          use Ecto.Schema
-
-          schema "posts" do
-            belongs_to :author, User
-          end
-
-          @type t() :: %__MODULE__{
-                  __meta__: Ecto.Schema.Metadata.t(__MODULE__),
-                  id: integer(),
-                  author: Ecto.Schema.belongs_to(User.t()),
-                  author_id: integer()
-                }
-        after
-          fetch_types!(Schema)
-        end
-
-      generated_types =
-        with_tmpmodule Schema, ctx do
-          use EctoTypedSchema
-
-          typed_schema "posts" do
-            belongs_to :author, User, typed: [enforce: true]
-          end
-        after
-          fetch_types!(Schema)
-        end
-
-      assert_type(expected_types, generated_types)
-    end
-  end
-
   describe "with custom FK type" do
     test "overrides foreign key type", ctx do
       expected_types =

test/ecto_typed_schema/types/embedded_schema_test.exs

@@ -39,42 +39,6 @@ defmodule EctoTypedSchema.Types.EmbeddedSchemaTest do
     end
   end
 
-  describe "with schema-level enforce: true" do
-    test "all fields are non-nullable", ctx do
-      expected_types =
-        with_tmpmodule Schema, ctx do
-          use Ecto.Schema
-
-          embedded_schema do
-            field :name, :string
-            field :age, :integer
-          end
-
-          @type t() :: %__MODULE__{
-                  id: Ecto.UUID.t(),
-                  name: String.t(),
-                  age: integer()
-                }
-        after
-          fetch_types!(Schema)
-        end
-
-      generated_types =
-        with_tmpmodule Schema, ctx do
-          use EctoTypedSchema
-
-          typed_embedded_schema enforce: true do
-            field :name, :string
-            field :age, :integer
-          end
-        after
-          fetch_types!(Schema)
-        end
-
-      assert_type(expected_types, generated_types)
-    end
-  end
-
   describe "with schema-level null: false" do
     test "all fields are non-nullable", ctx do
       expected_types =
@@ -332,40 +296,4 @@ defmodule EctoTypedSchema.Types.EmbeddedSchemaTest do
       assert_type(expected_types, generated_types)
     end
   end
-
-  describe "combined schema-level options" do
-    test "enforce: true and null: false together", ctx do
-      expected_types =
-        with_tmpmodule Schema, ctx do
-          use Ecto.Schema
-
-          embedded_schema do
-            field :name, :string
-            field :age, :integer
-          end
-
-          @type t() :: %__MODULE__{
-                  id: Ecto.UUID.t(),
-                  name: String.t(),
-                  age: integer()
-                }
-        after
-          fetch_types!(Schema)
-        end
-
-      generated_types =
-        with_tmpmodule Schema, ctx do
-          use EctoTypedSchema
-
-          typed_embedded_schema enforce: true, null: false do
-            field :name, :string
-            field :age, :integer
-          end
-        after
-          fetch_types!(Schema)
-        end
-
-      assert_type(expected_types, generated_types)
-    end
-  end
 end