chore: clean node db hooks from mdw (#619)

Author: jyeshe

config/config.exs

@@ -27,8 +27,8 @@ config :ae_mdw, AeMdw.Db.RocksDb, data_dir: "#{node_root}/rel/aeternity/data/mdw
 
 config :ae_plugin,
   node_root: node_root,
-  "$aec_db_create_tables": {AeMdw.Db.Setup, :create_tables},
-  "$aec_db_check_tables": {AeMdw.Db.Setup, :check_tables}
+  "$aec_db_create_tables": {AeMdw.Db.NodeStub, :create_tables},
+  "$aec_db_check_tables": {AeMdw.Db.NodeStub, :check_tables}
 
 config :ae_mdw,
   sync: true,

lib/ae_mdw/application.ex

@@ -10,7 +10,6 @@ defmodule AeMdw.Application do
   """
   alias AeMdw.Contract
   alias AeMdw.Db.Model
-  alias AeMdw.Db.Stream, as: DbStream
   alias AeMdw.Db.Sync
   alias AeMdw.EtsCache
   alias AeMdw.Extract
@@ -29,7 +28,6 @@ defmodule AeMdw.Application do
     :lager.set_loglevel(:epoch_sync_lager_event, :lager_console_backend, :undefined, :error)
     :lager.set_loglevel(:lager_console_backend, :error)
 
-    init(:model_records)
     init(:node_records)
     init(:meta)
     init_public(:contract_cache)
@@ -74,9 +72,6 @@ defmodule AeMdw.Application do
   #   |> Enum.map(&:code.load_abs(to_charlist(Path.rootname(&1))))
   # end
 
-  defp init(:model_records),
-    do: Enum.each(Model.records(), &SmartRecord.new(Model, &1, Model.defaults(&1)))
-
   defp init(:node_records) do
     {:ok, aeo_oracles_code} = Extract.AbsCode.module(:aeo_oracles)
     {:ok, aeo_query_code} = Extract.AbsCode.module(:aeo_query)
@@ -143,14 +138,6 @@ defmodule AeMdw.Application do
 
     id_fields = id_field_type_map |> Map.keys() |> Enum.map(Util.compose(&to_string/1, &hd/1))
 
-    stream_mod = fn db_mod ->
-      ["AeMdw", "Db", "Model", tab] = Module.split(db_mod)
-      # credo:disable-for-next-line
-      Module.concat(DbStream, tab)
-    end
-
-    collect_stream_mod = fn t, acc -> put_in(acc[t], stream_mod.(t)) end
-
     tx_types = Map.keys(type_mod_map)
     tx_group = &("#{&1}" |> String.split("_") |> hd |> String.to_atom())
     tx_group_map = Enum.group_by(tx_types, tx_group)
@@ -196,7 +183,6 @@ defmodule AeMdw.Application do
         tx_types: [{[], MapSet.new(tx_types)}],
         tx_prefixes: [{[], MapSet.new(tx_types |> Enum.map(tx_prefix))}],
         id_prefixes: [{[], MapSet.new(Map.keys(id_prefix_type_map))}],
-        stream_mod: Enum.reduce(Model.tables(), %{}, collect_stream_mod),
         tx_group: tx_group_map,
         tx_groups: [{[], MapSet.new(Map.keys(tx_group_map))}],
         id_type: id_type_map,

lib/ae_mdw/db/model.ex

@@ -676,26 +676,4 @@ defmodule AeMdw.Db.Model do
   def record(AeMdw.Db.Model.TargetKindIntTransferTx), do: :target_kind_int_transfer_tx
   def record(AeMdw.Db.Model.DeltaStat), do: :delta_stat
   def record(AeMdw.Db.Model.TotalStat), do: :total_stat
-  def record(AeMdw.Db.Model.None), do: :none
-
-  #
-  # Stub for Node-Mdw database management
-  #
-  @none_defaults [index: 0, value: 0]
-  defrecord :none, @none_defaults
-
-  @spec tables() :: list(atom())
-  def tables(), do: [AeMdw.Db.Model.None]
-
-  @spec records() :: list(atom())
-  def records(), do: [:none]
-
-  @spec table(atom()) :: atom()
-  def table(:none), do: AeMdw.Db.Model.None
-
-  @spec fields(atom()) :: list(atom())
-  def fields(record), do: for({x, _} <- defaults(record), do: x)
-
-  @spec defaults(atom()) :: list()
-  def defaults(:none), do: @none_defaults
 end

lib/ae_mdw/db/setup.ex

@@ -1,71 +1,16 @@
-defmodule AeMdw.Db.Setup do
-  require AeMdw.Db.Model
-  alias AeMdw.Db.Model
+defmodule AeMdw.Db.NodeStub do
+  @moduledoc """
+  This is a stub needed only to satisify a Node plugin requirement (expected hooks/callbacks).
 
-  def create_tables(),
-    do: create_tables(mode())
+  It doesn't create any database table anymore as the Mdw now manages its own database.
+  """
 
-  def create_tables(mode),
-    do: missing_tables(mode) |> Enum.map(&create_table!/1)
+  @spec create_tables() :: []
+  def create_tables(), do: []
 
-  def handle_issues(xs),
-    do: xs |> Enum.map(&handle_issue(&1, mode()))
+  @spec create_tables(list()) :: []
+  def create_tables(_list), do: []
 
-  def delete_tables(),
-    do: Model.tables() |> delete_tables
-
-  def delete_tables(tables),
-    do: tables |> Enum.map(&{&1, :mnesia.delete_table(&1)})
-
-  def clear_tables(),
-    do: Model.tables() |> Enum.map(&:mnesia.clear_table/1)
-
-  def check_tables(acc) do
-    case check_tables() do
-      [] -> []
-      issues -> [{:callback, {__MODULE__, :handle_issues, [issues]}}]
-    end ++ acc
-  end
-
-  def tab_defs(mode),
-    do: Model.tables() |> Enum.map(&tab_def(&1, mode))
-
-  def tab_def(name, mode),
-    do: tab_def(name, :ordered_set, mode)
-
-  defp tab_def(table, type, mode) do
-    record = Model.record(table)
-
-    {table,
-     [
-       :aec_db.tab_copies(mode)
-       | [
-           type: type,
-           record_name: record,
-           attributes: Model.fields(record),
-           user_properties: [vsn: 1]
-         ]
-     ]}
-  end
-
-  defp check_table({name, definition}, acc),
-    do: :aec_db.check_table(name, definition, acc)
-
-  defp create_table!({name, definition}),
-    do: {name, {:atomic, :ok} = :mnesia.create_table(name, definition)}
-
-  defp handle_issue({:missing_table, name}, mode),
-    do: create_table!(tab_def(name, mode))
-
-  def missing_tables(),
-    do: missing_tables(mode())
-
-  def missing_tables(mode),
-    do: for({:missing_table, name} <- check_tables(), do: tab_def(name, mode))
-
-  def mode,
-    do: :aec_db.backend_mode()
-
-  def check_tables(),
-    do: tab_defs(mode()) |> Enum.reduce([], &check_table/2)
+  @spec check_tables(list()) :: []
+  def check_tables(_list), do: []
 end