Code duplication in Elixir and Ecto - ecto

Question

I want to compose a module out of smaller modules.
This is a module I have right now:
defmodule Api.Product do
use Ecto.Schema
import Ecto.Changeset
import Api.Repo
import Ecto.Query
#derive {Poison.Encoder, only: [:name, :brand, :description, :image, :rating, :number_of_votes]}
schema "products" do
field :name, :string
field :brand, :string
field :description, :string
field :image, :string
field :rating, :integer
field :number_of_votes, :integer
field :not_vegan_count, :integer
end
def changeset(product, params \\ %{}) do
product
|> cast(params, [:name, :brand, :description, :image, :rating, :number_of_votes, :not_vegan_count])
|> validate_required([:name, :description, :brand])
|> unique_constraint(:brand, name: :unique_product)
end
def delete_all_from_products do
from(Api.Product) |> delete_all
end
def insert_product(conn, product) do
changeset = Api.Product.changeset(%Api.Product{}, product)
errors = changeset.errors
valid = changeset.valid?
case insert(changeset) do
{:ok, product} ->
{:success, product}
{:error, changeset} ->
{:error, changeset}
end
end
def get_product_by_name_and_brand(name, brand) do
Api.Product |> Ecto.Query.where(name: ^name) |> Ecto.Query.where(brand: ^brand) |> all
end
def get_products do
Api.Product |> all
end
end
But I want to have different things other than Product which all have most of the same fields as Product except for brand. Therefore is it best to create a module which has all fields except brand and then all the modules containing those fields have that module as a field?
Here is my module that all modules would contain:
defmodule Api.VeganThing do
use Ecto.Schema
import Ecto.Changeset
import Api.Repo
import Ecto.Query
#derive {Poison.Encoder, only: [:name, :description, :image, :rating, :number_of_votes]}
schema "vegan_things" do
field :name, :string
field :description, :string
field :image, :string
field :rating, :integer
field :number_of_votes, :integer
field :not_vegan_count, :integer
end
end
There will be no database table for vegan_things. But a few different modules which do have database tables will contain a vegan_thing.
Is this a good way to avoid the code duplication of rewriting every field in every module in Elixir?
Here is my current changeset:
defmodule Api.Repo.Migrations.CreateProducts do
use Ecto.Migration
def change do
create table(:products) do
add :name, :string
add :brand, :string
add :description, :string
add :image, :string
add :rating, :integer
add :number_of_votes, :integer
add :not_vegan_count, :integer
end
create unique_index(:products, [:name, :brand], name: :unique_product)
end
end
So I'm basing the uniqueness on a field which would be in vegan_thing and a field which is only in product. Can I do something like this?
defmodule Api.Repo.Migrations.CreateProducts do
use Ecto.Migration
def change do
create table(:products) do
add :name, :string
add :vegan_thing, :vegan_thing
end
create unique_index(:products, [:vegan_thing.name, :brand], name: :unique_product)
end
end
Or do I have to put the name field directly in product? instead of vegan_thing to be able to use it as a unique constraint?

Answer 1

Macros can be used for this situation:
defmodule Vegan do
defmacro vegan_schema name, fields do
quote do
schema unquote(name) do
unquote(fields)
field :name, :string
field :description, :string
field :image, :string
field :rating, :integer
field :number_of_votes, :integer
field :not_vegan_count, :integer
end
end
end
def changeset(struct_or_changeset, params) do
struct_or_changeset
|> Ecto.Changeset.cast(params, [:name, :description, :rating])
|> Ecto.Changeset.validate_required([:name, :description])
end
end
defmodule Product do
use Ecto.Schema
require Vegan
#derive {Poison.Encoder, only: [:name, :brand, :description, :image, :rating, :number_of_votes]}
Vegan.vegan_schema "products" do
field :brand, :string
end
def changeset(params) do
%Product{}
|> Vegan.changeset(params)
|> Ecto.Changeset.cast(params, [:brand])
|> Ecto.Changeset.validate_required([:brand])
end
end
For other functions dealing with Ecto.Changeset, then regular modules and functions should be fine for factoring out any duplicated code, as shown in the example above where Product.changeset/1 calls Vegan.changeset/2 to cast and validate the common fields.