Fix typos and main Dialyzer warnings (#124)

Thank, I take care about mix credo and mix format

Author: fdie

lib/mongo.ex

@@ -72,14 +72,13 @@ defmodule Mongo do
   @type collection :: String.t()
   @opaque cursor :: Mongo.Cursor.t()
   @type result(t) :: :ok | {:ok, t} | {:error, Mongo.Error.t()}
-  @type result!(t) :: nil | t | no_return
+  @type result!(t) :: t
 
   defmacrop bangify(result) do
     quote do
       case unquote(result) do
         {:ok, value} -> value
         {:error, error} -> raise error
-        :ok -> nil
       end
     end
   end
@@ -178,7 +177,7 @@ defmodule Mongo do
       iex> Mongo.uuid("848e90e9-5750-4e0a-ab73-66-c6b328242")
       {:error, %ArgumentError{message: "non-alphabet digit found: \"-\" (byte 45)"}}
   """
-  @spec uuid(String.t()) :: {:ok, BSON.Binary.t()} | {:error, ArgumentError.t()}
+  @spec uuid(any) :: {:ok, BSON.Binary.t()} | {:error, %ArgumentError{}}
   def uuid(string) when is_binary(string) and byte_size(string) == 36 do
     try do
       p1 = binary_part(string, 0, 8) |> Base.decode16!(case: :lower)
@@ -221,7 +220,7 @@ defmodule Mongo do
   @doc """
   Creates a new UUID.
   """
-  @spec uuid(String.t()) :: BSON.Binary.t()
+  @spec uuid() :: BSON.Binary.t()
   def uuid() do
     %BSON.Binary{binary: uuid4(), subtype: :uuid}
   end
@@ -257,7 +256,7 @@ defmodule Mongo do
         returning the first notification after the token. This will allow users to watch collections that have been dropped and recreated
         or newly renamed collections without missing any notifications. (since 4.0.7)
   """
-  @spec watch_collection(GenServer.server(), collection | 1, [BSON.document()], fun, Keyword.it()) ::
+  @spec watch_collection(GenServer.server(), collection | 1, [BSON.document()], fun | nil, Keyword.t()) ::
           cursor
   def watch_collection(topology_pid, coll, pipeline, on_resume_token \\ nil, opts \\ []) do
     stream_opts =
@@ -312,7 +311,7 @@ defmodule Mongo do
         returning the first notification after the token. This will allow users to watch collections that have been dropped and recreated
         or newly renamed collections without missing any notifications. (since 4.0.7)
   """
-  @spec watch_db(GenServer.server(), [BSON.document()], fun, Keyword.it()) :: cursor
+  @spec watch_db(GenServer.server(), [BSON.document()], fun | nil, Keyword.t()) :: cursor
   def watch_db(topology_pid, pipeline, on_resume_token \\ nil, opts \\ []) do
     watch_collection(topology_pid, 1, pipeline, on_resume_token, opts)
   end
@@ -448,6 +447,8 @@ defmodule Mongo do
         _other ->
           result
       end
+    else
+      _ -> {:error, Mongo.Error.exception("Command processing error")}
     end
   end
 
@@ -587,8 +588,11 @@ defmodule Mongo do
 
     opts = Keyword.drop(opts, ~w(limit skip hint collation)a)
 
-    with {:ok, doc} <- issue_command(topology_pid, cmd, :read, opts),
-         do: {:ok, trunc(doc["n"])}
+    with {:ok, doc} <- issue_command(topology_pid, cmd, :read, opts) do
+      {:ok, trunc(doc["n"])}
+    else
+      _ -> {:error, Mongo.Error.exception("Failed to count")}
+    end
   end
 
   @doc false
@@ -618,15 +622,14 @@ defmodule Mongo do
       |> filter_nils()
       |> Enum.map(&List.wrap/1)
 
-    documents =
-      topology_pid
-      |> Mongo.aggregate(coll, pipeline, opts)
-      |> Enum.to_list()
-
-    case documents do
-      [%{"n" => count}] -> {:ok, count}
-      [] -> {:ok, 0}
-      _ -> :error
+    with %Mongo.Stream{} = cursor <- Mongo.aggregate(topology_pid, coll, pipeline, opts),
+      documents <- Enum.to_list(cursor) do
+        case documents do
+          [%{"n" => count}] -> {:ok, count}
+          [] -> {:ok, 0}
+        end
+    else
+      _ -> {:error, Mongo.Error.exception("Failed to count")}
     end
   end
 
@@ -809,7 +812,7 @@ defmodule Mongo do
 
   @doc false
   @spec exec_command(GenServer.server(), BSON.document(), Keyword.t()) ::
-          {:ok, BSON.document() | nil} | {:error, Mongo.Error.t()}
+          {:ok, {any(), BSON.document()} | nil} | {:error, Mongo.Error.t()}
   def exec_command(conn, cmd, opts) do
     with {:ok, _cmd, response} <- DBConnection.execute(conn, %Query{action: :command}, [cmd], defaults(opts)) do
       check_for_error(response, cmd, opts)
@@ -1078,6 +1081,8 @@ defmodule Mongo do
             true -> {:ok, %Mongo.InsertManyResult{inserted_ids: ids}}
           end
       end
+    else
+      _ -> {:error, Mongo.Error.exception("Failed to insert many")}
     end
   end
 
@@ -1306,8 +1311,10 @@ defmodule Mongo do
     end
   end
 
-  defp filter_upsert_ids(nil), do: []
-  defp filter_upsert_ids(upserted), do: Enum.map(upserted, fn doc -> doc["_id"] end)
+
+  @spec filter_upsert_ids(any) :: list
+  defp filter_upsert_ids([_|_] = upserted), do: Enum.map(upserted, fn doc -> doc["_id"] end)
+  defp filter_upsert_ids(_), do: []
 
   @doc """
   Similar to `update_many/5` but unwraps the result and raises on error.
@@ -1335,7 +1342,7 @@ defmodule Mongo do
   @doc """
   Convenient function that returns a cursor with the names of the indexes.
   """
-  @spec list_index_names(GenServer.server(), String.t(), Keyword.t()) :: Stream.t()
+  @spec list_index_names(GenServer.server(), String.t(), Keyword.t()) :: cursor
   def list_index_names(topology_pid, coll, opts \\ []) do
     list_indexes(topology_pid, coll, opts)
     |> Stream.map(fn %{"name" => name} -> name end)
@@ -1386,7 +1393,7 @@ defmodule Mongo do
   @doc """
   Convenient function that drops the database `name`.
   """
-  @spec drop_database(GenServer.server(), String.t()) :: :ok | {:error, Mongo.Error.t()}
+  @spec drop_database(GenServer.server(), String.t() | nil) :: :ok | {:error, Mongo.Error.t()}
   def drop_database(topology_pid, name \\ nil)
 
   def drop_database(topology_pid, nil) do

lib/mongo/bulk_write.ex

@@ -346,8 +346,9 @@ defmodule Mongo.BulkWrite do
     |> BulkWriteResult.reduce()
   end
 
-  defp filter_upsert_ids(nil), do: []
-  defp filter_upsert_ids(upserted), do: Enum.map(upserted, fn doc -> doc["_id"] end)
+  @spec filter_upsert_ids(any) :: list
+  defp filter_upsert_ids([_|_] = upserted), do: Enum.map(upserted, fn doc -> doc["_id"] end)
+  defp filter_upsert_ids(_), do: []
 
   defp run_commands(session, {cmds, ids}, opts) do
     {Enum.map(cmds, fn cmd -> Mongo.exec_command_session(session, cmd, opts) end), ids}

lib/mongo/ordered_bulk.ex

@@ -56,7 +56,7 @@ defmodule Mongo.OrderedBulk do
 
   @type t :: %__MODULE__{
           coll: String.t(),
-          ops: [BulkOps.bulk_op()]
+          ops: [Mongo.BulkOps.bulk_op()]
         }
 
   defstruct coll: nil, ops: []
@@ -90,7 +90,7 @@ defmodule Mongo.OrderedBulk do
   @doc """
   Appends a bulk operation to the ordered bulk.
   """
-  @spec push(BulkOps.bulk_op(), OrderedBulk.t()) :: OrderedBulk.t()
+  @spec push(Mongo.BulkOps.bulk_op(), OrderedBulk.t()) :: OrderedBulk.t()
   def push(op, %OrderedBulk{ops: rest} = bulk) do
     %OrderedBulk{bulk | ops: [op | rest]}
   end
@@ -105,7 +105,7 @@ defmodule Mongo.OrderedBulk do
   %Mongo.OrderedBulk{coll: "bulk", ops: [insert: %{name: "Waldo"}]}
   ```
   """
-  @spec insert_one(OrderedBulk.t(), BulkOps.bulk_op()) :: OrderedBulk.t()
+  @spec insert_one(OrderedBulk.t(), BSON.document()) :: OrderedBulk.t()
   def insert_one(%OrderedBulk{} = bulk, doc) do
     get_insert_one(doc) |> push(bulk)
   end
@@ -120,7 +120,7 @@ defmodule Mongo.OrderedBulk do
   %Mongo.OrderedBulk{coll: "bulk", ops: [delete: {%{name: "Waldo"}, [limit: 1]}]}
   ```
   """
-  @spec delete_one(OrderedBulk.t(), BulkOps.bulk_op()) :: OrderedBulk.t()
+  @spec delete_one(OrderedBulk.t(), BSON.document()) :: OrderedBulk.t()
   def delete_one(%OrderedBulk{} = bulk, doc) do
     get_delete_one(doc) |> push(bulk)
   end
@@ -135,7 +135,7 @@ defmodule Mongo.OrderedBulk do
   %Mongo.OrderedBulk{coll: "bulk", ops: [delete: {%{name: "Waldo"}, [limit: 0]}]}
   ```
   """
-  @spec delete_many(OrderedBulk.t(), BulkOps.bulk_op()) :: OrderedBulk.t()
+  @spec delete_many(OrderedBulk.t(), BSON.document()) :: OrderedBulk.t()
   def delete_many(%OrderedBulk{} = bulk, doc) do
     get_delete_many(doc) |> push(bulk)
   end

lib/mongo/read_preference.ex

@@ -117,10 +117,6 @@ defmodule Mongo.ReadPreference do
     transform(config)
   end
 
-  defp transform(%{:mode => :primary}) do
-    %{:mode => :primary}
-  end
-
   defp transform(config) do
     mode =
       case config[:mode] do

lib/mongo/results.ex

@@ -88,7 +88,7 @@ defmodule Mongo.BulkWriteResult do
           upserted_count: non_neg_integer,
           upserted_ids: list(BSON.ObjectId.t()),
           inserted_ids: list(BSON.ObjectId.t()),
-          errors: list(Map.t())
+          errors: list(map)
         }
 
   alias Mongo.BulkWriteResult

lib/mongo/session.ex

@@ -223,9 +223,9 @@ defmodule Mongo.Session do
   @doc """
   Merge the session / transaction data into the cmd. There is no need to call this function directly. It is called automatically.
   """
-  @spec bind_session(Session.t(), BSON.document()) :: :ok | {:error, term()}
-  def bind_session(nil, cmd) do
-    cmd
+  @spec bind_session(Session.t(), BSON.document()) :: {:ok, pid, BSON.document()} | {:error, term()}
+  def bind_session(nil, _cmd) do
+    {:error, Mongo.Error.exception("No session")}
   end
 
   def bind_session(pid, cmd) do
@@ -253,7 +253,7 @@ defmodule Mongo.Session do
   @doc """
   Advance the `operationTime` for causally consistent read commands
   """
-  @spec advance_operation_time(Session.t(), BSON.Timestamp.t()) :: none()
+  @spec advance_operation_time(Session.t(), BSON.Timestamp.t()) :: any()
   def advance_operation_time(_pid, nil) do
   end
 
@@ -264,7 +264,7 @@ defmodule Mongo.Session do
   @doc """
   Update the `recoveryToken` after each response from mongos
   """
-  @spec update_recovery_token(Session.t(), BSON.document()) :: none()
+  @spec update_recovery_token(Session.t(), BSON.document()) :: any()
   def update_recovery_token(_pid, nil) do
   end
 
@@ -384,7 +384,7 @@ defmodule Mongo.Session do
   @doc """
   Return the wire_version used in the session.
   """
-  @spec connection(Session.t()) :: pid
+  @spec wire_version(Session.t()) :: integer
   def wire_version(pid) do
     call(pid, :wire_version)
   end
@@ -408,7 +408,7 @@ defmodule Mongo.Session do
   @doc """
   Check if the session is alive.
   """
-  @spec server_session(Session.t()) :: boolean()
+  @spec alive?(Session.t()) :: boolean()
   def alive?(nil), do: false
   def alive?(pid), do: Process.alive?(pid)
 

lib/mongo/unordered_bulk.ex

@@ -55,9 +55,9 @@ defmodule Mongo.UnorderedBulk do
 
   @type t :: %__MODULE__{
           coll: String.t(),
-          inserts: [BulkOps.bulk_op()],
-          updates: [BulkOps.bulk_op()],
-          deletes: [BulkOps.bulk_op()]
+          inserts: [Mongo.BulkOps.bulk_op()],
+          updates: [Mongo.BulkOps.bulk_op()],
+          deletes: [Mongo.BulkOps.bulk_op()]
         }
 
   defstruct coll: nil, inserts: [], updates: [], deletes: []
@@ -99,7 +99,7 @@ defmodule Mongo.UnorderedBulk do
   Appends a bulk operation to the unordered bulk. One of the field (inserts, updates or deletes)
   will be updated.
   """
-  @spec push(BulkOps.bulk_op(), UnorderedBulk.t()) :: UnorderedBulk.t()
+  @spec push(Mongo.BulkOps.bulk_op(), UnorderedBulk.t()) :: UnorderedBulk.t()
   def push({:insert, doc}, %UnorderedBulk{inserts: rest} = bulk) do
     %UnorderedBulk{bulk | inserts: [doc | rest]}
   end
@@ -127,7 +127,7 @@ defmodule Mongo.UnorderedBulk do
   }
   ```
   """
-  @spec insert_one(UnorderedBulk.t(), BulkOps.bulk_op()) :: UnorderedBulk.t()
+  @spec insert_one(UnorderedBulk.t(), BSON.document()) :: UnorderedBulk.t()
   def insert_one(%UnorderedBulk{} = bulk, doc) do
     get_insert_one(doc) |> push(bulk)
   end
@@ -147,7 +147,7 @@ defmodule Mongo.UnorderedBulk do
   }
   ```
   """
-  @spec delete_one(UnorderedBulk.t(), BulkOps.bulk_op()) :: UnorderedBulk.t()
+  @spec delete_one(UnorderedBulk.t(), BSON.document()) :: UnorderedBulk.t()
   def delete_one(%UnorderedBulk{} = bulk, doc) do
     get_delete_one(doc) |> push(bulk)
   end
@@ -167,7 +167,7 @@ defmodule Mongo.UnorderedBulk do
   }
   ```
   """
-  @spec delete_many(UnorderedBulk.t(), BulkOps.bulk_op()) :: UnorderedBulk.t()
+  @spec delete_many(UnorderedBulk.t(), BSON.document()) :: UnorderedBulk.t()
   def delete_many(%UnorderedBulk{} = bulk, doc) do
     get_delete_many(doc) |> push(bulk)
   end

lib/mongo/write_concern.ex

@@ -3,6 +3,7 @@ defmodule Mongo.WriteConcern do
 
   import Keywords
 
+  @spec write_concern(keyword) :: nil | map
   def write_concern(opts) do
     %{
       w: Keyword.get(opts, :w),
@@ -13,29 +14,16 @@ defmodule Mongo.WriteConcern do
     |> filter_empty()
   end
 
-  def filter_empty(map) when is_map(map) and map == %{} do
-    nil
-  end
-
-  def filter_empty(map) when is_map(map) do
-    map
-  end
+  @spec filter_empty(map) :: nil | map
+  defp filter_empty(%{} = map) when map == %{}, do: nil
+  defp filter_empty(%{} = map), do: map
 
-  def acknowledged?(nil) do
-    true
-  end
+  @spec acknowledged?(nil | keyword | map) :: boolean
+  def acknowledged?(nil), do: true
 
-  def acknowledged?(write_concern) when is_map(write_concern) do
-    case Map.get(write_concern, :w) do
-      0 -> false
-      _ -> true
-    end
-  end
+  def acknowledged?(%{} = write_concern), do:
+    Map.get(write_concern, :w) != 0
 
-  def acknowledged?(write_concern) when is_list(write_concern) do
-    case Keyword.get(write_concern, :w) do
-      0 -> false
-      _ -> true
-    end
-  end
+  def acknowledged?(write_concern) when is_list(write_concern), do:
+    Keyword.get(write_concern, :w) != 0
 end

lib/session/session_pool.ex

@@ -11,6 +11,8 @@ defmodule Mongo.Session.SessionPool do
 
   alias Mongo.Session.ServerSession
 
+  @type session_pool() :: %{:pool_size => any, :queue => [ServerSession.t()], :timeout => any, optional(any) => any}
+
   def new(logical_session_timeout, opts \\ []) do
     pool_size = Keyword.get(opts, :session_pool, 1000)
 
@@ -25,7 +27,7 @@ defmodule Mongo.Session.SessionPool do
   Return a server session. If the session timeout is not reached, then a cached server session is return for reuse.
   Otherwise a newly created server session is returned.
   """
-  @spec checkout(GenServer.server()) :: ServerSession.t()
+  @spec checkout(session_pool()) :: {ServerSession.t(), session_pool()}
   @compile {:inline, checkout: 1}
   def checkout(%{queue: queue, timeout: timeout, pool_size: size} = pool) do
     {session, queue} = find_session(queue, timeout, size)
@@ -36,7 +38,7 @@ defmodule Mongo.Session.SessionPool do
   Checkin a used server session. It if is already expired, the server session is dropped. Otherwise the server session
   is cache for reuse, until it expires due of being cached all the time.
   """
-  @spec checkin(GenServer.server(), ServerSession.t()) :: none()
+  @spec checkin(session_pool(), ServerSession.t()) :: session_pool()
   @compile {:inline, checkin: 2}
   def checkin(%{queue: queue, timeout: timeout} = pool, session) do
     case ServerSession.about_to_expire?(session, timeout) do