Building a Bingo game backend with encore.dev

$ brew install encoredev/tap/encore
//then run 
$ encore app create

 and see the "API Explorer" which is a nice interface that lists all our API endpoints so we can trigger the request from there with a custom body, params and all that
![encore api explorer](https://i.imgur.com/bSQuZfR.png)
There's also a nice thing about this app that encore creates for us, we also have available an auto generated API docs which specify a little description about the API endpoint, the params types and response schema of each defined endpoint

## Creating our bingo database and migration

In this post I won't be generating all the authentication part of the app, since it's a small project, I will be creating the following routes with it's functionality:
- User creation route (with a number list)
- Randomizer route (to get a random number and compare to the number list of a specified user)

### Doing the migration
So let's start with how the migration of the user is going to look, to create the right file, we need to add a new folder called

 ```bingo```

 on the root of the project, then create a

 ```migration```

 folder with a file on it called

 ```1_create_user_table.up.sql```

, 
__Notes:__
- the number of the file means the order that the migrations are going to be executed
- after the first underscore (_) comes the name of the migration
- we have to add the extension

 ```.up.sql```

 to all migrations



```sql
CREATE TABLE client (
  email TEXT PRIMARY KEY,
  list INTEGER []
);

 file inside the bingo folder to create our routes inside of it.

first we need to include the package name which should match the folder name (our bingo service) then after that we should define our imports and include encore sqldb handler inside of it


```go
package bingo

import (
    "context"

    "encore.dev/storage/sqldb"
)

type UserParams struct {
    Email string
}

type RegisterResponse struct {
    Email string
    List  []int
}

//encore:api public
func RegisterUser(ctx context.Context, params *UserParams) (*RegisterResponse, error) {
    var list = generateList(0, 100)
    var user RegisterResponse
    err := sqldb.QueryRow(ctx, `
    INSERT INTO "client" (email, list)
    VALUES ($1, $2)
    RETURNING *;
  `, params.Email, list).Scan(&user.Email, &user.List)
    if err != nil {
        return nil, err
    }
    return &user, nil
}

func generateList(min, max int) []int {
    a := make([]int, max-min+1)
    for i := range a {
        a[i] = min + i
    }
    return a
}

//encore:api public
func DrawFromList(ctx context.Context, params *UserParams) (*DrawResponse, error) {
    var list []int // empty list to be asssigned after the SQL query
    err := sqldb.QueryRow(ctx, `
    SELECT list from "client"
    WHERE email = ($1)`, params.Email).Scan(&list)
    if err != nil {
        return nil, err
    }
  var response DrawResponse
  // generate a random number everytime you hit the request 
    rand.Seed(time.Now().UnixNano())
    var randomIndex = rand.Intn(len(list) - list[0] + 1 + list[0])
  // assign the random number to the response selected struct
    response.Selected = list[randomIndex]
  //remove the item from the array by the index
    list = RemoveIndex(list, randomIndex)
  // update the list of the user with the new one without the selected item
    sqldb.QueryRow(ctx, `
    UPDATE "client"
    SET list = ($1)
    WHERE email = ($2)`, list, params.Email)
    response.Removed = true
    return &response, nil
}

//Function to remove an item from an array by the index
func RemoveIndex(s []int, index int) []int {
    return append(s[:index], s[index+1:]...)
}

curl --location --request POST 'https://bingo-c7m2.encoreapi.com/prod/bingo.RegisterUser' \
--header 'Content-Type: application/json' \
--data-raw '{
    "Email": "your-mail@gg.com"
}'

curl --location --request POST 'https://bingo-c7m2.encoreapi.com/prod/bingo.DrawFromList' \
--header 'Content-Type: application/json' \
--data-raw '{
    "Email": "your-mail@gg.com"
}'