Add first implementation

Author: andrei.lepeshkin

.formatter.exs

@@ -0,0 +1,4 @@
+# Used by "mix format"
+[
+  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
+]

.gitignore

@@ -0,0 +1,27 @@
+# The directory Mix will write compiled artifacts to.
+/_build/
+
+# If you run "mix test --cover", coverage assets end up here.
+/cover/
+
+# The directory Mix downloads your dependencies sources to.
+/deps/
+
+# Where third-party dependencies like ExDoc output generated docs.
+/doc/
+
+# Ignore .fetch files in case you like to edit your project deps locally.
+/.fetch
+
+# If the VM crashes, it generates a dump, let's ignore it too.
+erl_crash.dump
+
+# Also ignore archive artifacts (built via "mix archive.build").
+*.ez
+
+# Ignore package tarball (built via "mix hex.build").
+jsonrpc2_plug-*.tar
+
+
+# Temporary files for e.g. tests
+/tmp

README.md

@@ -1,6 +1,6 @@
 # JSONRPC2Plug
 
-JSONRPC 2 plug
+JSON-RPC 2 plug
 
 ## Installation
 

lib/jsonrpc2_plug.ex

@@ -0,0 +1,23 @@
+defmodule JSONRPC2Plug do
+  def init(handler),
+    do: handler
+
+  @doc false
+  def call(%{method: "POST", body_params: %Plug.Conn.Unfetched{}}, _handler),
+    do: raise "Plug the JSONRPC2Plug after Plug.Parsers"
+
+  def call(%{method: "POST", body_params: body_params} = conn, handler) do
+    resp_body = case handler.handle(body_params, conn) do
+      []   -> ""
+      nil  -> ""
+      resp -> Poison.encode!(resp)
+    end
+
+    conn
+    |> Plug.Conn.put_resp_header("content-type", "application/json")
+    |> Plug.Conn.resp(200, resp_body)
+  end
+
+  def call(conn, _),
+    do: Plug.Conn.resp(conn, 404, "")
+end

lib/jsonrpc2_plug/error.ex

@@ -0,0 +1,29 @@
+defmodule JSONRPC2Plug.Error do
+  defstruct [:id, :error, jsonrpc: "2.0"]
+
+  @errors [
+    parse_error: {-32700, "Parse error"},
+    invalid_request: {-32600, "Invalid Request"},
+    method_not_found: {-32601, "Method not found"},
+    invalid_params: {-32602, "Invalid params"},
+    internal_error: {-32603, "Internal error"},
+    server_error: {-32000, "Server error"}
+  ]
+
+  def new(id, code, message),
+    do: %__MODULE__{id: id, error: %{code: code, message: message}}
+  def new(id, code, message, data),
+    do: %__MODULE__{id: id, error: %{code: code, message: message, data: data}}
+
+  def error(type),
+    do: error(type, nil)
+  def error(type, id) do
+    case Keyword.get(@errors, type) do
+      {code, message} ->
+        new(id, code, message)
+
+      nil ->
+        new(id, -32000, "Internal error")
+    end
+  end
+end

lib/jsonrpc2_plug/handler.ex

@@ -0,0 +1,101 @@
+defmodule JSONRPC2Plug.Handler do
+  require Logger
+
+  alias JSONRPC2Plug.Error
+  alias JSONRPC2Plug.Request
+  alias JSONRPC2Plug.Response
+
+  defmacro __using__(_) do
+    quote do
+      def handle(params, conn) do
+        unquote(__MODULE__).handle(__MODULE__, params, conn)
+      end
+
+      def handle_notification(method, params, conn),
+        do: handle_request(method, params, conn)
+
+      def handle_request(_method, _params, _conn),
+        do: error!(-32601, "Method not found")
+
+      def handle_error(exception, stacktrace),
+        do: Logger.error(Exception.format(:error, exception, stacktrace))
+
+      defoverridable [handle_request: 3, handle_error: 2, handle_notification: 3]
+
+      defp error!(code, message),
+        do: throw {:jsonrpc2, code, message}
+      defp error!(code, message, data),
+        do: throw {:jsonrpc2, code, message, data}
+    end
+  end
+
+  @doc false
+  def handle(module, data, conn) when is_list(data),
+    do: data |> Request.parse() |> handle_batch(module, conn)
+  def handle(module, data, conn),
+    do: data |> Request.parse() |> handle_one(module, conn)
+
+  defp handle_batch(data, module, conn),
+    do: Enum.map(data, fn(tuple) -> handle_one(tuple, module, conn) end) |> Enum.reject(&is_nil/1)
+
+  defp handle_one(%Error{} = error, _module, _conn),
+    do: error
+  defp handle_one(%Request{} = request, module, conn) do
+    if Request.valid?(request) do
+      dispatch(module, request, conn)
+    else
+      Error.error(:invalid_request, request.id)
+    end
+  end
+
+  defp dispatch(module, %{id: nil, method: method, params: params}, conn) do
+    try do
+      module.handle_notification(method, params, conn)
+      nil
+    rescue
+      ex ->
+        module.handle_error(ex, __STACKTRACE__)
+    catch
+      :throw, {:jsonrpc2, code, message} when is_integer(code) and is_binary(message) ->
+        nil
+
+      :throw, {:jsonrpc2, code, message, data} when is_integer(code) and is_binary(message) ->
+        nil
+
+      kind, payload ->
+        Logger.error([
+          "Error in handler ", inspect(module), " for method ", method, " with params: ",
+          inspect(params), ":\n\n", Exception.format(kind, payload, __STACKTRACE__)
+        ])
+
+        nil
+    end
+  end
+  defp dispatch(module, %{id: id, method: method, params: params}, conn) do
+    try do
+      method
+      |> module.handle_request(params, conn)
+      |> Response.new(id)
+    rescue
+      ex ->
+        module.handle_error(ex, __STACKTRACE__)
+    catch
+      :throw, {:jsonrpc2, code, message} when is_integer(code) and is_binary(message) ->
+        Error.new(id, code, message)
+
+      :throw, {:jsonrpc2, code, message, data} when is_integer(code) and is_binary(message) ->
+        Error.new(id, code, message, data)
+
+      kind, payload ->
+        Logger.error([
+          "Error in handler ", inspect(module), " for method ", method, " with params: ",
+          inspect(params), ":\n\n", Exception.format(kind, payload, __STACKTRACE__)
+        ])
+
+        Error.error(:internal_error, id)
+    end
+  end
+
+  defp dispatch(_module, _data, _conn),
+    do: Error.error(:invalid_request, nil)
+end

lib/jsonrpc2_plug/request.ex

@@ -0,0 +1,22 @@
+defmodule JSONRPC2Plug.Request do
+  defstruct [:id, :method, :params]
+
+  alias JSONRPC2Plug.Error
+
+  def parse([]),
+    do: Error.error(:invalid_request)
+  def parse(data) when is_list(data),
+    do: Enum.map(data, &parse_one/1)
+  def parse(data),
+    do: parse_one(data)
+
+  def valid?(%__MODULE__{id: _, method: method, params: params}),
+    do: is_binary(method) && (is_list(params) || is_map(params))
+
+  defp parse_one(%{"id" => id, "method" => method, "params" => params, "jsonrpc" => "2.0"}),
+    do: %__MODULE__{id: id, method: method, params: params}
+  defp parse_one(%{"id" => id}),
+    do: Error.error(:invalid_request, id)
+  defp parse_one(_),
+    do: Error.error(:invalid_request)
+end

lib/jsonrpc2_plug/response.ex

@@ -0,0 +1,6 @@
+defmodule JSONRPC2Plug.Response do
+  defstruct [:id, :result, jsonrpc: "2.0"]
+
+  def new(id, result),
+    do: %__MODULE__{id: id, result: result}
+end

mix.exs

@@ -0,0 +1,29 @@
+defmodule Jsonrpc2Plug.MixProject do
+  use Mix.Project
+
+  def project do
+    [
+      app: :jsonrpc2_plug,
+      version: "0.1.0",
+      elixir: "~> 1.11",
+      start_permanent: Mix.env() == :prod,
+      deps: deps()
+    ]
+  end
+
+  # Run "mix help compile.app" to learn about applications.
+  def application do
+    [
+      extra_applications: [:logger]
+    ]
+  end
+
+  # Run "mix help deps" to learn about dependencies.
+  defp deps do
+    [
+      {:poison, "~> 4.0"},
+      {:plug, "~> 1.12"},
+      {:dialyxir, "~> 0.3", only: :dev}
+    ]
+  end
+end

mix.lock

@@ -0,0 +1,8 @@
+%{
+  "dialyxir": {:hex, :dialyxir, "0.5.1", "b331b091720fd93e878137add264bac4f644e1ddae07a70bf7062c7862c4b952", [:mix], [], "hexpm", "6c32a70ed5d452c6650916555b1f96c79af5fc4bf286997f8b15f213de786f73"},
+  "mime": {:hex, :mime, "2.0.2", "0b9e1a4c840eafb68d820b0e2158ef5c49385d17fb36855ac6e7e087d4b1dcc5", [:mix], [], "hexpm", "e6a3f76b4c277739e36c2e21a2c640778ba4c3846189d5ab19f97f126df5f9b7"},
+  "plug": {:hex, :plug, "1.12.1", "645678c800601d8d9f27ad1aebba1fdb9ce5b2623ddb961a074da0b96c35187d", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "d57e799a777bc20494b784966dc5fbda91eb4a09f571f76545b72a634ce0d30b"},
+  "plug_crypto": {:hex, :plug_crypto, "1.2.2", "05654514ac717ff3a1843204b424477d9e60c143406aa94daf2274fdd280794d", [:mix], [], "hexpm", "87631c7ad914a5a445f0a3809f99b079113ae4ed4b867348dd9eec288cecb6db"},
+  "poison": {:hex, :poison, "4.0.1", "bcb755a16fac91cad79bfe9fc3585bb07b9331e50cfe3420a24bcc2d735709ae", [:mix], [], "hexpm", "ba8836feea4b394bb718a161fc59a288fe0109b5006d6bdf97b6badfcf6f0f25"},
+  "telemetry": {:hex, :telemetry, "1.0.0", "0f453a102cdf13d506b7c0ab158324c337c41f1cc7548f0bc0e130bbf0ae9452", [:rebar3], [], "hexpm", "73bc09fa59b4a0284efb4624335583c528e07ec9ae76aca96ea0673850aec57a"},
+}

test/jsonrpc2_plug/error_test.exs

@@ -0,0 +1,37 @@
+defmodule JSONRPC2Plug.ErrorTest do
+  use ExUnit.Case
+
+  alias JSONRPC2Plug.Error
+
+  describe ".error" do
+    test "Parse error" do
+      assert %Error{id: 123, error: %{code: -32700, message: "Parse error"}} = Error.error(:parse_error, 123)
+      assert %Error{id: nil, error: %{code: -32700, message: "Parse error"}} = Error.error(:parse_error)
+    end
+
+    test "Invalid Request" do
+      assert %Error{id: 123, error: %{code: -32600, message: "Invalid Request"}} = Error.error(:invalid_request, 123)
+      assert %Error{id: nil, error: %{code: -32600, message: "Invalid Request"}} = Error.error(:invalid_request)
+    end
+
+    test "Method not found" do
+      assert %Error{id: 123, error: %{code: -32601, message: "Method not found"}} = Error.error(:method_not_found, 123)
+      assert %Error{id: nil, error: %{code: -32601, message: "Method not found"}} = Error.error(:method_not_found)
+    end
+
+    test "Invalid params" do
+      assert %Error{id: 123, error: %{code: -32602, message: "Invalid params"}} = Error.error(:invalid_params, 123)
+      assert %Error{id: nil, error: %{code: -32602, message: "Invalid params"}} = Error.error(:invalid_params)
+    end
+
+    test "Internal error" do
+      assert %Error{id: 123, error: %{code: -32603, message: "Internal error"}} = Error.error(:internal_error, 123)
+      assert %Error{id: nil, error: %{code: -32603, message: "Internal error"}} = Error.error(:internal_error)
+    end
+
+    test "Server error" do
+      assert %Error{id: 123, error: %{code: -32000, message: "Server error"}} = Error.error(:server_error, 123)
+      assert %Error{id: nil, error: %{code: -32000, message: "Server error"}} = Error.error(:server_error)
+    end
+  end
+end

test/jsonrpc2_plug/request_test.exs

@@ -0,0 +1,33 @@
+defmodule JSONRPC2Plug.RequestTest do
+  use ExUnit.Case
+
+  alias JSONRPC2Plug.Error
+  alias JSONRPC2Plug.Request
+
+  describe ".parse" do
+    test "batch" do
+      assert %Error{id: nil, error: %{code: -32600, message: "Invalid Request"}} = Request.parse([])
+
+      example = [
+        %Error{id: 123, error: %{code: -32600, message: "Invalid Request"}},
+        %Request{id: 123, method: "test.method", params: [1, 2]}
+      ]
+
+      assert ^example = Request.parse([
+        %{"id" => 123},
+        %{"id" => 123, "method" => "test.method", "params" => [1, 2], "jsonrpc" => "2.0"}
+      ])
+    end
+
+    test "one request" do
+      assert %Error{id: nil, error: %{code: -32600, message: "Invalid Request"}} = Request.parse(%{})
+      assert %Error{id: 123, error: %{code: -32600, message: "Invalid Request"}} = Request.parse(%{"id" => 123})
+      assert %Request{id: 123, method: "test.method", params: [1, 2]} = Request.parse(%{
+        "id" => 123, "method" => "test.method", "params" => [1, 2], "jsonrpc" => "2.0"
+      })
+      assert %Request{id: 123, method: "test.method", params: %{"k1" => "v1"}} = Request.parse(%{
+        "id" => 123, "method" => "test.method", "params" => %{"k1" => "v1"}, "jsonrpc" => "2.0"
+      })
+    end
+  end
+end

test/jsonrpc2_plug_test.exs

@@ -0,0 +1,4 @@
+defmodule JSONRPC2PlugTest do
+  use ExUnit.Case
+  doctest JSONRPC2Plug
+end

test/test_helper.exs

@@ -0,0 +1 @@
+ExUnit.start()