Set infer: false by default in schema macro

Author: solnic

lib/drops/relation/plugins/reading.ex

@@ -1407,34 +1407,39 @@ defmodule Drops.Relation.Plugins.Reading do
     apply(repo, fun, [queryable] ++ args ++ [repo_opts])
   end
 
+  @doc false
   def operation(name, opts) when is_atom(name) do
     {relation, _repo, queryable, rest_opts} = clean_opts(opts)
     operation_opts = Keyword.get(rest_opts, name, rest_opts)
 
     relation.add_operation(queryable, name, operation_opts)
   end
 
+  @doc false
   def operation(other, name, opts) when is_struct(other) and is_map_key(other, :queryable) do
     {relation, _repo, _queryable, rest_opts} = clean_opts(opts)
     operation_opts = Keyword.get(rest_opts, name, rest_opts)
 
     relation.add_operation(other, name, operation_opts)
   end
 
+  @doc false
   def operation(other, name, opts) when is_struct(other) do
     {relation, _repo, queryable, rest_opts} = clean_opts(opts, other)
     operation_opts = Keyword.get(rest_opts, name, rest_opts)
 
     relation.add_operation(relation.new(queryable), name, operation_opts)
   end
 
+  @doc false
   def operation(other, name, opts) when is_atom(other) do
     {relation, _repo, queryable, rest_opts} = clean_opts(opts, other)
     operation_opts = Keyword.get(rest_opts, name, rest_opts)
 
     relation.add_operation(relation.new(queryable), name, operation_opts)
   end
 
+  @doc false
   def clean_opts(opts, queryable \\ nil) do
     relation = opts[:relation]
     repo = relation.repo()

lib/drops/relation/plugins/schema.ex

@@ -5,74 +5,6 @@ defmodule Drops.Relation.Plugins.Schema do
   This plugin adds the `schema/1` and `schema/2` macros for defining relation schemas.
   It supports both automatic schema inference from database tables and manual schema
   definition with Ecto.Schema syntax.
-
-  ## Examples
-
-  ### Automatic Schema Inference
-      defmodule MyApp.Users do
-        use Drops.Relation, otp_app: :my_app
-
-        schema("users", infer: true)
-      end
-
-      iex> schema = MyApp.Users.schema()
-      iex> schema.source
-      :users
-      iex> %{name: name, type: type, meta: %{default: default}} = MyApp.Users.schema(:email)
-      iex> name
-      :email
-      iex> type
-      :string
-      iex> default
-      nil
-
-  ### Manual Schema Definition
-
-  You can also define schemas manually using familiar Ecto.Schema syntax:
-
-      schema("users") do
-        field(:name, :string)
-        field(:email, :string)
-        field(:active, :boolean, default: true)
-
-        timestamps()
-      end
-
-  This gives you full control over field definitions, types, and options.
-
-  ## Hybrid Approach
-
-  Combine automatic inference with manual customizations:
-
-      defmodule MyApp.Users do
-        use Drops.Relation, repo: MyApp.Repo
-
-        schema("users", infer: true) do
-          field(:full_name, :string, virtual: true)
-
-          has_many(:posts, MyApp.Posts)
-        end
-      end
-
-  ### Schema Access and Struct Generation
-
-      iex> schema_module = MyApp.Users.__schema_module__()
-      iex> is_atom(schema_module)
-      true
-
-      iex> user = MyApp.Users.struct(%{name: "John", email: "[email protected]"})
-      iex> user.__struct__
-      MyApp.Users.User
-      iex> user.name
-      "John"
-      iex> user.email
-      "[email protected]"
-
-  ## Options
-
-  - `infer: true` - Automatically infer schema from database (default)
-  - `struct: "CustomName"` - Use custom struct module name
-  - Standard Ecto.Schema options are supported in manual definitions
   """
 
   alias Drops.Relation.Schema
@@ -87,7 +19,7 @@ defmodule Drops.Relation.Plugins.Schema do
 
     use Drops.Relation.Plugin.MacroStruct,
       key: :schema,
-      struct: [:name, block: nil, fields: nil, opts: [], infer: true]
+      struct: [:name, block: nil, fields: nil, opts: [], infer: false]
 
     def new(name) when is_binary(name) do
       %Macros.Schema{name: name}
@@ -99,7 +31,7 @@ defmodule Drops.Relation.Plugins.Schema do
 
     def new(name, opts) when is_binary(name) and is_list(opts) do
       opts = Keyword.delete(opts, :do)
-      infer = Keyword.get(opts, :infer, true)
+      infer = Keyword.get(opts, :infer, false)
 
       %{new(name) | opts: opts, infer: infer}
     end
@@ -109,7 +41,80 @@ defmodule Drops.Relation.Plugins.Schema do
     end
   end
 
-  defmacro schema(fields, opts \\ [])
+  @doc """
+  Defines a schema for the relation.
+
+  By default, this creates an empty schema that you must populate with manual field
+  definitions. Use `infer: true` option to automatically introspect the database table.
+
+  ## Parameters
+
+  - `table_name` - String name of the database table
+  - `opts` - Keyword list of options (optional)
+
+  ## Options
+
+  - `infer: false` - Use only manual field definitions (default: false)
+  - `infer: true` - Automatically infer schema from database table
+  - `struct: "CustomName"` - Use custom struct module name instead of default
+
+  ## Returns
+
+  Sets up the relation to generate:
+  - A `schema/0` function that returns the complete schema metadata
+  - A `schema/1` function that returns a specific field by name
+
+  ## Examples
+
+  Manual schema definition:
+
+      iex> defmodule Relations.Users do
+      ...>   use Drops.Relation, repo: MyApp.Repo
+      ...>
+      ...>   schema("users") do
+      ...>     field(:name, :string)
+      ...>     field(:email, :string)
+      ...>   end
+      ...> end
+      ...>
+      iex> user = Relations.Users.struct(%{name: "Alice Johnson", email: "[email protected]"})
+      iex> user.__struct__
+      Relations.Users.User
+      iex> user.name
+      "Alice Johnson"
+      iex> user.email
+      "[email protected]"
+
+  With automatic inference:
+
+      iex> defmodule Relations.Users do
+      ...>   use Drops.Relation, repo: MyApp.Repo
+      ...>
+      ...>   schema("users", infer: true)
+      ...> end
+      iex> schema = Relations.Users.schema()
+      iex> schema.source
+      :users
+      iex> length(schema.fields) > 0
+      true
+
+  With custom struct name:
+
+      iex> defmodule Relations.People do
+      ...>   use Drops.Relation, repo: MyApp.Repo
+      ...>
+      ...>   schema("users", struct: "Person", infer: true)
+      ...> end
+      ...>
+      iex> user = Relations.People.struct(%{name: "Alice Johnson", email: "[email protected]"})
+      iex> user.__struct__
+      Relations.People.Person
+      iex> user.name
+      "Alice Johnson"
+      iex> user.email
+      "[email protected]"
+  """
+  defmacro schema(name, opts \\ [])
 
   defmacro schema(name, opts) when is_binary(name) do
     block = opts[:do]
@@ -129,6 +134,47 @@ defmodule Drops.Relation.Plugins.Schema do
     end
   end
 
+  @doc """
+  Defines a schema with manual field definitions or combines inference with custom fields.
+
+  This form allows you to either define a completely manual schema using Ecto.Schema
+  syntax, or combine automatic inference with additional custom fields and associations.
+
+  ## Parameters
+
+  - `table_name` - String name of the database table
+  - `opts` - Keyword list of options
+  - `block` - Schema definition block using Ecto.Schema syntax
+
+  ## Options
+
+  - `infer: false` - Use only the manual field definitions in the block (default: false)
+  - `infer: true` - Automatically infer schema from database and merge with block
+  - `struct: "CustomName"` - Use custom struct module name
+
+  ## Returns
+
+  Sets up the relation with either a purely manual schema or a merged schema
+  combining inference with custom definitions.
+
+  ## Examples
+
+      iex> defmodule Relations.Users do
+      ...>   use Drops.Relation, repo: MyApp.Repo
+      ...>
+      ...>   schema("users", infer: true) do
+      ...>     field(:role, :string, default: "member")
+      ...>     field(:full_name, :string, virtual: true)
+      ...>   end
+      ...> end
+      ...>
+      iex> schema = Relations.Users.schema()
+      iex> %{name: name, meta: %{default: default}} = schema[:role]
+      iex> name
+      :role
+      iex> default
+      "member"
+  """
   defmacro schema(name, opts, block) when is_binary(name) do
     block = block[:do]
 
@@ -153,6 +199,7 @@ defmodule Drops.Relation.Plugins.Schema do
     end
   end
 
+  @doc false
   def put_schema(relation, opts) do
     schema =
       case context(relation, :schema) do
@@ -174,6 +221,15 @@ defmodule Drops.Relation.Plugins.Schema do
           else
             source_schema
           end
+
+        %{name: name, infer: false, block: block} when not is_nil(block) ->
+          Generator.schema_from_block(name, block)
+
+        %{name: name, infer: false, block: nil} ->
+          Schema.new(%{source: String.to_atom(name)})
+
+        %{name: name, block: nil} ->
+          Schema.new(%{source: String.to_atom(name)})
       end
 
     Module.put_attribute(relation, :schema, schema)

test/drops/relation/associations_test.exs

@@ -3,21 +3,21 @@ defmodule Drops.Relation.AssociationsTest do
 
   describe "defining associations" do
     relation(:user_groups) do
-      schema("user_groups") do
+      schema("user_groups", infer: true) do
         belongs_to(:user, Test.Relations.Users)
         belongs_to(:group, Test.Relations.Groups)
       end
     end
 
     relation(:users) do
-      schema("users") do
+      schema("users", infer: true) do
         has_many(:user_groups, Test.Relations.UserGroups)
         has_many(:groups, through: [:user_groups, :group])
       end
     end
 
     relation(:groups) do
-      schema("groups") do
+      schema("groups", infer: true) do
         has_many(:user_groups, Test.Relations.UserGroups)
         has_many(:users, through: [:user_groups, :user])
       end

test/drops/relation/metadata_test.exs

@@ -21,7 +21,7 @@ defmodule Drops.Relation.MetadataIntegrationTest do
 
   describe "parameterized types with metadata" do
     relation(:metadata_test) do
-      schema("metadata_test") do
+      schema("metadata_test", infer: true) do
         field(:status, Ecto.Enum, values: [:active, :inactive, :pending])
         field(:priority, :integer, default: 10)
       end

test/drops/relation/plugins/reading_test.exs

@@ -431,13 +431,13 @@ defmodule Drops.Relations.Plugins.ReadingTest do
     end
 
     relation(:association_items) do
-      schema("association_items") do
+      schema("association_items", infer: true) do
         belongs_to(:association, Test.Relations.Associations)
       end
     end
 
     relation(:associations) do
-      schema("associations") do
+      schema("associations", infer: true) do
         has_many(:items, Test.Relations.AssociationItems)
         belongs_to(:parent, Test.Relations.AssociationParents)
       end

test/drops/relation/plugins/schema_test.exs

@@ -191,7 +191,7 @@ defmodule Drops.Relation.Plugins.SchemaTest do
     end
 
     relation(:users_with_embeds) do
-      schema("users") do
+      schema("users", infer: true) do
         field(:name, :string)
         embeds_one(:metadata, TestEmbedded)
         embeds_many(:tags, TestEmbedded)
@@ -250,7 +250,7 @@ defmodule Drops.Relation.Plugins.SchemaTest do
 
   describe "embeds with inline schemas" do
     relation(:users_with_inline_embeds) do
-      schema("users") do
+      schema("users", infer: true) do
         field(:name, :string)
 
         embeds_one :profile, Profile do

test/drops/relation/schema_test.exs

@@ -5,7 +5,7 @@ defmodule Drops.Relation.SchemaTest do
     @describetag adapter: :sqlite
 
     relation(:metadata_test) do
-      schema("metadata_test") do
+      schema("metadata_test", infer: true) do
         field(:status, Ecto.Enum, values: [:active, :inactive, :pending])
         field(:priority, :integer, default: 10)
       end

test/drops/relation_test.exs

@@ -199,7 +199,7 @@ defmodule Drops.RelationTest do
 
   describe "customizing fields" do
     relation(:users) do
-      schema("users") do
+      schema("users", infer: true) do
         field(:tags, Ecto.Enum, values: [:red, :green, :blue])
         field(:status, :string, default: "active")
       end
@@ -236,7 +236,7 @@ defmodule Drops.RelationTest do
 
   describe "overriding inferred fields" do
     relation(:users) do
-      schema("users") do
+      schema("users", infer: true) do
         field(:name, :binary)
       end
     end