diff --git a/README.md b/README.md
index 4ef930a..0d99952 100644
--- a/README.md
+++ b/README.md
@@ -1,59 +1,26 @@
 # alog
 alog (Append-only Log) is an easy way to start using the Lambda/Kappa architecture in your Elixir/Phoenix Apps while still using PostgreSQL (with Ecto).
 
-This module provides some helper functions to make it easy to insert and retrieve the data you need.
+This module is an Ecto Adapter that extends the default Postgres adapter with functionality to ensure data is only ever appended, never deleted or edited.
 
 ## Usage
 
-  At the top of the schema you wish to use append only functions for, `use` this module:
+ In your Repo module, when defining your Ecto Repo, set the adapter to be this module, Alog
 
-  ``` elixir
-  use Alog
-  ```
-
-  The append only functions will then be available to call as part of your schema.
-
-  ## Example
-
-  ``` elixir
-  defmodule MyApp.User do
-    use Ecto.Schema
-    use Alog
-
-    import Ecto.Changeset
-
-    schema "users" do
-      ...
-    end
-
-    def changeset(user, attrs) do
-      ...
-    end
+ ``` elixir
+  defmodule MyApp.Repo do
+    use Ecto.Repo,
+      otp_app: :my_app,
+      adapter: Alog
   end
-  ```
-
-  ## Repo
-
-  You can set the repo you want Alog to use in a config file:
-
-  ``` elixir
- config :alog, Alog,
-    repo: MyApp.Repo
-  ```
-  
-  If you do not explicitly set a Repo, Alog will try to find it using your application name.
-  So if your app is `MyApp` and your schema is `MyApp.User`, or `MyApp.Accounts.User`, your Repo should be `MyApp.Repo`.
-
-  ## Uniqueness
+ ```
 
-  Due to the append only manner in which Alog stores data, it is not compatible with tables that have Unique Indexes applied to any of their columns. If you wish to use alog, you will have to remove these indexes.
+## Considerations
 
-  For example, the following in a migration file would remove a unique index on the `email` column from the `users` table.
+- When inserting or updating an item, the return value of the insert/update function is currently incorrect. The updates and inserts are however done correctly, as you will see if you get all items from the database using `Repo.all`.
 
-  ```
-  drop(unique_index(:users, :email))
-  ```
+- We exclude the `schema_migrations` file from all alog functions, instead forwarding them on to the original Postgres Adapter.
 
-  See https://hexdocs.pm/ecto_sql/Ecto.Migration.html#content for more details.
+- The autogenerated cid is used as the primary key. There is no way currently to define a custom primary key.
 
-  If you want to ensure each entry in your database has a unique field, you can use the [`Ecto.Changeset.unique_constraint/3`](https://hexdocs.pm/ecto/Ecto.Changeset.html#unique_constraint/3) function as normal, and Alog will ensure there are no repeated fields, other than those of the same entry, returning an invalid changeset if there are.
\ No newline at end of file
+Hopefully these issues can later be resolved by looking at defining/extending our own version of the the `Ecto.Schema` macro.
\ No newline at end of file
diff --git a/config/test.exs b/config/test.exs
index 16720f2..cead70a 100644
--- a/config/test.exs
+++ b/config/test.exs
@@ -1,7 +1,6 @@
 use Mix.Config
 
 config :alog, Alog.Repo,
-  adapter: Ecto.Adapters.Postgres,
   username: "postgres",
   password: "postgres",
   database: "test_app_dev",
diff --git a/lib/alog.ex b/lib/alog.ex
index c967446..f46b3be 100644
--- a/lib/alog.ex
+++ b/lib/alog.ex
@@ -1,435 +1,151 @@
 defmodule Alog do
-  @moduledoc """
-  Behaviour that defines functions for accessing and inserting data in an
-  Append Only database.
+  use Ecto.Adapters.SQL,
+    driver: :postgrex,
+    migration_lock: "FOR UPDATE"
 
-  ## Usage
+  alias Ecto.Adapters.Postgres, as: EAP
 
-  At the top of the schema you wish to use append only functions for, `use` this module:
+  @behaviour Ecto.Adapter.Storage
+  @behaviour Ecto.Adapter.Schema
 
-      use Alog
+  @impl true
+  def supports_ddl_transaction?, do: true
 
-  The append only functions will then be available to call as part of your schema.
+  @impl true
+  defdelegate storage_up(opts), to: EAP
 
-  ## Example
+  @impl true
+  defdelegate storage_down(opts), to: EAP
 
-      defmodule MyApp.User do
-        use Ecto.Schema
-        use Alog
+  @impl true
+  defdelegate structure_dump(default, config), to: EAP
 
-        import Ecto.Changeset
+  @impl true
+  defdelegate structure_load(default, config), to: EAP
 
-        schema "users" do
-          ...
-        end
-
-        def changeset(user, attrs) do
-          ...
-        end
-      end
+  @impl true
+  def update(adapter_meta, %{source: source, prefix: prefix}, fields, params, returning, opts) do
+    cid = Keyword.get(params, :cid)
+    query = "SELECT * FROM #{source} where cid='#{cid}'"
+    {:ok, old} = Ecto.Adapters.SQL.query(adapter_meta, query, [])
 
-  You can set the repo you want Alog to use in a config file:
+    new_params =
+      Enum.with_index(old.columns)
+      |> Enum.map(fn {c, i} ->
+        case Keyword.get(fields, String.to_existing_atom(c)) do
+          _ when c == "cid" ->
+            nil
 
-      config :alog, Alog,
-        repo: MyApp.Repo
+          nil ->
+            {String.to_existing_atom(c), old.rows |> List.first() |> Enum.at(i)}
 
-  If you do not explicitly set a Repo, Alog will try to find it using your application name.
-  So if your app is `MyApp` and your schema is `MyApp.User`, or `MyApp.Accounts.User`, your Repo should be `MyApp.Repo`.
+          new ->
+            {String.to_existing_atom(c), new}
+        end
+      end)
+      |> Enum.filter(&(not is_nil(&1)))
+      |> Keyword.new()
+
+    insert(
+      adapter_meta,
+      %{source: source, prefix: prefix},
+      new_params,
+      {:raise, [], []},
+      returning,
+      opts
+    )
+  end
 
-  Any schema that uses Alog must include the fields `:deleted` of type `:boolean` and default false,
-  and `:entry_id` of type `:string`.
+  @impl true
+  def autogenerate(:binary_id), do: nil
+
+  @impl true
+  def loaders(:binary_id, type), do: [:binary, type]
+  def loaders(_primitive, type), do: [type]
+
+  @impl true
+  def dumpers(:binary_id, type), do: [:binary, type]
+  def dumpers(_primitive, type), do: [type]
+
+  # overrides insert/6 defined in Ecto.Adapters.SQL
+  def insert(
+        adapter_meta,
+        %{source: "schema_migrations", prefix: prefix},
+        params,
+        on_conflict,
+        returning,
+        opts
+      ) do
+    insert_logic(adapter_meta, "schema_migrations", prefix, params, on_conflict, returning, opts)
+  end
 
-        field(:deleted, :boolean, default: false)
-        field(:entry_id, :string)
-  """
+  def insert(
+        adapter_meta,
+        %{source: source, prefix: prefix},
+        params,
+        on_conflict,
+        returning,
+        opts
+      ) do
+    # converts params from a keyword list to a map
+    params_map = Enum.into(params, %{})
+
+    # removes inserted_at and updated_at from map (will not error if keys are not in map)
+    map_for_cid = Map.drop(params_map, [:inserted_at, :updated_at])
+
+    # creates a cid from the map witout the inserted_at and updated_at_values
+    cid = Cid.cid(map_for_cid)
+
+    # creates a unique entry_id for the data based on the CID generated
+    entry_id = create_entry_id(source, adapter_meta, cid, 2)
+
+    # updates params to ensure that timestamps, cid, and entry_id are all added.
+    # then converts the map back into a list for use in existing functionality (original format)
+    params =
+      map_for_cid
+      |> add_timestamps()
+      |> Map.put(:cid, cid)
+      |> Map.put(:entry_id, entry_id)
+      |> Enum.into([])
+
+    insert_logic(adapter_meta, source, prefix, params, on_conflict, returning, opts)
+  end
 
-  @callback insert(Ecto.Schema.t() | Ecto.Changeset.t()) ::
-              {:ok, Ecto.Schema.t()} | {:error, Ecto.Changeset.t()}
-  @callback get(String.t()) :: Ecto.Schema.t() | nil | no_return()
-  @callback get_by(Keyword.t() | map(), Keyword.t()) :: Ecto.Schema.t() | nil | no_return()
-  @callback update(Ecto.Changeset.t()) :: {:ok, Ecto.Schema.t()} | {:error, Ecto.Changeset.t()}
-  @callback get_history(Ecto.Schema.t()) :: [Ecto.Schema.t()] | no_return()
-  @callback delete(Ecto.Schema.t() | Ecto.Changeset.t()) ::
-              {:ok, Ecto.Schema.t()} | {:error, Ecto.Changeset.t()}
-  @callback preload(Ecto.Schema.t() | list(Ecto.Schema.t()), atom() | list()) ::
-              Ecto.Schema.t() | list(Ecto.Schema.t())
+  defp create_entry_id(source, adapter_meta, cid, n) do
+    entry_id = String.slice(cid, 0..n)
+    entry_id_query = "SELECT * FROM #{source} where entry_id='#{entry_id}'"
+    {:ok, results} = Ecto.Adapters.SQL.query(adapter_meta, entry_id_query, [])
 
-  defmacro __using__(_opts) do
-    quote location: :keep do
-      @behaviour Alog
-      @before_compile unquote(__MODULE__)
+    if results.num_rows == 0 do
+      entry_id
+    else
+      create_entry_id(source, adapter_meta, cid, n + 1)
     end
   end
 
-  defmacro __before_compile__(_env) do
-    quote generated: true, location: :keep do
-      import Ecto.Query
-      import Ecto.Query.API, only: [field: 2]
-
-      @repo apply(unquote(__MODULE__), :get_repo, [__MODULE__])
-
-      if not Map.has_key?(%__MODULE__{}, :deleted) || not is_boolean(%__MODULE__{}.deleted) do
-        raise """
-
-        Your Schema must have a key :deleted, with type :boolean and default false.
-
-        Add the following line to your schema:
-
-            field(:deleted, :boolean, default: false)
-        """
-      end
-
-      if not Map.has_key?(%__MODULE__{}, :entry_id) do
-        raise """
-
-        Your Schema must have a key :entry_id, with type :string
-
-        Add the following line to your schema:
-
-            field(:entry_id, :string)
-        """
-      end
-
-      @doc """
-      Inserts a struct made with a schema or a changeset into the database.
-      Adds an entry id to link it to future updates of the item.
-
-      If `cast_assoc` has been used on the changeset before passing it to this function,
-      any nested associations will also be given an `entry_id` before they are
-      inserted into the database.
-
-          %User{name: "username", age: "25"}
-          |> User.insert()
-
-          %User{}
-          |> User.changeset(%{name: "username", age: "25"})
-          |> User.insert()
-      """
-      def insert(struct_or_changeset) do
-        case check_for_unique_index() do
-          :ok ->
-            struct_or_changeset
-            |> insert_entry_id()
-            |> apply_constraints()
-            |> @repo.insert()
-
-          {:error, msg} ->
-            raise msg
-        end
-      end
-
-      @doc """
-      Gets the item from the database that matches the given entry id.
-      Gets the most recently inserted item if it is not marked as deleted.
-
-          User.get("5ds4fg31-a7f1-2hd8-x56a-d4s3g7ded1vv2")
-      """
-      def get(entry_id) do
-        sub =
-          from(
-            m in __MODULE__,
-            where: m.entry_id == ^entry_id,
-            order_by: [desc: :updated_at],
-            limit: 1,
-            select: m
-          )
-
-        query = from(m in subquery(sub), where: not m.deleted, select: m)
-
-        item = @repo.one(query)
-      end
-
-      @doc """
-      Gets an item from the database that matches the given clause.
-
-          User.get_by(username: "admin")
-          User.get_by(first_name: "Charlie", age: 27)
-
-      ## Options
-
-          - :case_insensitive (boolean) - whether your query should be case insensitive. Defaults to `false`.
-
-      If using the `:case_insensitive` option, you should consider adding a lowercase index to your table,
-      as it will significantly increase the query speed. For example:
-
-          `create index("users", ["(lower(first_name))"], first_name: :users_lower_first_name_index)`
-
-      See https://hexdocs.pm/ecto_sql/Ecto.Migration.html#index/3 for more details.
-
-      If passing options, make sure your clauses are wrapped in square brackets, or passed as a map:
-
-          User.get([first_name: "charlie"], case_insensitive: true)
-          User.get(%{first_name: "charlie"}, case_insensitive: true)
-      """
-      def get_by(clauses, opts \\ []) do
-        sub =
-          __MODULE__
-          |> (fn q ->
-                Enum.reduce(clauses, q, fn {key, value}, q ->
-                  case Keyword.get(opts, :case_insensitive) do
-                    true ->
-                      q
-                      |> where(
-                        [m],
-                        fragment("lower(?)", field(m, ^key)) == ^String.downcase(value)
-                      )
-
-                    _ ->
-                      q |> where([m], field(m, ^key) == ^value)
-                  end
-                end)
-              end).()
-          |> order_by([m], desc: m.updated_at)
-          |> distinct([m], m.entry_id)
-          |> select([m], m)
-
-        query = from(m in subquery(sub), where: not m.deleted, select: m)
-
-        query
-        |> @repo.all
-        |> Enum.filter(fn item -> item && __MODULE__.get(item.entry_id) == item end)
-        |> List.last()
-      end
-
-      @doc """
-      Updates an item in the database.
-      Copies the current row, updates the relevant fields and appends
-      it to the database table.
-      Requires a changeset to be given.
-
-          User.get("5ds4fg31-a7f1-2hd8-x56a-d4s3g7ded1vv2")
-          |> User.changeset(%{age: 44})
-          |> User.update()
-      """
-      def update(%Ecto.Changeset{} = changeset) do
-        case check_for_unique_index() do
-          :ok ->
-            data =
-              changeset
-              |> Map.get(:data)
-              |> @repo.preload(__MODULE__.__schema__(:associations))
-              |> Map.put(:id, nil)
-              |> Map.put(:updated_at, nil)
-
-            changeset
-            |> apply_constraints()
-            |> Map.put(:data, data)
-            |> @repo.insert()
-
-          {:error, msg} ->
-            raise msg
-        end
-      end
-
-      def update(_) do
-        raise ArgumentError, "The argument provided to update/1 must be an Ecto.Changeset"
-      end
-
-      @doc """
-      Gets the full history of an item in the database.
-
-          User.get("5ds4fg31-a7f1-2hd8-x56a-d4s3g7ded1vv2")
-          |> User.get_history()
-      """
-      def get_history(%__MODULE__{} = item) do
-        query =
-          from(m in __MODULE__,
-            where: m.entry_id == ^item.entry_id,
-            select: m
-          )
-
-        @repo.all(query)
-      end
-
-      @doc """
-      Gets all of the distinct instances of a schema that have not been deleted.
-
-          User.all()
-      """
-      def all do
-        sub =
-          from(m in __MODULE__,
-            distinct: m.entry_id,
-            order_by: [desc: :updated_at],
-            select: m
-          )
-
-        query = from(m in subquery(sub), where: not m.deleted, select: m)
-
-        @repo.all(query)
-      end
-
-      @doc """
-      Marks an item as deleted in the database.
-      Deleted items will not show up in queries.
-
-          User.get("5ds4fg31-a7f1-2hd8-x56a-d4s3g7ded1vv2")
-          |> User.delete()
-
-          User.get("5ds4fg31-a7f1-2hd8-x56a-d4s3g7ded1vv2")
-          |> User.changeset(%{})
-          |> User.delete()
-      """
-      def delete(%Ecto.Changeset{} = changeset) do
-        changeset
-        |> Ecto.Changeset.put_change(:deleted, true)
-        |> update()
-      end
-
-      def delete(%__MODULE__{} = entry) do
-        entry
-        |> Ecto.Changeset.cast(%{deleted: true}, [:deleted])
-        |> update()
-      end
-
-      @doc """
-      Preloads an item's (or list of items') multiple associations.
-      Also preloads any nested associations.
-
-          # Load all of a user's friends and comments
-          User.get("5ds4fg31-a7f1-2hd8-x56a-d4s3g7ded1vv2")
-          |> User.preload([:friends, :comments])
-
-          # Load all of a user's friends, and all of their friends' comments
-          User.get("5ds4fg31-a7f1-2hd8-x56a-d4s3g7ded1vv2")
-          |> User.preload([friends: [:comments]])
-      """
-      def preload(item, assocs) when is_list(assocs) do
-        @repo.preload(
-          item,
-          Enum.map(assocs, fn a ->
-            preload_map(a, __MODULE__)
-          end)
-        )
-      end
-
-      @doc """
-      Preloads an item's (or list of items') association.
-
-          User.get("5ds4fg31-a7f1-2hd8-x56a-d4s3g7ded1vv2")
-          |> User.preload(:friends)
-      """
-      def preload(item, assoc) do
-        @repo.preload(item, [{assoc, preload_query(assoc)}])
-      end
-
-      defp apply_constraints(%Ecto.Changeset{} = changeset) do
-        changeset
-        |> Map.get(:constraints)
-        |> Enum.reduce(changeset, fn con, acc ->
-          with :unique <- con.type,
-               change when not is_nil(change) <- Map.get(changeset.changes, con.field),
-               existing when not is_nil(existing) <- __MODULE__.get_by([{con.field, change}]) do
-            Ecto.Changeset.add_error(acc, con.field, Map.get(con, :error) |> elem(0))
-          else
-            _ -> acc
-          end
-        end)
-      end
-
-      defp apply_constraints(struct), do: struct
-
-      defp preload_map(assoc, owner) do
-        case assoc do
-          {k, v} ->
-            assoc_module = owner.__schema__(:association, k).queryable
-            {k, {preload_query(k, owner), Enum.map(v, fn a -> preload_map(a, assoc_module) end)}}
-
-          k ->
-            {k, preload_query(k, owner)}
-        end
-      end
-
-      @doc false
-      def preload_query(assoc, module \\ __MODULE__) do
-        sub =
-          from(mod in Map.get(module.__schema__(:association, assoc), :queryable),
-            distinct: mod.entry_id,
-            order_by: [desc: :updated_at],
-            select: mod
-          )
-
-        from(m in subquery(sub), where: not m.deleted, select: m)
-      end
-
-      defp insert_entry_id(%Ecto.Changeset{} = entry) do
-        with {:ok, nil} <- Map.fetch(entry.data, :entry_id),
-             nil <- get_change(entry, :entry_id) do
-          entry
-          |> put_change(:entry_id, Ecto.UUID.generate())
-          |> insert_nested_entry_ids()
-        else
-          _ ->
-            entry
-        end
-      end
-
-      defp insert_entry_id(%__MODULE__{} = entry) do
-        case Map.fetch(entry, :entry_id) do
-          {:ok, nil} -> %{entry | entry_id: Ecto.UUID.generate()}
-          _ -> entry
-        end
-      end
-
-      defp insert_nested_entry_ids(changeset) do
-        assocs = changeset.data.__struct__.__schema__(:associations)
-
-        Enum.reduce(changeset.changes, changeset, fn {k, v}, acc ->
-          if k in assocs do
-            assoc =
-              case v do
-                l when is_list(l) -> Enum.map(l, &insert_entry_id/1)
-                item -> insert_entry_id(item)
-              end
-
-            Ecto.Changeset.put_change(acc, k, assoc)
-          else
-            acc
-          end
-        end)
-      end
-
-      defp check_for_unique_index() do
-        table = __MODULE__.__schema__(:source)
-        "Elixir." <> module_name = unquote(__MODULE__) |> to_string()
-
-        case @repo.query(
-               "SELECT * FROM pg_indexes WHERE tablename = $1 and indexname NOT LIKE '%_pkey' AND indexdef LIKE 'CREATE UNIQUE INDEX%';",
-               [table]
-             ) do
-          {:ok, %Postgrex.Result{columns: columns, rows: rows}} when rows != [] ->
-            unique_index =
-              rows
-              |> List.first()
-              |> Enum.zip(columns)
-              |> Enum.find(fn {_r, c} -> c == "indexname" end)
-              |> elem(0)
-
-            {:error,
-             """
-               Unique index '#{unique_index}' found on table '#{table}'.
-               #{module_name} is not compatible with tables that have a unique index.
-               Please remove this index if you want to use #{module_name}.
-             """}
-
-          _ ->
-            :ok
-        end
-      end
-
-      defoverridable Alog
-    end
+  defp add_timestamps(params) do
+    params
+    |> Enum.into(%{})
+    |> Map.put_new(:inserted_at, NaiveDateTime.utc_now())
+    |> Map.put_new(:updated_at, NaiveDateTime.utc_now())
   end
 
-  def get_repo(module) do
-    with config when not is_nil(config) <- Application.get_env(:alog, Alog),
-         repo when not is_nil(repo) <- Keyword.get(config, :repo) do
-    else
-      _ ->
-        module
-        |> Module.split()
-        |> List.first()
-        |> Module.concat("Repo")
-    end
+  defp insert_logic(adapter_meta, source, prefix, params, on_conflict, returning, opts) do
+    {kind, conflict_params, _} = on_conflict
+    {fields, values} = :lists.unzip(params)
+    sql = Alog.Connection.insert(prefix, source, fields, [fields], on_conflict, returning)
+
+    Ecto.Adapters.SQL.struct(
+      adapter_meta,
+      Alog.Connection,
+      sql,
+      :insert,
+      source,
+      [],
+      values ++ conflict_params,
+      kind,
+      returning,
+      opts
+    )
   end
 end
diff --git a/lib/alog/connection.ex b/lib/alog/connection.ex
new file mode 100644
index 0000000..2fc173b
--- /dev/null
+++ b/lib/alog/connection.ex
@@ -0,0 +1,177 @@
+defmodule Alog.Connection do
+  alias Ecto.Adapters.Postgres.Connection, as: EAPC
+
+  @behaviour Ecto.Adapters.SQL.Connection
+  @default_port 5432
+
+  @impl true
+  def child_spec(opts) do
+    opts
+    |> Keyword.put_new(:port, @default_port)
+    |> Postgrex.child_spec()
+  end
+
+  @impl true
+  defdelegate prepare_execute(conn, name, statement, params, opts), to: EAPC
+
+  @impl true
+  defdelegate execute(conn, query, params, opts), to: EAPC
+
+  @impl true
+  defdelegate query(conn, statement, params, opts), to: EAPC
+
+  @impl true
+  defdelegate stream(conn, statement, params, opts), to: EAPC
+
+  @impl true
+  defdelegate to_constraints(error_struct), to: EAPC
+
+  @impl true
+  defdelegate ddl_logs(result), to: EAPC
+
+  @impl true
+  def all(query) do
+    iodata_query =  EAPC.all(query)
+
+    query = iodata_query
+    |> IO.iodata_to_binary()
+    |> alogify_all_query()
+
+    query
+  end
+
+  defp alogify_all_query(query) do
+    query_data = get_query_data(query)
+    # if all query is called during migration, some column used in the
+    # alogify version might not be yet defined.
+    # Return the "normal" query
+    if (query_data["table_name"] == "\"schema_migrations\"") do
+      query
+    else
+      subquery = IO.iodata_to_binary(
+                  [ "SELECT DISTINCT ON (#{query_data["table_as"]}.\"entry_id\" ) ",
+                    query_data["subquery_fields"],
+                    get_deleted_field(query_data),
+                    " FROM ",
+                    query_data["table_name"], " AS ", query_data["table_as"],
+                    query_data["rest_query"],
+                    " ORDER BY #{query_data["table_as"]}.\"entry_id\", #{query_data["table_as"]}.\"inserted_at\" DESC"
+                ]
+              )
+
+      IO.iodata_to_binary(
+        ["SELECT ", query_data["field_names"], " FROM (", subquery, ") AS alogsubquery WHERE (NOT alogsubquery.\"deleted\")"]
+      )
+    end
+  end
+
+  defp get_query_data(query) do
+    data = Regex.named_captures(~r/(\bSELECT\b)\s(?<fields>.*)\sFROM\s(?<table_name>.*)\sas\s(?<table_as>.*)(?<rest_query>.*)/i, query)
+    data = Map.put(data, "field_names", Regex.replace(~r/#{data["table_as"]}/, data["fields"], "alogsubquery"))
+
+    subquery_fields = data["fields"]
+      |> String.split(",")
+      |> Enum.map(fn f ->
+        field_name = Regex.replace(~r/#{data["table_as"]}./, f, "")
+        f <> " AS #{field_name}"
+      end)
+      |> Enum.join(", ")
+
+    Map.put(data, "subquery_fields", subquery_fields)
+  end
+
+  defp get_deleted_field(query_data) do
+    if String.contains?(query_data["subquery_fields"], "#{query_data["table_as"]}.\"deleted\"") do
+      ""
+    else
+      ", #{query_data["table_as"]}.\"deleted\" AS \"deleted\""
+    end
+  end
+
+  @impl true
+  def execute_ddl({c, %Ecto.Migration.Table{} = table, columns})
+      when c in [:create, :create_if_not_exists] do
+    # TODO: need to determine if migration_source has been set in config
+    # else name is :schema_migrations
+    with name when name != :schema_migrations <- Map.get(table, :name),
+         true <-
+           Enum.any?(
+             columns,
+             fn
+               {:add, field, _type, [primary_key: true]} when field != :cid -> true
+               _ -> false
+             end
+           ) do
+      raise ArgumentError, "you cannot add a primary key"
+    else
+      :schema_migrations ->
+        EAPC.execute_ddl({c, table, columns})
+
+      _ ->
+        EAPC.execute_ddl({c, table, update_columns(columns)})
+    end
+  end
+
+  def execute_ddl({:alter, %Ecto.Migration.Table{}, changes} = command) do
+    with :ok <-
+           Enum.each(
+             changes,
+             fn
+               {:remove, :cid, _, _} ->
+                 raise ArgumentError, "you cannot remove cid"
+
+               {_, _, _, [primary_key: true]} ->
+                 raise ArgumentError, "you cannot add a primary key"
+
+               _ ->
+                 nil
+             end
+           ) do
+      EAPC.execute_ddl(command)
+    end
+  end
+
+  def execute_ddl({c, %Ecto.Migration.Index{unique: true}})
+      when c in [:create, :create_if_not_exists] do
+    raise ArgumentError, "you cannot create a unique index"
+  end
+
+  defdelegate execute_ddl(command), to: EAPC
+
+  # Add required columns if they are missing
+  defp update_columns(columns) do
+    [
+      {:add, :cid, :binary, [primary_key: true]},
+      {:add, :entry_id, :string, [null: false]},
+      {:add, :deleted, :boolean, [default: false]},
+      {:add, :inserted_at, :naive_datetime_usec, [null: false]},
+      {:add, :updated_at, :naive_datetime_usec, [null: false]}
+    ]
+    |> Enum.reduce(columns, fn {_, c, _, _} = col, acc ->
+      case Enum.find(acc, fn {_, a, _, _} -> a == c end) do
+        nil -> acc ++ [col]
+        _ -> acc
+      end
+    end)
+  end
+
+  # Temporary delegate functions to make tests work
+
+  @impl true
+  defdelegate all(query), to: EAPC
+
+  @impl true
+  defdelegate insert(prefix, table, header, rows, on_conflict, returning), to: EAPC
+
+  @impl true
+  defdelegate delete_all(query), to: EAPC
+
+  @impl true
+  defdelegate update(prefix, table, fields, filters, returning), to: EAPC
+
+  @impl true
+  defdelegate delete(prefix, table, filters, returning), to: EAPC
+
+  @impl true
+  defdelegate update_all(query, prefix \\ nil), to: EAPC
+end
diff --git a/mix.exs b/mix.exs
index a6e7b9e..f0d0dd9 100644
--- a/mix.exs
+++ b/mix.exs
@@ -27,8 +27,9 @@ defmodule Alog.MixProject do
   # Run "mix help deps" to learn about dependencies.
   defp deps do
     [
-      {:ecto, "~> 2.2.10"},
-      {:postgrex, ">= 0.0.0"}
+      {:ecto_sql, "~> 3.0.5"},
+      {:postgrex, ">= 0.0.0"},
+      {:excid, "~> 0.1.0"}
     ]
   end
 end
diff --git a/mix.lock b/mix.lock
index 7f16fd1..5afdc29 100644
--- a/mix.lock
+++ b/mix.lock
@@ -1,8 +1,13 @@
 %{
+  "b58": {:hex, :b58, "0.1.1", "950563b90ad95be214143aa807d16c98d2ac7bab915097cb1461c936128c6b90", [:mix], [], "hexpm"},
   "connection": {:hex, :connection, "1.0.4", "a1cae72211f0eef17705aaededacac3eb30e6625b04a6117c1b2db6ace7d5976", [:mix], [], "hexpm"},
-  "db_connection": {:hex, :db_connection, "1.1.3", "89b30ca1ef0a3b469b1c779579590688561d586694a3ce8792985d4d7e575a61", [:mix], [{:connection, "~> 1.0.2", [hex: :connection, repo: "hexpm", optional: false]}, {:poolboy, "~> 1.5", [hex: :poolboy, repo: "hexpm", optional: true]}, {:sbroker, "~> 1.0", [hex: :sbroker, repo: "hexpm", optional: true]}], "hexpm"},
+  "db_connection": {:hex, :db_connection, "2.0.5", "ddb2ba6761a08b2bb9ca0e7d260e8f4dd39067426d835c24491a321b7f92a4da", [:mix], [{:connection, "~> 1.0.2", [hex: :connection, repo: "hexpm", optional: false]}], "hexpm"},
   "decimal": {:hex, :decimal, "1.6.0", "bfd84d90ff966e1f5d4370bdd3943432d8f65f07d3bab48001aebd7030590dcc", [:mix], [], "hexpm"},
-  "ecto": {:hex, :ecto, "2.2.11", "4bb8f11718b72ba97a2696f65d247a379e739a0ecabf6a13ad1face79844791c", [:mix], [{:db_connection, "~> 1.1", [hex: :db_connection, repo: "hexpm", optional: true]}, {:decimal, "~> 1.2", [hex: :decimal, repo: "hexpm", optional: false]}, {:mariaex, "~> 0.8.0", [hex: :mariaex, repo: "hexpm", optional: true]}, {:poison, "~> 2.2 or ~> 3.0", [hex: :poison, repo: "hexpm", optional: true]}, {:poolboy, "~> 1.5", [hex: :poolboy, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.13.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:sbroker, "~> 1.0", [hex: :sbroker, repo: "hexpm", optional: true]}], "hexpm"},
-  "poolboy": {:hex, :poolboy, "1.5.1", "6b46163901cfd0a1b43d692657ed9d7e599853b3b21b95ae5ae0a777cf9b6ca8", [:rebar], [], "hexpm"},
-  "postgrex": {:hex, :postgrex, "0.13.5", "3d931aba29363e1443da167a4b12f06dcd171103c424de15e5f3fc2ba3e6d9c5", [:mix], [{:connection, "~> 1.0", [hex: :connection, repo: "hexpm", optional: false]}, {:db_connection, "~> 1.1", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.0", [hex: :decimal, repo: "hexpm", optional: false]}], "hexpm"},
+  "ecto": {:hex, :ecto, "3.0.7", "44dda84ac6b17bbbdeb8ac5dfef08b7da253b37a453c34ab1a98de7f7e5fec7f", [:mix], [{:decimal, "~> 1.6", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:poison, "~> 2.2 or ~> 3.0", [hex: :poison, repo: "hexpm", optional: true]}], "hexpm"},
+  "ecto_sql": {:hex, :ecto_sql, "3.0.5", "7e44172b4f7aca4469f38d7f6a3da394dbf43a1bcf0ca975e958cb957becd74e", [:mix], [{:db_connection, "~> 2.0", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.0.6", [hex: :ecto, repo: "hexpm", optional: false]}, {:mariaex, "~> 0.9.1", [hex: :mariaex, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.14.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.3.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm"},
+  "ex_multihash": {:hex, :ex_multihash, "2.0.0", "7fb36f842a2ec1c6bbba550f28fcd16d3c62981781b9466c9c1975c43d7db43c", [:mix], [], "hexpm"},
+  "excid": {:hex, :excid, "0.1.0", "85fd8ac6466660bc8c4c0b52275e7a255389c683a18f70aaed8cd2ac7735cfab", [:mix], [{:b58, "~> 0.1.1", [hex: :b58, repo: "hexpm", optional: false]}, {:ex_multihash, "~> 2.0", [hex: :ex_multihash, repo: "hexpm", optional: false]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm"},
+  "jason": {:hex, :jason, "1.1.2", "b03dedea67a99223a2eaf9f1264ce37154564de899fd3d8b9a21b1a6fd64afe7", [:mix], [{:decimal, "~> 1.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm"},
+  "postgrex": {:hex, :postgrex, "0.14.1", "63247d4a5ad6b9de57a0bac5d807e1c32d41e39c04b8a4156a26c63bcd8a2e49", [:mix], [{:connection, "~> 1.0", [hex: :connection, repo: "hexpm", optional: false]}, {:db_connection, "~> 2.0", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm"},
+  "telemetry": {:hex, :telemetry, "0.3.0", "099a7f3ce31e4780f971b4630a3c22ec66d22208bc090fe33a2a3a6a67754a73", [:rebar3], [], "hexpm"},
 }
diff --git a/priv/repo/test_app/migrations/20181015145631_create_users.exs b/priv/repo/test_app/migrations/20181015145631_create_users.exs
deleted file mode 100644
index 40a7103..0000000
--- a/priv/repo/test_app/migrations/20181015145631_create_users.exs
+++ /dev/null
@@ -1,15 +0,0 @@
-defmodule Alog.Repo.Migrations.CreateUsers do
-  use Ecto.Migration
-
-  def change do
-    create table(:users) do
-      add(:name, :string)
-      add(:username, :string)
-      add(:postcode, :string)
-      add(:entry_id, :string)
-      add(:deleted, :boolean, default: false)
-
-      timestamps()
-    end
-  end
-end
diff --git a/priv/repo/test_app/migrations/20181026080544_create_items.exs b/priv/repo/test_app/migrations/20181026080544_create_items.exs
deleted file mode 100644
index 3bc37ae..0000000
--- a/priv/repo/test_app/migrations/20181026080544_create_items.exs
+++ /dev/null
@@ -1,28 +0,0 @@
-defmodule Alog.Repo.Migrations.CreateItems do
-  use Ecto.Migration
-
-  def change do
-    create table(:items) do
-      add(:name, :string)
-      add(:entry_id, :string)
-      add(:deleted, :boolean, default: false)
-      add(:owner, references(:users))
-
-      timestamps()
-    end
-
-    create table(:item_types) do
-      add(:type, :string)
-      add(:entry_id, :string)
-      add(:deleted, :boolean, default: false)
-
-      timestamps()
-    end
-
-    create table(:items_item_types, primary_key: false) do
-      add(:item_id, references(:items, on_delete: :delete_all, column: :id, type: :id))
-
-      add(:item_type_id, references(:item_types, on_delete: :delete_all, column: :id, type: :id))
-    end
-  end
-end
diff --git a/priv/repo/test_app/migrations/20181211161000_unique_index.exs b/priv/repo/test_app/migrations/20181211161000_unique_index.exs
deleted file mode 100644
index d43eb85..0000000
--- a/priv/repo/test_app/migrations/20181211161000_unique_index.exs
+++ /dev/null
@@ -1,15 +0,0 @@
-defmodule Alog.Repo.Migrations.UniqueIndex do
-  use Ecto.Migration
-
-  def change do
-    create table(:unique) do
-      add(:name, :string)
-      add(:entry_id, :string)
-      add(:deleted, :boolean, default: false)
-
-      timestamps()
-    end
-
-    create(unique_index(:unique, :name))
-  end
-end
diff --git a/priv/repo/test_app/migrations/20190301105228_create_comments.exs b/priv/repo/test_app/migrations/20190301105228_create_comments.exs
new file mode 100644
index 0000000..002816b
--- /dev/null
+++ b/priv/repo/test_app/migrations/20190301105228_create_comments.exs
@@ -0,0 +1,14 @@
+defmodule Alog.Repo.Migrations.CreateComments do
+  use Ecto.Migration
+
+  def change do
+    create table(:comments, primary_key: false) do
+      add(:cid, :string, primary_key: true)
+      add(:entry_id, :string)
+      add(:deleted, :boolean, default: false)
+      add(:comment, :string)
+
+      timestamps()
+    end
+  end
+end
diff --git a/test/all_test.exs b/test/all_test.exs
index 64b834a..cb8c043 100644
--- a/test/all_test.exs
+++ b/test/all_test.exs
@@ -1,31 +1,14 @@
 defmodule AlogTest.AllTest do
   use Alog.TestApp.DataCase
 
-  alias Alog.TestApp.{User, Helpers}
+  alias Alog.TestApp.{Comment}
 
   describe "all/0:" do
     test "succeeds" do
-      {:ok, _} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      {:ok, _} = %User{} |> User.changeset(Helpers.user_2_params()) |> User.insert()
+      {:ok, _comment} = %Comment{comment: "Hello Rob"}  |> Repo.insert()
+      {:ok, _} = %Comment{comment: "Hello Dan"} |> Repo.insert()
 
-      assert length(User.all()) == 2
-    end
-
-    test "does not include old items" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      {:ok, _} = %User{} |> User.changeset(Helpers.user_2_params()) |> User.insert()
-      {:ok, _} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
-
-      assert length(User.all()) == 2
-    end
-
-    test "all return inserted_at original value" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_3_params()) |> User.insert()
-      {:ok, user_updated} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
-
-      [user_all] = User.all()
-      assert user_all.inserted_at == user.inserted_at
-      assert user_all.postcode == user_updated.postcode
+      assert length(Repo.all(Comment)) == 2
     end
   end
 end
diff --git a/test/alog_test.exs b/test/alog_test.exs
index 1aa302b..fc14ecb 100644
--- a/test/alog_test.exs
+++ b/test/alog_test.exs
@@ -1,74 +1,74 @@
 defmodule AlogTest do
-  use Alog.TestApp.DataCase
-  doctest Alog
-
-  describe "required fields" do
-    test "schema without delete field raises error" do
-      assert_raise RuntimeError, fn ->
-        defmodule NoDeleteSchema do
-          use Ecto.Schema
-          use Alog
-
-          schema "bad_schema" do
-            field(:entry_id, :string)
-            timestamps()
-          end
-        end
-      end
-    end
-
-    test "schema without entry_id field raises error" do
-      assert_raise RuntimeError, fn ->
-        defmodule NoEntrySchema do
-          use Ecto.Schema
-          use Alog
-
-          schema "bad_schema" do
-            field(:deleted, :boolean, default: false)
-            timestamps()
-          end
-        end
-      end
-    end
-
-    test "schema with deleted field of wrong type raises error" do
-      assert_raise RuntimeError, fn ->
-        defmodule BadDeletedSchema do
-          use Ecto.Schema
-          use Alog
-
-          schema "bad_schema" do
-            field(:entry_id, :string)
-            field(:deleted, :string)
-            timestamps()
-          end
-        end
-      end
-    end
-
-    test "both required fields do not raise error" do
-      assert (fn ->
-                defmodule GoodSchema do
-                  use Ecto.Schema
-                  use Alog
-
-                  schema "bad_schema" do
-                    field(:entry_id, :string)
-                    field(:deleted, :boolean, default: false)
-                    timestamps()
-                  end
-                end
-              end).()
-    end
-  end
-
-  describe "Not compatible with unique index" do
-    test "Throws error if unique index exists" do
-      assert_raise RuntimeError, fn ->
-        %Alog.TestApp.Unique{}
-        |> Alog.TestApp.Unique.changeset(%{name: "unique item"})
-        |> Alog.TestApp.Unique.insert()
-      end
-    end
-  end
+  # use Alog.TestApp.DataCase
+  # doctest Alog
+  #
+  # describe "required fields" do
+  #   test "schema without delete field raises error" do
+  #     assert_raise RuntimeError, fn ->
+  #       defmodule NoDeleteSchema do
+  #         use Ecto.Schema
+  #         use Alog
+  #
+  #         schema "bad_schema" do
+  #           field(:entry_id, :string)
+  #           timestamps()
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  #   test "schema without entry_id field raises error" do
+  #     assert_raise RuntimeError, fn ->
+  #       defmodule NoEntrySchema do
+  #         use Ecto.Schema
+  #         use Alog
+  #
+  #         schema "bad_schema" do
+  #           field(:deleted, :boolean, default: false)
+  #           timestamps()
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  #   test "schema with deleted field of wrong type raises error" do
+  #     assert_raise RuntimeError, fn ->
+  #       defmodule BadDeletedSchema do
+  #         use Ecto.Schema
+  #         use Alog
+  #
+  #         schema "bad_schema" do
+  #           field(:entry_id, :string)
+  #           field(:deleted, :string)
+  #           timestamps()
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  #   test "both required fields do not raise error" do
+  #     assert (fn ->
+  #               defmodule GoodSchema do
+  #                 use Ecto.Schema
+  #                 use Alog
+  #
+  #                 schema "bad_schema" do
+  #                   field(:entry_id, :string)
+  #                   field(:deleted, :boolean, default: false)
+  #                   timestamps()
+  #                 end
+  #               end
+  #             end).()
+  #   end
+  # end
+  #
+  # describe "Not compatible with unique index" do
+  #   test "Throws error if unique index exists" do
+  #     assert_raise RuntimeError, fn ->
+  #       %Alog.TestApp.Unique{}
+  #       |> Alog.TestApp.Unique.changeset(%{name: "unique item"})
+  #       |> Alog.TestApp.Unique.insert()
+  #     end
+  #   end
+  # end
 end
diff --git a/test/constraint_test.exs b/test/constraint_test.exs
index 54f574d..e8ad9d8 100644
--- a/test/constraint_test.exs
+++ b/test/constraint_test.exs
@@ -1,33 +1,33 @@
 defmodule AlogTest.ConstraintTest do
-  use Alog.TestApp.DataCase
-
-  alias Alog.TestApp.{User, Helpers}
-
-  describe "apply_constraints/1:" do
-    test "returns error if not unique on insert" do
-      {:ok, user_1} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-
-      assert {:error, user_2} =
-               %User{}
-               |> User.changeset(
-                 Helpers.user_2_params()
-                 |> Map.merge(%{username: user_1.username})
-               )
-               |> User.insert()
-
-      assert user_2.errors == [username: {"has already been taken", []}]
-    end
-
-    test "returns error if not unique on update" do
-      {:ok, user_1} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      {:ok, user_2} = %User{} |> User.changeset(Helpers.user_2_params()) |> User.insert()
-
-      assert {:error, user_2} =
-               user_2
-               |> User.changeset(%{username: user_1.username})
-               |> User.update()
-
-      assert user_2.errors == [username: {"has already been taken", []}]
-    end
-  end
+  # use Alog.TestApp.DataCase
+  #
+  # alias Alog.TestApp.{User, Helpers}
+  #
+  # describe "apply_constraints/1:" do
+  #   test "returns error if not unique on insert" do
+  #     {:ok, user_1} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #
+  #     assert {:error, user_2} =
+  #              %User{}
+  #              |> User.changeset(
+  #                Helpers.user_2_params()
+  #                |> Map.merge(%{username: user_1.username})
+  #              )
+  #              |> User.insert()
+  #
+  #     assert user_2.errors == [username: {"has already been taken", []}]
+  #   end
+  #
+  #   test "returns error if not unique on update" do
+  #     {:ok, user_1} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #     {:ok, user_2} = %User{} |> User.changeset(Helpers.user_2_params()) |> User.insert()
+  #
+  #     assert {:error, user_2} =
+  #              user_2
+  #              |> User.changeset(%{username: user_1.username})
+  #              |> User.update()
+  #
+  #     assert user_2.errors == [username: {"has already been taken", []}]
+  #   end
+  # end
 end
diff --git a/test/delete_test.exs b/test/delete_test.exs
index c4162bd..82167ea 100644
--- a/test/delete_test.exs
+++ b/test/delete_test.exs
@@ -1,47 +1,47 @@
 defmodule AlogTest.DeleteTest do
-  use Alog.TestApp.DataCase
-
-  alias Alog.TestApp.{User, Helpers}
-
-  describe "delete/1:" do
-    test "succeeds" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      assert {:ok, _} = User.delete(user)
-    end
-
-    test "deleted items are not retrieved with 'get'" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      {:ok, _} = User.delete(user)
-
-      assert User.get(user.entry_id) == nil
-    end
-
-    test "deleted items are not retrieved with 'all'" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      {:ok, _} = User.delete(user)
-
-      assert length(User.all()) == 0
-    end
-  end
-
-  describe "delete/1 - with changeset:" do
-    test "succeeds" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      assert {:ok, _} = user |> User.changeset(%{}) |> User.delete()
-    end
-
-    test "deleted items are not retrieved with 'get'" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      {:ok, _} = user |> User.changeset(%{}) |> User.delete()
-
-      assert User.get(user.entry_id) == nil
-    end
-
-    test "deleted items are not retrieved with 'all'" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      {:ok, _} = user |> User.changeset(%{}) |> User.delete()
-
-      assert length(User.all()) == 0
-    end
-  end
+  # use Alog.TestApp.DataCase
+  #
+  # alias Alog.TestApp.{User, Helpers}
+  #
+  # describe "delete/1:" do
+  #   test "succeeds" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #     assert {:ok, _} = User.delete(user)
+  #   end
+  #
+  #   test "deleted items are not retrieved with 'get'" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #     {:ok, _} = User.delete(user)
+  #
+  #     assert User.get(user.entry_id) == nil
+  #   end
+  #
+  #   test "deleted items are not retrieved with 'all'" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #     {:ok, _} = User.delete(user)
+  #
+  #     assert length(User.all()) == 0
+  #   end
+  # end
+  #
+  # describe "delete/1 - with changeset:" do
+  #   test "succeeds" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #     assert {:ok, _} = user |> User.changeset(%{}) |> User.delete()
+  #   end
+  #
+  #   test "deleted items are not retrieved with 'get'" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #     {:ok, _} = user |> User.changeset(%{}) |> User.delete()
+  #
+  #     assert User.get(user.entry_id) == nil
+  #   end
+  #
+  #   test "deleted items are not retrieved with 'all'" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #     {:ok, _} = user |> User.changeset(%{}) |> User.delete()
+  #
+  #     assert length(User.all()) == 0
+  #   end
+  # end
 end
diff --git a/test/get_by_test.exs b/test/get_by_test.exs
index 34fb9ee..a0f0228 100644
--- a/test/get_by_test.exs
+++ b/test/get_by_test.exs
@@ -1,66 +1,66 @@
 defmodule AlogTest.GetByTest do
-  use Alog.TestApp.DataCase
-
-  alias Alog.TestApp.{User, Helpers}
-
-  describe "get_by/2:" do
-    test "only returns one result" do
-      {:ok, _user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-
-      {:ok, user_2} =
-        %User{}
-        |> User.changeset(Map.put(Helpers.user_2_params(), :postcode, "E2 0SY"))
-        |> User.insert()
-
-      assert User.get_by(postcode: "E2 0SY") == user_2
-    end
-
-    test "works with multiple clauses" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      {:ok, _user_2} = %User{} |> User.changeset(Helpers.user_2_params()) |> User.insert()
-
-      assert User.get_by(postcode: "E2 0SY", name: "Thor") == user
-    end
-
-    test "works with map params " do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-
-      assert User.get_by(%{postcode: "E2 0SY", name: "Thor"}) == user
-    end
-
-    test "case_insensitive option" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-
-      refute User.get_by(name: "thor") == user
-      assert User.get_by([name: "thor"], case_insensitive: true) == user
-      assert User.get_by(%{name: "thor"}, case_insensitive: true) == user
-    end
-
-    test "does not retrieve outdated results" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      {:ok, _updated_user} = user |> User.changeset(%{postcode: "EC3 RST"}) |> User.update()
-
-      assert User.get_by(postcode: "E2 0SY") == nil
-    end
-
-    test "does retrieve updated results if they match" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      {:ok, updated_user} = user |> User.changeset(%{postcode: "EC3 RST"}) |> User.update()
-
-      assert User.get_by(name: "Thor") |> User.preload(:items) == updated_user
-    end
-
-    test "ignores outdated and retrieves matching" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-
-      {:ok, user_2} =
-        %User{}
-        |> User.changeset(Map.put(Helpers.user_2_params(), :postcode, "E2 0SY"))
-        |> User.insert()
-
-      {:ok, _} = user_2 |> User.changeset(%{postcode: "EC3 RST"}) |> User.update()
-
-      assert User.get_by(postcode: "E2 0SY") == user
-    end
-  end
+  # use Alog.TestApp.DataCase
+  #
+  # alias Alog.TestApp.{User, Helpers}
+  #
+  # describe "get_by/2:" do
+  #   test "only returns one result" do
+  #     {:ok, _user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #
+  #     {:ok, user_2} =
+  #       %User{}
+  #       |> User.changeset(Map.put(Helpers.user_2_params(), :postcode, "E2 0SY"))
+  #       |> User.insert()
+  #
+  #     assert User.get_by(postcode: "E2 0SY") == user_2
+  #   end
+  #
+  #   test "works with multiple clauses" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #     {:ok, _user_2} = %User{} |> User.changeset(Helpers.user_2_params()) |> User.insert()
+  #
+  #     assert User.get_by(postcode: "E2 0SY", name: "Thor") == user
+  #   end
+  #
+  #   test "works with map params " do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #
+  #     assert User.get_by(%{postcode: "E2 0SY", name: "Thor"}) == user
+  #   end
+  #
+  #   test "case_insensitive option" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #
+  #     refute User.get_by(name: "thor") == user
+  #     assert User.get_by([name: "thor"], case_insensitive: true) == user
+  #     assert User.get_by(%{name: "thor"}, case_insensitive: true) == user
+  #   end
+  #
+  #   test "does not retrieve outdated results" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #     {:ok, _updated_user} = user |> User.changeset(%{postcode: "EC3 RST"}) |> User.update()
+  #
+  #     assert User.get_by(postcode: "E2 0SY") == nil
+  #   end
+  #
+  #   test "does retrieve updated results if they match" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #     {:ok, updated_user} = user |> User.changeset(%{postcode: "EC3 RST"}) |> User.update()
+  #
+  #     assert User.get_by(name: "Thor") |> User.preload(:items) == updated_user
+  #   end
+  #
+  #   test "ignores outdated and retrieves matching" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #
+  #     {:ok, user_2} =
+  #       %User{}
+  #       |> User.changeset(Map.put(Helpers.user_2_params(), :postcode, "E2 0SY"))
+  #       |> User.insert()
+  #
+  #     {:ok, _} = user_2 |> User.changeset(%{postcode: "EC3 RST"}) |> User.update()
+  #
+  #     assert User.get_by(postcode: "E2 0SY") == user
+  #   end
+  # end
 end
diff --git a/test/get_history_test.exs b/test/get_history_test.exs
index 1926696..eb9bd16 100644
--- a/test/get_history_test.exs
+++ b/test/get_history_test.exs
@@ -1,14 +1,14 @@
 defmodule AlogTest.GetHistoryTest do
-  use Alog.TestApp.DataCase
-
-  alias Alog.TestApp.{User, Helpers}
-
-  describe "get_history/1:" do
-    test "gets all items" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      {:ok, updated_user} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
-
-      assert length(User.get_history(updated_user)) == 2
-    end
-  end
+  # use Alog.TestApp.DataCase
+  #
+  # alias Alog.TestApp.{User, Helpers}
+  #
+  # describe "get_history/1:" do
+  #   test "gets all items" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #     {:ok, updated_user} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
+  #
+  #     assert length(User.get_history(updated_user)) == 2
+  #   end
+  # end
 end
diff --git a/test/insert_test.exs b/test/insert_test.exs
index ae3300b..de8ea22 100644
--- a/test/insert_test.exs
+++ b/test/insert_test.exs
@@ -1,117 +1,131 @@
 defmodule AlogTest.InsertTest do
   use Alog.TestApp.DataCase
+  alias Alog.Repo
+  alias Alog.TestApp.{Comment}
 
-  alias Alog.TestApp.{User, Item, ItemType, Helpers}
-
-  describe "insert/1 - with changeset:" do
+  describe "Repo.insert/2 - with Comment struct:" do
     test "succeeds" do
-      assert {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-    end
-
-    test "validates required fields" do
-      {:error, changeset} =
-        %User{}
-        |> User.changeset(%{name: "Thor"})
-        |> User.insert()
-
-      assert length(changeset.errors) > 0
+      Repo.insert(%Comment{comment: "hi"})
+      num_comments = Comment |> Repo.all() |> length()
+      assert num_comments == 1
     end
 
-    test "inserted user is available" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+    test "inserting the same comment twice fails with changeset" do
+      Repo.insert(%Comment{comment: "hi"})
 
-      assert User.get(user.entry_id) == user
-    end
-  end
-
-  describe "insert/1 - with struct:" do
-    test "succeeds" do
-      {:ok, user} = struct(User, Helpers.user_1_params()) |> User.insert()
+      {atom, _changeset} =
+        %Comment{}
+        |> Comment.changeset(%{comment: "hi"})
+        |> Repo.insert()
 
-      assert User.get(user.entry_id) == user
+      assert atom == :error
     end
 
-    test "inserted user is available" do
-      {:ok, user} = struct(User, Helpers.user_1_params()) |> User.insert()
-
-      assert User.get(user.entry_id) == user
-    end
+    # test "validates required fields" do
+    #   {:error, changeset} =
+    #     %User{}
+    #     |> User.changeset(%{name: "Thor"})
+    #     |> User.insert()
+    #
+    #   assert length(changeset.errors) > 0
+    # end
+    #
+    # test "inserted user is available" do
+    #   {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+    #
+    #   assert User.get(user.entry_id) == user
+    # end
   end
 
-  describe "insert/1 - with nested changeset:" do
-    test "succeeds" do
-      assert {:ok, user} =
-               %User{}
-               |> User.user_and_item_changeset(
-                 Map.put(Helpers.user_1_params(), :items, [%{name: "Belt"}])
-               )
-               |> User.insert()
-    end
-
-    test "item is associated with user" do
-      {:ok, user} =
-        %User{}
-        |> User.user_and_item_changeset(
-          Map.put(Helpers.user_1_params(), :items, [%{name: "Belt"}])
-        )
-        |> User.insert()
-
-      assert User.get(user.entry_id) |> Repo.preload(:items) |> Map.get(:items) |> length == 1
-    end
-
-    test "associated item is inserted into database - has_many" do
-      {:ok, _user} =
-        %User{}
-        |> User.user_and_item_changeset(
-          Map.put(Helpers.user_1_params(), :items, [%{name: "Belt"}])
-        )
-        |> User.insert()
-
-      all_items = Item.all()
-
-      assert length(all_items) == 1
-      assert List.first(all_items).entry_id
-    end
-
-    test "associated item is inserted into database - belongs_to" do
-      {:ok, _item} =
-        %Item{}
-        |> Item.changeset(Map.put(%{name: "Stormbreaker"}, :user, Helpers.user_1_params()))
-        |> Item.insert()
-
-      all_users = User.all()
-
-      user = List.first(all_users)
-
-      assert length(all_users) == 1
-      assert user.entry_id
-      assert user.name == "Thor"
-    end
-
-    test "two level deep nested associations" do
-      {:ok, _user} =
-        %User{}
-        |> User.user_and_item_changeset(
-          Map.put(Helpers.user_1_params(), :items, [
-            %{name: "Stormbreaker", item_types: [%{type: "Axe"}]}
-          ])
-        )
-        |> User.insert()
-
-      all_items = Item.all()
-      all_types = ItemType.all()
-
-      item = List.first(all_items)
-      type = List.first(all_types)
-
-      assert length(all_items) == 1
-      assert length(all_types) == 1
-
-      assert item.entry_id
-      assert item.name == "Stormbreaker"
-
-      assert type.entry_id
-      assert type.type == "Axe"
-    end
-  end
+  #
+  # describe "insert/1 - with struct:" do
+  #   test "succeeds" do
+  #     {:ok, user} = struct(User, Helpers.user_1_params()) |> User.insert()
+  #
+  #     assert User.get(user.entry_id) == user
+  #   end
+  #
+  #   test "inserted user is available" do
+  #     {:ok, user} = struct(User, Helpers.user_1_params()) |> User.insert()
+  #
+  #     assert User.get(user.entry_id) == user
+  #   end
+  # end
+  #
+  # describe "insert/1 - with nested changeset:" do
+  #   test "succeeds" do
+  #     assert {:ok, user} =
+  #              %User{}
+  #              |> User.user_and_item_changeset(
+  #                Map.put(Helpers.user_1_params(), :items, [%{name: "Belt"}])
+  #              )
+  #              |> User.insert()
+  #   end
+  #
+  #   test "item is associated with user" do
+  #     {:ok, user} =
+  #       %User{}
+  #       |> User.user_and_item_changeset(
+  #         Map.put(Helpers.user_1_params(), :items, [%{name: "Belt"}])
+  #       )
+  #       |> User.insert()
+  #
+  #     assert User.get(user.entry_id) |> Repo.preload(:items) |> Map.get(:items) |> length == 1
+  #   end
+  #
+  #   test "associated item is inserted into database - has_many" do
+  #     {:ok, _user} =
+  #       %User{}
+  #       |> User.user_and_item_changeset(
+  #         Map.put(Helpers.user_1_params(), :items, [%{name: "Belt"}])
+  #       )
+  #       |> User.insert()
+  #
+  #     all_items = Item.all()
+  #
+  #     assert length(all_items) == 1
+  #     assert List.first(all_items).entry_id
+  #   end
+  #
+  #   test "associated item is inserted into database - belongs_to" do
+  #     {:ok, _item} =
+  #       %Item{}
+  #       |> Item.changeset(Map.put(%{name: "Stormbreaker"}, :user, Helpers.user_1_params()))
+  #       |> Item.insert()
+  #
+  #     all_users = User.all()
+  #
+  #     user = List.first(all_users)
+  #
+  #     assert length(all_users) == 1
+  #     assert user.entry_id
+  #     assert user.name == "Thor"
+  #   end
+  #
+  #   test "two level deep nested associations" do
+  #     {:ok, _user} =
+  #       %User{}
+  #       |> User.user_and_item_changeset(
+  #         Map.put(Helpers.user_1_params(), :items, [
+  #           %{name: "Stormbreaker", item_types: [%{type: "Axe"}]}
+  #         ])
+  #       )
+  #       |> User.insert()
+  #
+  #     all_items = Item.all()
+  #     all_types = ItemType.all()
+  #
+  #     item = List.first(all_items)
+  #     type = List.first(all_types)
+  #
+  #     assert length(all_items) == 1
+  #     assert length(all_types) == 1
+  #
+  #     assert item.entry_id
+  #     assert item.name == "Stormbreaker"
+  #
+  #     assert type.entry_id
+  #     assert type.type == "Axe"
+  #   end
+  # end
 end
diff --git a/test/preload_test.exs b/test/preload_test.exs
index cecab64..d20fee5 100644
--- a/test/preload_test.exs
+++ b/test/preload_test.exs
@@ -1,57 +1,57 @@
 defmodule AlogTest.PreloadTest do
-  use Alog.TestApp.DataCase
-
-  alias Alog.TestApp.{User, Item, Helpers}
-
-  test "preloads one_to_many associations" do
-    {:ok, user, _} = Helpers.seed_data()
-
-    # items are not loaded by default
-    assert_raise ArgumentError, fn ->
-      user.entry_id
-      |> User.get()
-      |> Map.get(:items)
-      |> length()
-    end
-
-    assert user.entry_id
-           |> User.get()
-           |> User.preload(:items)
-           |> Map.get(:items)
-           |> length() == 1
-  end
-
-  test "preloads nested associations" do
-    {:ok, user, item} = Helpers.seed_data()
-
-    # item_types are not loaded by default
-    assert_raise ArgumentError, fn ->
-      item.entry_id
-      |> Item.get()
-      |> Map.get(:item_types)
-      |> length()
-    end
-
-    assert user.entry_id
-           |> User.get()
-           |> User.preload(items: [:item_types])
-           |> Map.get(:items)
-           |> List.first()
-           |> Map.get(:item_types)
-           |> length() == 1
-  end
-
-  test "preloads two level deep nested associations" do
-    {:ok, user, _} = Helpers.seed_data()
-
-    assert user.entry_id
-           |> User.get()
-           |> User.preload(items: [item_types: [:items]])
-           |> Map.get(:items)
-           |> List.first()
-           |> Map.get(:item_types)
-           |> List.first()
-           |> Map.get(:items)
-           |> length() == 2
-  end
+  # use Alog.TestApp.DataCase
+  #
+  # alias Alog.TestApp.{User, Item, Helpers}
+  #
+  # test "preloads one_to_many associations" do
+  #   {:ok, user, _} = Helpers.seed_data()
+  #
+  #   # items are not loaded by default
+  #   assert_raise ArgumentError, fn ->
+  #     user.entry_id
+  #     |> User.get()
+  #     |> Map.get(:items)
+  #     |> length()
+  #   end
+  #
+  #   assert user.entry_id
+  #          |> User.get()
+  #          |> User.preload(:items)
+  #          |> Map.get(:items)
+  #          |> length() == 1
+  # end
+  #
+  # test "preloads nested associations" do
+  #   {:ok, user, item} = Helpers.seed_data()
+  #
+  #   # item_types are not loaded by default
+  #   assert_raise ArgumentError, fn ->
+  #     item.entry_id
+  #     |> Item.get()
+  #     |> Map.get(:item_types)
+  #     |> length()
+  #   end
+  #
+  #   assert user.entry_id
+  #          |> User.get()
+  #          |> User.preload(items: [:item_types])
+  #          |> Map.get(:items)
+  #          |> List.first()
+  #          |> Map.get(:item_types)
+  #          |> length() == 1
+  # end
+  #
+  # test "preloads two level deep nested associations" do
+  #   {:ok, user, _} = Helpers.seed_data()
+  #
+  #   assert user.entry_id
+  #          |> User.get()
+  #          |> User.preload(items: [item_types: [:items]])
+  #          |> Map.get(:items)
+  #          |> List.first()
+  #          |> Map.get(:item_types)
+  #          |> List.first()
+  #          |> Map.get(:items)
+  #          |> length() == 2
+  # end
 end
diff --git a/test/support/application.ex b/test/support/application.ex
index 5af3f64..f0176dd 100644
--- a/test/support/application.ex
+++ b/test/support/application.ex
@@ -3,18 +3,8 @@ defmodule Alog.TestApp.Application do
   use Application
 
   def start(_type, _args) do
-    import Supervisor.Spec
-
-    children =
-      case Code.ensure_compiled(Alog.TestApp) do
-        {:error, _} ->
-          []
-
-        {:module, Alog.TestApp} ->
-          [supervisor(Alog.Repo, [])]
-      end
-
     opts = [strategy: :one_for_one, name: Alog.TestApp.Supervisor]
-    Supervisor.start_link(children, opts)
+
+    Supervisor.start_link([Alog.Repo], opts)
   end
 end
diff --git a/test/support/comment.ex b/test/support/comment.ex
new file mode 100644
index 0000000..5a3ab13
--- /dev/null
+++ b/test/support/comment.ex
@@ -0,0 +1,18 @@
+defmodule Alog.TestApp.Comment do
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  # I'd imagine we'll change string as the type
+  @primary_key {:cid, :string, autogenerate: false}
+  schema "comments" do
+    field(:entry_id, :string)
+    field(:deleted, :boolean, default: false)
+    field(:comment, :string)
+  end
+
+  def changeset(comment_struct, attrs \\ %{}) do
+    comment_struct
+    |> cast(attrs, [:cid, :entry_id, :comment, :deleted])
+    |> unique_constraint(:cid, name: :comments_pkey)
+  end
+end
\ No newline at end of file
diff --git a/test/support/helpers.ex b/test/support/helpers.ex
index 2374956..ec3dbf6 100644
--- a/test/support/helpers.ex
+++ b/test/support/helpers.ex
@@ -1,48 +1,48 @@
 defmodule Alog.TestApp.Helpers do
-  alias Alog.TestApp.{User, Item, ItemType}
-  alias Alog.Repo
-
-  def user_1_params(), do: %{name: "Thor", username: "gdofthndr12", postcode: "E2 0SY"}
-
-  def user_2_params(), do: %{name: "Loki", username: "mschfmkr", postcode: "E1 6DR"}
-
-  def user_3_params(), do: %{name: "Bob", username: "bobuser", postcode: "E1 7DR"}
-
-  def seed_data() do
-    {:ok, item_type} = %ItemType{} |> ItemType.changeset(%{type: "Weapon"}) |> ItemType.insert()
-
-    {:ok, item} = %Item{} |> Item.changeset(%{name: "Mjolnir"}) |> Item.insert()
-    {:ok, item_2} = %Item{} |> Item.changeset(%{name: "Staff"}) |> Item.insert()
-
-    {:ok, item} = add_type_to_item(item, item_type)
-    {:ok, _item_2} = add_type_to_item(item_2, item_type)
-
-    {:ok, user} = %User{} |> User.changeset(user_1_params) |> User.insert()
-
-    {:ok, user} = add_item_to_user(user, item)
-
-    {:ok, user, item}
-  end
-
-  def add_type_to_item(item, type) do
-    item
-    |> Item.preload([:item_types, :user])
-    |> Map.put(:id, nil)
-    |> Map.put(:inserted_at, nil)
-    |> Map.put(:updated_at, nil)
-    |> Item.changeset(%{})
-    |> Ecto.Changeset.put_assoc(:item_types, [type])
-    |> Repo.insert()
-  end
-
-  def add_item_to_user(user, item) do
-    user
-    |> User.preload([:items])
-    |> Map.put(:id, nil)
-    |> Map.put(:inserted_at, nil)
-    |> Map.put(:updated_at, nil)
-    |> User.changeset(%{})
-    |> Ecto.Changeset.put_assoc(:items, [item])
-    |> Repo.insert()
-  end
+  # alias Alog.TestApp.{User, Item, ItemType}
+  # alias Alog.Repo
+  #
+  # def user_1_params(), do: %{name: "Thor", username: "gdofthndr12", postcode: "E2 0SY"}
+  #
+  # def user_2_params(), do: %{name: "Loki", username: "mschfmkr", postcode: "E1 6DR"}
+  #
+  # def user_3_params(), do: %{name: "Bob", username: "bobuser", postcode: "E1 7DR"}
+  #
+  # def seed_data() do
+  #   {:ok, item_type} = %ItemType{} |> ItemType.changeset(%{type: "Weapon"}) |> ItemType.insert()
+  #
+  #   {:ok, item} = %Item{} |> Item.changeset(%{name: "Mjolnir"}) |> Item.insert()
+  #   {:ok, item_2} = %Item{} |> Item.changeset(%{name: "Staff"}) |> Item.insert()
+  #
+  #   {:ok, item} = add_type_to_item(item, item_type)
+  #   {:ok, _item_2} = add_type_to_item(item_2, item_type)
+  #
+  #   {:ok, user} = %User{} |> User.changeset(user_1_params) |> User.insert()
+  #
+  #   {:ok, user} = add_item_to_user(user, item)
+  #
+  #   {:ok, user, item}
+  # end
+  #
+  # def add_type_to_item(item, type) do
+  #   item
+  #   |> Item.preload([:item_types, :user])
+  #   |> Map.put(:id, nil)
+  #   |> Map.put(:inserted_at, nil)
+  #   |> Map.put(:updated_at, nil)
+  #   |> Item.changeset(%{})
+  #   |> Ecto.Changeset.put_assoc(:item_types, [type])
+  #   |> Repo.insert()
+  # end
+  #
+  # def add_item_to_user(user, item) do
+  #   user
+  #   |> User.preload([:items])
+  #   |> Map.put(:id, nil)
+  #   |> Map.put(:inserted_at, nil)
+  #   |> Map.put(:updated_at, nil)
+  #   |> User.changeset(%{})
+  #   |> Ecto.Changeset.put_assoc(:items, [item])
+  #   |> Repo.insert()
+  # end
 end
diff --git a/test/support/item.ex b/test/support/item.ex
deleted file mode 100644
index 6e2dc22..0000000
--- a/test/support/item.ex
+++ /dev/null
@@ -1,31 +0,0 @@
-defmodule Alog.TestApp.Item do
-  use Ecto.Schema
-  use Alog
-  import Ecto.Changeset
-
-  schema "items" do
-    field(:name, :string)
-    field(:entry_id, :string)
-    field(:deleted, :boolean, default: false)
-
-    belongs_to(:user, Alog.TestApp.User, foreign_key: :owner)
-
-    many_to_many(
-      :item_types,
-      Alog.TestApp.ItemType,
-      join_through: "items_item_types",
-      join_keys: [item_id: :id, item_type_id: :id]
-    )
-
-    timestamps()
-  end
-
-  @doc false
-  def changeset(item, attrs) do
-    item
-    |> cast(attrs, [:name])
-    |> validate_required([:name])
-    |> cast_assoc(:item_types)
-    |> cast_assoc(:user)
-  end
-end
diff --git a/test/support/item_type.ex b/test/support/item_type.ex
deleted file mode 100644
index 31df3ed..0000000
--- a/test/support/item_type.ex
+++ /dev/null
@@ -1,27 +0,0 @@
-defmodule Alog.TestApp.ItemType do
-  use Ecto.Schema
-  use Alog
-  import Ecto.Changeset
-
-  schema "item_types" do
-    field(:type, :string)
-    field(:entry_id, :string)
-    field(:deleted, :boolean, default: false)
-
-    many_to_many(
-      :items,
-      Alog.TestApp.Item,
-      join_through: "items_item_types",
-      join_keys: [item_type_id: :id, item_id: :id]
-    )
-
-    timestamps()
-  end
-
-  @doc false
-  def changeset(address, attrs) do
-    address
-    |> cast(attrs, [:type])
-    |> validate_required([:type])
-  end
-end
diff --git a/test/support/repo.ex b/test/support/repo.ex
index 41237c3..179466a 100644
--- a/test/support/repo.ex
+++ b/test/support/repo.ex
@@ -1,11 +1,5 @@
 defmodule Alog.Repo do
-  use Ecto.Repo, otp_app: :alog
-
-  @doc """
-  Dynamically loads the repository url from the
-  DATABASE_URL environment variable.
-  """
-  def init(_, opts) do
-    {:ok, Keyword.put(opts, :url, System.get_env("DATABASE_URL"))}
-  end
+  use Ecto.Repo,
+    otp_app: :alog,
+    adapter: Alog
 end
diff --git a/test/support/unique.ex b/test/support/unique.ex
deleted file mode 100644
index 197bd23..0000000
--- a/test/support/unique.ex
+++ /dev/null
@@ -1,20 +0,0 @@
-defmodule Alog.TestApp.Unique do
-  use Ecto.Schema
-  use Alog
-  import Ecto.Changeset
-
-  schema "unique" do
-    field(:name, :string)
-    field(:entry_id, :string)
-    field(:deleted, :boolean, default: false)
-
-    timestamps()
-  end
-
-  @doc false
-  def changeset(unique, attrs) do
-    unique
-    |> cast(attrs, [:name])
-    |> validate_required([:name])
-  end
-end
diff --git a/test/support/user.ex b/test/support/user.ex
deleted file mode 100644
index dfc77fe..0000000
--- a/test/support/user.ex
+++ /dev/null
@@ -1,32 +0,0 @@
-defmodule Alog.TestApp.User do
-  use Ecto.Schema
-  use Alog
-  import Ecto.Changeset
-
-  schema "users" do
-    field(:name, :string)
-    field(:username, :string)
-    field(:postcode, :string)
-    field(:entry_id, :string)
-    field(:deleted, :boolean, default: false)
-
-    has_many(:items, Alog.TestApp.Item, foreign_key: :owner)
-
-    timestamps()
-  end
-
-  @doc false
-  def changeset(user, attrs) do
-    user
-    |> cast(attrs, [:name, :username, :postcode, :deleted])
-    |> validate_required([:name, :username, :postcode])
-    |> unique_constraint(:username)
-  end
-
-  def user_and_item_changeset(user, attrs) do
-    user
-    |> cast(attrs, [:name, :username, :postcode, :deleted])
-    |> validate_required([:name, :username, :postcode])
-    |> cast_assoc(:items)
-  end
-end
diff --git a/test/update_test.exs b/test/update_test.exs
index 076f639..1a7d845 100644
--- a/test/update_test.exs
+++ b/test/update_test.exs
@@ -1,38 +1,15 @@
 defmodule AlogTest.UpdateTest do
   use Alog.TestApp.DataCase
 
-  alias Alog.TestApp.{User, Helpers}
+  alias Alog.TestApp.{Comment, Helpers}
 
-  describe "update/2:" do
-    test "succeeds" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  test "adds new record" do
+    {:ok, _} = Repo.insert(%Comment{} |> Comment.changeset(%{comment: "hi"}))
 
-      assert {:ok, updated_user} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
-    end
+    [c | []] = Repo.all(Comment)
 
-    test "updates" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+    {:ok, _} = Repo.update(Comment.changeset(c, %{comment: "hello"}))
 
-      {:ok, updated_user} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
-
-      assert updated_user.postcode == "W2 3EC"
-    end
-
-    test "'get' returns most recently updated item" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-
-      {:ok, updated_user} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
-
-      assert User.get(user.entry_id) |> User.preload(:items) == updated_user
-      assert User.get(user.entry_id).postcode == "W2 3EC"
-    end
-
-    test "associations remain after update" do
-      {:ok, user, _item} = Helpers.seed_data()
-
-      {:ok, _updated_user} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
-
-      assert User.get(user.entry_id) |> User.preload(:items) |> Map.get(:items) |> length == 1
-    end
+    assert Repo.all(Comment) |> length == 2
   end
 end