Merge pull request #26 from renatomassaro/allow-enum-values-to-be-defined-as-a-function

Allow Enum values to be defined as a function

Author: renatomassaro

lib/feeb/db/type/enum.ex

@@ -9,13 +9,19 @@ defmodule Feeb.DB.Type.Enum do
   If a valid `format` is specified, keep as is. However, if one was not specified by the user, infer
   it based on the contents of the `values` entry. We assume all entries within `values` will share
   the same type (and we will crash otherwise).
+
+  We accept `values` being a function, as long as it is a function that returns a list. This might
+  be useful if the application wants to avoid transitive compile-time dependencies.
   """
+  def overwrite_opts(%{values: values_fn} = opts, mod, identifier) when is_function(values_fn),
+    do: overwrite_opts(%{opts | values: values_fn.()}, mod, identifier)
+
   def overwrite_opts(%{format: format} = opts, _, _) do
     true = format in [:atom, :safe_atom, :string]
     opts
   end
 
-  def overwrite_opts(%{values: values} = opts, _, identifier) do
+  def overwrite_opts(%{values: values} = opts, _, identifier) when is_list(values) do
     value_types =
       values
       |> Enum.map(fn value ->

priv/test/migrations/test/241020150400_all_types.sql

@@ -30,5 +30,6 @@ CREATE TABLE all_types (
   list_nullable TEXT,
   enum TEXT,
   enum_nullable TEXT,
-  enum_safe_atom TEXT
+  enum_safe_atom TEXT,
+  enum_fn TEXT
 ) STRICT;

test/db/schema_test.exs

@@ -59,7 +59,8 @@ defmodule DB.SchemaTest do
                :list_nullable,
                :enum,
                :enum_nullable,
-               :enum_safe_atom
+               :enum_safe_atom,
+               :enum_fn
              ] == AllTypes.__cols__()
     end
   end

test/db/type/enum_test.exs

@@ -7,21 +7,24 @@ defmodule Feeb.DB.Type.EnumTest do
 
   describe "enum type" do
     test "stores and loads correctly", %{shard_id: shard_id} do
-      params = AllTypes.creation_params(%{enum: :one, enum_nullable: "baz"})
+      params = AllTypes.creation_params(%{enum: :one, enum_nullable: "baz", enum_fn: :function})
 
       # Enums are correctly casted
       all_types = AllTypes.new(params)
       assert all_types.enum == :one
       assert all_types.enum_nullable == "baz"
+      assert all_types.enum_fn == :function
 
       # Enums are correctly dumped and loaded
       DB.begin(@context, shard_id, :write)
       assert {:ok, db_all_types} = DB.insert(all_types)
       assert db_all_types.enum == :one
       assert db_all_types.enum_nullable == "baz"
+      assert db_all_types.enum_fn == :function
 
       # Values are stored as text in the database
-      assert [["one", "baz"]] == DB.raw!("select enum, enum_nullable from all_types")
+      assert [["one", "baz", "function"]] ==
+               DB.raw!("select enum, enum_nullable, enum_fn from all_types")
     end
 
     test "crashes if input is not a possible enum value" do
@@ -228,5 +231,22 @@ defmodule Feeb.DB.Type.EnumTest do
 
       assert error =~ "Multiple types in enum"
     end
+
+    test "supports a function as value generator" do
+      atom_values_fn = fn -> [:a, :b, :c] end
+      str_values_fn = fn -> ["x", "y", "z"] end
+
+      opts = DB.Type.Enum.overwrite_opts(%{values: atom_values_fn, format: :safe_atom}, nil, nil)
+      assert opts.values == [:a, :b, :c]
+      assert opts.format == :safe_atom
+
+      opts = DB.Type.Enum.overwrite_opts(%{values: atom_values_fn}, nil, nil)
+      assert opts.values == [:a, :b, :c]
+      assert opts.format == :atom
+
+      opts = DB.Type.Enum.overwrite_opts(%{values: str_values_fn}, nil, nil)
+      assert opts.values == ["x", "y", "z"]
+      assert opts.format == :string
+    end
   end
 end

test/support/db/schemas/all_types.ex

@@ -36,6 +36,7 @@ defmodule Sample.AllTypes do
     {:enum, {:enum, values: [:one, :two, :three]}},
     {:enum_nullable, {:enum, values: ["foo", "bar", "baz"], nullable: true}},
     {:enum_safe_atom, {:enum, values: [:safe, :atom], format: :safe_atom, nullable: true}},
+    {:enum_fn, {:enum, values: fn -> [:from, :a, :function] end, nullable: true}},
     {:virtual, {:integer, virtual: true}},
     {:virtual_with_after_read, {:integer, virtual: true, after_read: :load_virtual_integer}}
   ]