inaka / dayron Goto Github PK

It seems that hexdoc.pm links the documentation with the source code in github, but those links are not working because of missing version tags.

• v0.1.0 has no tag.
• v0.1.1 tag is name does not follow the expectaction (it's missing the initial v).

• implement inspect protocol in request, response and error modules
• update logger to use new {request, response} tuple

When dealing with external services an important part of the equation is circuit breaking logic to avoid long timeouts during outages or network congestion. Is anything like this already planned?

• Add an example app where api requests authentication is made based on a current_user token field.
• Handle unauthorized api responses (401, 403)

Dayron needs to support custom request method and url combinations beyond the default ones.
A kind of router inside the model/resource would be a proper solution.

Hey there,

Currently, it seems that Dayron only supports data retrieval of endpoints that look like this:

[
    { "id": 0, "name": "Elem 1"},
    { "id": 1, "name": "Elem 2"}
]

Unfortunately I have to work with REST APIs that output data in a different way quite often. Some APIs add some additional metadata and therefore store the main result list in a specific property. Classic example:

{
"data": [
    { "id": 0, "name": "Elem 1"},
    { "id": 1, "name": "Elem 2"}
],
"count": 2
}

I made quick changes on my fork of Dayron that support this kind of data structure, those are tested in the model_test.ex file. I have also adressed this topic a bit in the README.MD file, as I feel it would have saved me a bit of time to have this specified in the readme.

Would you be interested in a pull request?

Note that some of our services also use the JSONApi.org specification, which is even more complex. Full support of JSONApi would probably be a big work (though if you are looking to build nested data mapping, you should check out how they handle it, it's quite interesting). However, I have also written small changes that allow Dayron to extract data from a JSONApi response. It's still quite early, it feels too unsure to push this publicly, but tell me if you're interested on this topic as well, as I will probably investigate it further.

Thanks

Dayron needs to support requests to nested resources, such as /posts/:id/comments

Since Ecto 2.0 is more data-centric we should research how to allow Ecto Schema functions and structures to provide data mapping of Dayron requests. It may allows easy associations/embed support.
Research if embedded_schema is the way to go.

Make it load config from system env if:

config :my_app, Dayron,
        url: {:system, "API_URL"}

The default HTTPoison adapter implementation decodes and creates atom keys, which may lead to unsolvable memory leaks.

I see here that __from_json__/2 assumes (in the default implementation) atom keys, but it doesn't have to.

Would it be worth revising that method default implementation to handle string keys, so that we avoid the problem altogether? If I'm not mistaken, we can leverage the schema as well at that point and generate it from the definition.

General Items

• It has a github repo
• It has a proper Apache2 LICENSE file
• It's has a clear and useful README.md
• It's documented (with examples)
• It's tested
• It's hooked to the open-source hipchat room
• It has a link to the open-source hipchat room in its README
• It has a link to inaka.github.io in its README and/or landing page

Exhibition

• There is a blog post about it
• It's shared on social networks
• It's shared on reddit
• It's shared on hacker news with a title like Show HN: description
• It has a landing page built in github pages

For Libraries

• It provides a sample application
• Examples of use are documented in the README or linked from there

For Erlang/Elixir Projects

• It's shared on Erlang Central
• It's published on Hex.pm

Hi,

I encountered an issue while using your lib to consume API.ai's api. A GET request is actually sending double quotes in body. After hours of debugging (I thought something was wrong with the headers sent), I found that we encode an empty body with Poison.encode even for a GET request.

This behavior causes API.ai to throw a 403 forbidden response.

I'm doing my first step in Elixir and functional programming, so I lack deep knowledge in how to solve in good manner this issue. Below is my attempt:

adapters/httpoison_adapter.ex, line ~24:

     def process_request_body(""), do: "" #tried to return nil but it's not catched by hackney library
     
     def process_request_body(body), do: Poison.encode!(body)

You can check this behavior using http://requestb.in/ and looking at the raw body of your GET request. it should be empty, it's not.

Looking for your advice and a proper fix!

It creates a MyApp.RestRepo module and basic configuration if possible

• create a logger behavior
• move current to a basic_logger
• accept logger setting in application config

Add support to Ecto.Changeset, casting field values, running validations before sending requests

The idea here is have a kind of plug and pipelines support. It would be something like faraday middlewares from ruby.
With the solution, we would be able to change the request data before it's sent, and change the response data after the request but before the mapping to a struct.
I did a quick research if we could use Plug structure for that, but in my opinion it does not support all response data or error handling we need.

• Check if Tesla is a good choice - https://github.com/teamon/tesla

I'm currently using Dayron to interact with a jsonapi.org spec API (and it's working great! 😄), but ran into an issue deserializing the data. The JSON-API spec returns either a top level data key or a top-level errors keys. This runs into an issue with Dayron because in Dayron.Model the first method that gets called is __from_json_list__/2 (

So, when JSON-API returns an array of records nested inside of the data attribute, Dayron sees there is no list at the root level, then it tries to apply the attributes to a struct, which results in an empty struct being returned.

I was able to correct his behavior by mapping the data key instead:

def __from_json_list__(%{data: data}, opts) do
  Enum.map(data, &__from_json__(&1, opts))
end

This also had the benefit of allowing me to match on the error key as well:

def __from_json_list__(%{errors: errors}, opts) do
  # ...
end

But this is not currently allowed by the Dayron library. I had to adjust the Dayron.Model to allow the __from_json_list/2` to be overridable, otherwise the library models took precedence:

# lib/dayron/model.ex#96
defoverridable [__url_for__: 1, __from_json__: 2, __from_json_list__: 2]

With the overridable change to the library and the custom __from_json_list__/2 method on the model, I was able to achieve the desired result.

• adapter should respond with it
• replace all HTTPoison.Response, HTTPoison.Error usage

• Research how Ecto manage the data mapping into associations and embed resources.
• Implement association fetch
• Implement embed data mapping

Tesla is a new Elixir Http Client with middleware support, similar to ruby faraday.

https://medium.com/@teamon/introducing-tesla-the-flexible-http-client-for-elixir-95b699656d88#.kfhd11vjv

• A simple generator as Ecto provides
• Research if importing models from an api schema.json file is possible