Building a JSON API with Phoenix 1.3 and Elixir: A Step-by-Step Guide

Are you tired of looking at outdated or incomplete tutorials on how to build a JSON API using Elixir and Phoenix? Look no further! In this article, we'll take you through the process of creating a fully functional JSON API from scratch.

Creating a Sign in Endpoint with Session-Based Authentication

The first step is to create a sign-in endpoint that uses session-based authentication. This will allow users to authenticate themselves and receive a token that can be used to access protected routes. In Phoenix, this is achieved using the `Phoenix.Token` module.

Configuring CORS

Next, we need to configure CORS (Cross-Origin Resource Sharing) to enable communication between our API and frontend applications running on different ports or domains. This is important for security reasons and will allow us to use our API with a Vue.js frontend, for example.

Creating a Users Endpoint

Now that we have our sign-in endpoint set up, it's time to create a users endpoint. This will allow us to get a list of all users, create new users, and delete existing ones.

Creating a User Schema Module (Model) and Hashing Passwords

To store user data securely, we need to create a user schema module that defines the structure of our user data. We'll also hash passwords using the `Comeonin` library to prevent unauthorized access.

Creating a New API-Only Phoenix Application

Before we start building our API, let's quickly create a new Phoenix application without HTML and JavaScript files. This will keep things simple and focused on building an API-only application.

Quickstart Guide for a New Vue.js Project

To complement your API, I recommend using Vue.js as the frontend framework. Here's a quickstart guide to get you started:

1. Install Vue.js using npm or yarn.

2. Create a new Vue.js project with `vue create my-app`.

3. Install the required dependencies for your app.

In this article, we've covered the basics of building a JSON API with Phoenix and Elixir. We've created a sign-in endpoint, configured CORS, created a users endpoint, and defined a user schema module. With these steps, you should now have a fully functional JSON API that can be used as the backend for your web application.

Test Case

Here's an example of how you might use Ecto to map data to structs:

```elixir

defmodule EmbedsOne do

@schema '

embeds_one :commit,

embeds_many :branches,

embeds_one :repository,

ref from_json(data) when is_binary(data)

end

```

This code defines a `EmbedsOne` module that uses Ecto to map data to structs. The `@schema` attribute specifies the structure of our data, including embedded structs and references.

Future Development

In future articles, we'll explore more advanced topics such as using JWT (JSON Web Tokens) for authentication and building a fully integrated frontend with Vue.js. Stay tuned!

Read in json file elixir ecto