/v1/movies?title=godfather&genres=crime,drama&page=1&page_size=5&sort=-year

package main

import (
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"strconv"
	"strings"

	"github.com/julienschmidt/httprouter"
	"github.com/nahuelev23/greenlight/internal/validator"
)
...


// The readString() helper returns a string value from the query string, or the provided
// default value if no matching key could be found.
func (app *application) readString(qs url.Values, key string, defaultValue string) string {
	// Extract the value for a given key from the query string. If no key exists this
	// will return the empty string "".
	s := qs.Get(key)
	// If no key exists (or the value is empty) then return the default value.
	if s == "" {
		return defaultValue
	}
	// Otherwise return the string.
	return s
}

// The readCSV() helper reads a string value from the query string and then splits it
// into a slice on the comma character. If no matching key could be found, it returns
// the provided default value.
func (app *application) readCSV(qs url.Values, key string, defaultValue []string) []string {
	// Extract the value from the query string.
	csv := qs.Get(key)
	// If no key exists (or the value is empty) then return the default value.
	if csv == "" {
		return defaultValue
	}
	// Otherwise parse the value into a []string slice and return it.
	return strings.Split(csv, ",")
}

// The readInt() helper reads a string value from the query string and converts it to an
// integer before returning. If no matching key could be found it returns the provided
// default value. If the value couldn't be converted to an integer, then we record an
// error message in the provided Validator instance.
func (app *application) readInt(qs url.Values, key string, defaultValue int, v *validator.Validator) int {
	// Extract the value from the query string.
	s := qs.Get(key)
	// If no key exists (or the value is empty) then return the default value.
	if s == "" {
		return defaultValue
	}
	// Try to convert the value to an int. If this fails, add an error message to the
	// validator instance and return the default value.
	i, err := strconv.Atoi(s)
	if err != nil {
		v.AddError(key, "must be an integer value")
		return defaultValue
	}
	// Otherwise, return the converted integer value.
	return i
}

func (app *application) listMoviesHandler(w http.ResponseWriter, r *http.Request) {
	// To keep things consistent with our other handlers, we'll define an input struct
	// to hold the expected values from the request query string.
	var input struct {
		Title    string
		Genres   []string
		Page     int
		PageSize int
		Sort     string
	}
	// Initialize a new Validator instance.
	v := validator.New()
	// Call r.URL.Query() to get the url.Values map containing the query string data.
	qs := r.URL.Query()
	// Use our helpers to extract the title and genres query string values, falling back
	// to defaults of an empty string and an empty slice respectively if they are not
	// provided by the client.
	input.Title = app.readString(qs, "title", "")
	input.Genres = app.readCSV(qs, "genres", []string{})
	// Get the page and page_size query string values as integers. Notice that we set
	// the default page value to 1 and default page_size to 20, and that we pass the
	// validator instance as the final argument here.
	input.Page = app.readInt(qs, "page", 1, v)
	input.PageSize = app.readInt(qs, "page_size", 20, v)
	// Extract the sort query string value, falling back to "id" if it is not provided
	// by the client (which will imply a ascending sort on movie ID).
	input.Sort = app.readString(qs, "sort", "id")
	// Check the Validator instance for any errors and use the failedValidationResponse()
	// helper to send the client a response if necessary.
	if !v.Valid() {
		app.failedValidationResponse(w, r, v.Errors)
		return
	}
	// Dump the contents of the input struct in a HTTP response.
	fmt.Fprintf(w, "%+v\n", input)
}

func (app *application) routes() http.Handler {
	router := httprouter.New()

	router.NotFound = http.HandlerFunc(app.notFoundResponse)

	router.MethodNotAllowed = http.HandlerFunc(app.methodNotAllowedResponse)

	router.HandlerFunc(http.MethodGet, "/v1/healthcheck", app.healthcheckHandler)

	// Add the route for the GET /v1/movies endpoint.
	router.HandlerFunc(http.MethodGet, "/v1/movies", app.listMoviesHandler)
	router.HandlerFunc(http.MethodPost, "/v1/movies", app.createMovieHandler)
	router.HandlerFunc(http.MethodGet, "/v1/movies/:id", app.showMovieHandler)
	router.HandlerFunc(http.MethodPatch, "/v1/movies/:id", app.updateMovieHandler)
	router.HandlerFunc(http.MethodDelete, "/v1/movies/:id", app.deleteMovieHandler)

	return app.recoverPanic(router)
}

$ curl "localhost:4000/v1/movies?title=godfather&genres=crime,drama&page=1&page_size=5&sort=year"
{Title:godfather Genres:[crime drama] Page:1 PageSize:5 Sort:year

$ curl localhost:4000/v1/movies
{Title: Genres:[] Page:1 PageSize:20 Sort:id}

$ touch internal/data/filters.go

package data

type Filters struct {
	Page     int
	PageSize int
	Sort     string
}

func (app *application) listMoviesHandler(w http.ResponseWriter, r *http.Request) {

// Embed the new Filters struct
  var input struct {
  		Title    string
  		Genres   []string
-  		Page     int
-  		PageSize int
-  		Sort     string
+     data.Filters
	}

	v := validator.New()

	qs := r.URL.Query()

	input.Title = app.readString(qs, "title", "")
	input.Genres = app.readCSV(qs, "genres", []string{})

	// Read the page and page_size query string values into the embedded struct.
	input.Filters.Page = app.readInt(qs, "page", 1, v)
	input.Filters.PageSize = app.readInt(qs, "page_size", 20, v)

	// Read the sort query string value into the embedded struct.
	input.Filters.Sort = app.readString(qs, "sort", "id")

	if !v.Valid() {
		app.failedValidationResponse(w, r, v.Errors)
		return
	}

	fmt.Fprintf(w, "%+v\n", input)
}

$ curl "localhost:4000/v1/movies?page=abc&page_size=abc"
{
  "error": {
    "page": "debe ser un valor entero",
    "page_size": "debe ser un valor entero"
  }
}

package data

import "github.com/nahuelev23/greenlight/internal/validator"

// Add a SortSafelist field to hold the supported sort values.
type Filters struct {
	Page         int
	PageSize     int
	Sort         string
	SortSafelist []string
}

func ValidateFilters(v *validator.Validator, f Filters) {
	// Check that the page and page_size parameters contain sensible values.
	v.Check(f.Page > 0, "page", "must be greater than zero")
	v.Check(f.Page <= 10_000_000, "page", "must be a maximum of 10 million")
	v.Check(f.PageSize > 0, "page_size", "must be greater than zero")
	v.Check(f.PageSize <= 100, "page_size", "must be a maximum of 100")
	// Check that the sort parameter matches a value in the safelist.
	v.Check(validator.PermittedValue(f.Sort, f.SortSafelist...), "sort", "invalid sort value")
}

func (app *application) listMoviesHandler(w http.ResponseWriter, r *http.Request) {

	// Embed the new Filters struct
	var input struct {
		Title  string
		Genres []string
		data.Filters
	}

	v := validator.New()

	qs := r.URL.Query()

	input.Title = app.readString(qs, "title", "")
	input.Genres = app.readCSV(qs, "genres", []string{})

	input.Filters.Page = app.readInt(qs, "page", 1, v)
	input.Filters.PageSize = app.readInt(qs, "page_size", 20, v)

	input.Filters.Sort = app.readString(qs, "sort", "id")
	// Add the supported sort values for this endpoint to the sort safelist.
	input.Filters.SortSafelist = []string{"id", "title", "year", "runtime", "-id", "-title", "-year", "-runtime"}

	// Execute the validation checks on the Filters struct and send a response
	// containing the errors if necessary.
	if data.ValidateFilters(v, input.Filters); !v.Valid() {
		app.failedValidationResponse(w, r, v.Errors)
		return

	}

	fmt.Fprintf(w, "%+v\n", input)
}

$ curl "localhost:4000/v1/movies?page=-1&page_size=-1&sort=foo"
{
  "error": {
    "page": "must be greater than zero",
    "page_size": "must be greater than zero",
    "sort": "invalid sort value"
  }
}

{
  "movies": [
    {
      "id": 1,
      "title": "Moana",
      "year": 2015,
      "runtime": "107 mins",
      "genres": [
        "animation",
        "adventure"
      ],
      "version": 1
    },
    {
      "id": 2,
      "title": "Black Panther",
      "year": 2018,
      "runtime": "134 mins",
      "genres": [
        "sci-fi",
        "action",
        "adventure"
      ],
      "version": 2
    },
    ... etc.
  ]
}

SELECT id, created_at, title, year, runtime, genres, version
FROM movies
ORDER BY id

// Create a new GetAll() method which returns a slice of movies. Although we're not
// using them right now, we've set this up to accept the various filter parameters as
// arguments.
func (m MovieModel) GetAll(title string, genres []string, filters Filters) ([]*Movie, error) {
	// Construct the SQL query to retrieve all movie records.
	query := `
	SELECT id, created_at, title, year, runtime, genres, version
	FROM movies
	ORDER BY id`
	// Create a context with a 3-second timeout.
	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()
	// Use QueryContext() to execute the query. This returns a sql.Rows resultset
	// containing the result.
	rows, err := m.DB.QueryContext(ctx, query)
	if err != nil {
		return nil, err
	}
	// Importantly, defer a call to rows.Close() to ensure that the resultset is closed
	// before GetAll() returns.
	defer rows.Close()
	// Initialize an empty slice to hold the movie data.
	movies := []*Movie{}
	// Use rows.Next to iterate through the rows in the resultset.
	for rows.Next() {
		// Initialize an empty Movie struct to hold the data for an individual movie.
		var movie Movie
		// Scan the values from the row into the Movie struct. Again, note that we're
		// using the pq.Array() adapter on the genres field here.
		err := rows.Scan(
			&movie.ID,
			&movie.CreatedAt,
			&movie.Title,
			&movie.Year,
			&movie.Runtime,
			pq.Array(&movie.Genres),
			&movie.Version,
		)
		if err != nil {
			return nil, err
		}
		// Add the Movie struct to the slice.
		movies = append(movies, &movie)
	}
	// When the rows.Next() loop has finished, call rows.Err() to retrieve any error
	// that was encountered during the iteration.
	if err = rows.Err(); err != nil {
		return nil, err
	}
	// If everything went OK, then return the slice of movies.
	return movies, nil
}

func (app *application) listMoviesHandler(w http.ResponseWriter, r *http.Request) {

	// Embed the new Filters struct
	var input struct {
		Title  string
		Genres []string
		data.Filters
	}

	v := validator.New()

	qs := r.URL.Query()

	input.Title = app.readString(qs, "title", "")
	input.Genres = app.readCSV(qs, "genres", []string{})

	input.Filters.Page = app.readInt(qs, "page", 1, v)
	input.Filters.PageSize = app.readInt(qs, "page_size", 20, v)

	input.Filters.Sort = app.readString(qs, "sort", "id")
	input.Filters.SortSafelist = []string{"id", "title", "year", "runtime", "-id", "-title", "-year", "-runtime"}

	if data.ValidateFilters(v, input.Filters); !v.Valid() {
		app.failedValidationResponse(w, r, v.Errors)
		return

	}

	// Call the GetAll() method to retrieve the movies, passing in the various filter
	// parameters.
	movies, err := app.models.Movies.GetAll(input.Title, input.Genres, input.Filters)
	if err != nil {
		app.serverErrorResponse(w, r, err)
		return
	}
	// Send a JSON response containing the movie data.
	err = app.writeJSON(w, http.StatusOK, envelope{"movies": movies}, nil)
	if err != nil {
		app.serverErrorResponse(w, r, err)
	}
}

$ curl localhost:4000/v1/movies
{
  "movies": [
    {
      "id": 1,
      "title": "Moana",
      "year": 2016,
      "runtime": "107 mins",
      "genres": [
        "animation",
        "adventure"
      ],
      "version": 1
    },
    {
      "id": 2,
      "title": "Black Panther",
      "year": 2018,
      "runtime": "134 mins",
      "genres": [
        "sci-fi",
        "action",
        "adventure"
      ],
      "version": 2
    },
    {
      "id": 4,
      "title": "The Breakfast Club",
      "year": 1985,
      "runtime": "97 mins",
      "genres": [
        "comedy"
      ],
      "version": 5
    }
  ]
}

// List all movies.
/v1/movies
// List movies where the title is a case-insensitive exact match for 'black panther'.
/v1/movies?title=black+panther
// List movies where the genres includes 'adventure'.
/v1/movies?genres=adventure
// List movies where the title is a case-insensitive exact match for 'moana' AND the
// genres include both 'animation' AND 'adventure'.
/v1/movies?title=moana&genres=animation,adventure

SELECT id, created_at, title, year, runtime, genres, version
FROM movies
WHERE (LOWER(title) = LOWER($1) OR $1 = '')
AND (genres @> $2 OR $2 = '{}')
ORDER BY id

input.Title = app.readString(qs, "title", "")
input.Genres = app.readCSV(qs, "genres", []string{})

  func (m MovieModel) GetAll(title string, genres []string, filters Filters) ([]*Movie, error) {
+  		// Update the SQL query to include the filter conditions.
+  		query := `
+  		SELECT id, created_at, title, year, runtime, genres, version
+  		FROM movies
+  		WHERE (LOWER(title) = LOWER($1) OR $1 = '')
+  		AND (genres @> $2 OR $2 = '{}')
+  		ORDER BY id`

  	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
  	defer cancel()

+  	rows, err := m.DB.QueryContext(ctx, query,title,pq.Array(genres))
  	if err != nil {
  		return nil, err
  	}

  	defer rows.Close()

  	movies := []*Movie{}

  	for rows.Next() {

  		var movie Movie

  		err := rows.Scan(
  			&movie.ID,
  			&movie.CreatedAt,
  			&movie.Title,
  			&movie.Year,
  			&movie.Runtime,
  			pq.Array(&movie.Genres),
  			&movie.Version,
  		)
  		if err != nil {
  			return nil, err
  		}

  		movies = append(movies, &movie)
  	}

  	if err = rows.Err(); err != nil {
  		return nil, err
  	}

  	return movies, nil
  }

$ curl "localhost:4000/v1/movies?title=black+panther"
{
	"movies": [
	{
		"id": 2,
		"title": "Black Panther",
		"year": 2018,
		"runtime": "134 mins",
		"genres": [
			"sci-fi",
			"action",
			"adventure"
		],
		"version": 2
		}
	]
}

$ curl "localhost:4000/v1/movies?genres=adventure"
{
  "movies": [
    {
      "id": 1,
      "title": "Moana",
      "year": 2015,
      "runtime": "107 mins",
      "genres": [
        "animation",
        "adventure"
      ],
      "version": 1
    },
    {
      "id": 2,
      "title": "Black Panther",
      "year": 2018,
      "runtime": "134 mins",
      "genres": [
        "sci-fi",
        "action",
        "adventure"
      ],
      "version": 2
    }
  ]
}

$ curl "localhost:4000/v1/movies?title=moana&genres=animation,adventure"
{
  "movies": [
    {
      "id": 1,
      "title": "Moana",
      "year": 2016,
      "runtime": "107 mins",
      "genres": [
        "animation",
        "adventure"
      ],
      "version": 1
    }
  ]
}

$ curl "localhost:4000/v1/movies?genres=western"
{
  "movies": []
}

SELECT id, created_at, title, year, runtime, genres, version
FROM movies
WHERE (to_tsvector('simple', title) @@ plainto_tsquery('simple', $1) OR $1 = '')
AND (genres @> $2 OR $2 = '{}')
ORDER BY id

// Return all movies where the title includes the case-insensitive word 'panther'.
/v1/movies?title=panther
// Return all movies where the title includes the case-insensitive words 'the' and
// 'club'.
/v1/movies?title=the+club

package main

func (m MovieModel) GetAll(title string, genres []string, filters Filters) ([]*Movie, error) {
	// Use full-text search for the title filter.
	query := `
		SELECT id, created_at, title, year, runtime, genres, version
		FROM movies
		WHERE (to_tsvector('simple', title) @@ plainto_tsquery('simple', $1) OR $1 = '')
		AND (genres @> $2 OR $2 = '{}')
		ORDER BY id`

...
}

$ curl "localhost:4000/v1/movies?title=panther"
{
  "movies": [
    {
      "id": 2,
      "title": "Black Panther",
      "year": 2018,
      "runtime": "134 mins",
      "genres": [
        "sci-fi",
        "action",
        "adventure"
      ],
      "version": 2
    }
  ]
}

$ curl "localhost:4000/v1/movies?title=the+club"
{
  "movies": [
    {
      "id": 4,
      "title": "The Breakfast Club",
      "year": 1985,
      "runtime": "97 mins",
      "genres": [
        "comedy"
      ],
      "version": 5
    }
  ]
}

migrate create -seq -ext .sql -dir ./migrations add_movies_indexes

CREATE INDEX IF NOT EXISTS movies_title_idx ON movies USING GIN (to_tsvector('simple', title));
CREATE INDEX IF NOT EXISTS movies_genres_idx ON movies USING GIN (genres);

DROP INDEX IF EXISTS movies_title_idx;
DROP INDEX IF EXISTS movies_genres_idx;

$ migrate -path ./migrations -database $GREENLIGHT_DB_DSN up
3/u add_movies_indexes (38.638777ms)

postgres=# \dF
List of text search configurations
Schema      | Name    | Description
------------+---------+---------------------------------------
pg_catalog  | arabic  | configuration for arabic language
pg_catalog  | danish  | configuration for danish language
pg_catalog  | dutch   | configuration for dutch language
pg_catalog  | english | configuration for english language
...

SELECT id, created_at, title, year, runtime, genres, version
FROM movies
WHERE (to_tsvector('english', title) @@ plainto_tsquery('english', $1) OR $1 = '')
AND (genres @> $2 OR $2 = '{}')
ORDER BY id

SELECT id, created_at, title, year, runtime, genres, version
FROM movies
WHERE (STRPOS(LOWER(title), LOWER($1)) > 0 OR $1 = '')
AND (genres @> $2 OR $2 = '{}')
ORDER BY id;

SELECT id, created_at, title, year, runtime, genres, version
FROM movies
WHERE (title ILIKE $1 OR $1 = '')
AND (genres @> $2 OR $2 = '{}')
ORDER BY id;

// Ordenar las películas por el campo de título en orden alfabético ascendente.
/v1/movies?sort=title
// Ordenar las películas por el campo de año en orden numérico descendente.
/v1/movies?sort=-year

SELECT id, created_at, title, year, runtime, genres, version
FROM movies
WHERE (STRPOS(LOWER(title), LOWER($1)) > 0 OR $1 = '')
AND (genres @> $2 OR $2 = '{}')
ORDER BY year DESC;

SELECT id, created_at, title, year, runtime, genres, version
FROM movies
WHERE (STRPOS(LOWER(title), LOWER($1)) > 0 OR $1 = '')
AND (genres @> $2 OR $2 = '{}')
ORDER BY year DESC, id ASC;

package data

import (
    "strings" // Nuevo import
    "greenlight.nahueldev23.net/internal/validator"
)

type Filters struct {
    Page       int
    PageSize   int
    Sort       string
    SortSafelist []string
}

// Comprueba que el campo Sort proporcionado por el cliente coincida con una de las entradas de nuestra lista blanca
// y si lo hace, extrae el nombre de la columna del campo Sort eliminando el carácter de guion inicial
// (si existe).
func (f Filters) sortColumn() string {
    for _, safeValue := range f.SortSafelist {
        if f.Sort == safeValue {
            return strings.TrimPrefix(f.Sort, "-")
        }
    }
    panic("parámetro de ordenación no seguro: " + f.Sort)
}

// Devuelve la dirección de ordenación ("ASC" o "DESC") dependiendo del carácter de prefijo del
// campo Sort.
func (f Filters) sortDirection() string {
    if strings.HasPrefix(f.Sort, "-") {
        return "DESC"
    }
    return "ASC"
}

func (m MovieModel) GetAll(title string, genres []string, filters Filters) ([]*Movie, error) {
	// Add an ORDER BY clause and interpolate the sort column and direction. Importantly
	// notice that we also include a secondary sort on the movie ID to ensure a
	// consistent ordering.
	query := fmt.Sprintf(`
		SELECT id, created_at, title, year, runtime, genres, version
		FROM movies
		WHERE (to_tsvector('simple', title) @@ plainto_tsquery('simple', $1) OR $1 = '')
		AND (genres @> $2 OR $2 = '{}')
		ORDER BY %s %s, id ASC`, filters.sortColumn(), filters.sortDirection())

		// Nothing else below needs to change.
...
}

$ curl "localhost:4000/v1/movies?sort=-title"
{
  "movies": [
    {
      "id": 4,
      "title": "The Breakfast Club",
      "year": 1985,
      "runtime": "97 mins",
      "genres": [
        "comedy"
      ],
      "version": 5
    },
    {
      "id": 1,
      "title": "Moana",
      "year": 2016,
      "runtime": "107 mins",
      "genres": [
        "animation",
        "adventure"
      ],
      "version": 1
    },
    {
      "id": 2,
      "title": "Black Panther",
      "year": 2018,
      "runtime": "134 mins",
      "genres": [
        "sci-fi",
        "action",
        "adventure"
      ],
      "version": 2
    }
  ]
}

$ curl "localhost:4000/v1/movies?sort=-runtime"
{
  "movies": [
    {
      "id": 2,
      "title": "Black Panther",
      "year": 2018,
      "runtime": "134 mins",
      "genres": [
        "sci-fi",
        "action",
        "adventure"
      ],
      "version": 2
    },
    {
      "id": 1,
      "title": "Moana",
      "year": 2016,
      "runtime": "107 mins",
      "genres": [
        "animation",
        "adventure"
      ],
      "version": 1
    },
    {
      "id": 4,
      "title": "The Breakfast Club",
      "year": 1985,
      "runtime": "97 mins",
      "genres": [
        "comedy"
      ],
      "version": 5
    }
  ]
}

// Return the 5 records on page 1 (records 1-5 in the dataset)
/v1/movies?page=1&page_size=5
// Return the next 5 records on page 2 (records 6-10 in the dataset)
/v1/movies?page=2&page_size=5
// Return the next 5 records on page 3 (records 11-15 in the dataset)
/v1/movies?page=3&page_size=5

LIMIT = page_size
OFFSET = (page - 1) * page_size

/v1/movies?page_size=5&page=3

SELECT id, created_at, title, year, runtime, genres, version
FROM movies
WHERE (to_tsvector('simple', title) @@ plainto_tsquery('simple', $1) OR $1 = '')
AND (genres @> $2 OR $2 = '{}')
ORDER BY %s %s, id ASC
LIMIT 5 OFFSET 10

package data

type Filters struct {
	Page         int
	PageSize     int
	Sort         string
	SortSafelist []string
}

...
func (f Filters) limit() int {
	return f.PageSize
}
func (f Filters) offset() int {
	return (f.Page - 1) * f.PageSize
}

package data

import (
	"context"
	"fmt"
	"time"

	"github.com/lib/pq"
)

func (m MovieModel) GetAll(title string, genres []string, filters Filters) ([]*Movie, error) {
	// Update the SQL query to include the LIMIT and OFFSET clauses with placeholder
	// parameter values.
	query := fmt.Sprintf(`
		SELECT id, created_at, title, year, runtime, genres, version
		FROM movies
		WHERE (to_tsvector('simple', title) @@ plainto_tsquery('simple', $1) OR $1 = '')
		AND (genres @> $2 OR $2 = '{}')
		ORDER BY %s %s, id ASC
		LIMIT $3 OFFSET $4`, filters.sortColumn(), filters.sortDirection())

	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()

	// As our SQL query now has quite a few placeholder parameters, let's collect the
	// values for the placeholders in a slice. Notice here how we call the limit() and
	// offset() methods on the Filters struct to get the appropriate values for the
	// LIMIT and OFFSET clauses.
	args := []interface{}{title, pq.Array(genres), filters.limit(), filters.offset()}

	// And then pass the args slice to QueryContext() as a variadic parameter.
	rows, err := m.DB.QueryContext(ctx, query, args...)
	if err != nil {
		return nil, err
	}

	// Nothing else below needs to change.
	// ...
}

$ curl "localhost:4000/v1/movies?page_size=2"
{
  "movies": [
    {
      "id": 1,
      "title": "Moana",
      "year": 2016,
      "runtime": "107 mins",
      "genres": ["animation", "adventure"],
      "version": 1
    },
    {
      "id": 2,
      "title": "Black Panther",
      "year": 2018,
      "runtime": "134 mins",
      "genres": ["sci-fi", "action", "adventure"],
      "version": 2
    }
  ]
}

# IMPORTANTE: Esta URL debe estar rodeada de comillas dobles para funcionar correctamente.
$ curl "localhost:4000/v1/movies?page_size=2&page=2"
{
  "movies": [
    {
      "id": 4,
      "title": "The Breakfast Club",
      "year": 1985,
      "runtime": "97 mins",
      "genres": ["comedy"],
      "version": 5
    }
  ]
}

$ curl "localhost:4000/v1/movies?page_size=2&page=3"
{
  "movies": []
}

{
  "metadata": {
    "current_page": 1,
    "page_size": 20,
    "first_page": 1,
    "last_page": 42,
    "total_records": 832
  },
  "movies": [
    {
      "id": 1,
      "title": "Moana",
      "year": 2015,
      "runtime": "107 mins",
      "genres": [
        "animation",
        "adventure"
      ],
      "version": 1
    },
    // ... Otras películas ...
  ]
}

SELECT
  count(*) OVER(),
  id,
  created_at,
  title,
  year,
  runtime,
  genres,
  version
FROM
  movies
WHERE
  (to_tsvector('simple', title) @@ plainto_tsquery('simple', $1) OR $1 = '')
  AND (genres @> $2 OR $2 = '{}')
ORDER BY
  %s %s, id ASC
LIMIT
  $3 OFFSET $4;

 count | id |      created_at       |        title         | year | runtime |         genres          | version
-------+----+------------------------+----------------------+------+---------+------------------------+---------
     3 |  1 | 2020-11-27 17:17:25+01 | Moana                | 2015 |     107 | {animation,adventure}  |       1
     3 |  2 | 2020-11-27 18:01:45+01 | Black Panther        | 2018 |     134 | {sci-fi,action,adventure}|       2
     3 |  4 | 2020-11-27 18:02:20+01 | The Breakfast Club   | 1985 |      97 | {comedy,drama}          |       6

package data

import (
	"math" // Nuevo import
	"strings"
	"nahueldev23/internal/validator"
)

// ...

// Define una nueva estructura Metadata para contener los metadatos de paginación.
type Metadata struct {
	CurrentPage   int `json:"current_page,omitempty"`
	PageSize      int `json:"page_size,omitempty"`
	FirstPage     int `json:"first_page,omitempty"`
	LastPage      int `json:"last_page,omitempty"`
	TotalRecords  int `json:"total_records,omitempty"`
}

// La función calculateMetadata() calcula los valores apropiados de metadatos de paginación
// dados el número total de registros, la página actual y el tamaño de la página. Ten en cuenta
// que el valor de la última página se calcula usando la función math.Ceil(), que redondea
// hacia arriba un número flotante al entero más cercano. Así que, por ejemplo, si hay 12 registros
// en total y un tamaño de página de 5, el valor de la última página sería math.Ceil(12/5) = 3.
func calculateMetadata(totalRecords, page, pageSize int) Metadata {
	if totalRecords == 0 {
		// Ten en cuenta que devolvemos una estructura Metadata vacía si no hay registros.
		return Metadata{}
	}
	return Metadata{
		CurrentPage:  page,
		PageSize:     pageSize,
		FirstPage:    1,
		LastPage:     int(math.Ceil(float64(totalRecords) / float64(pageSize))),
		TotalRecords: totalRecords,
	}
}

package data

import (
	"context"
	"fmt"
	"time"

	"github.com/lib/pq"
)

// Actualiza la firma de la función para devolver una estructura Metadata.
func (m MovieModel) GetAll(title string, genres []string, filters Filters) ([]*Movie, Metadata, error) {
	// Actualiza la consulta SQL para incluir la función de ventana que cuenta el total de registros (filtrados).
	query := fmt.Sprintf(`
SELECT count(*) OVER(), id, created_at, title, year, runtime, genres, version
FROM movies
WHERE (to_tsvector('simple', title) @@ plainto_tsquery('simple', $1) OR $1 = '')
AND (genres @> $2 OR $2 = '{}')
ORDER BY %s %s, id ASC
LIMIT $3 OFFSET $4`, filters.sortColumn(), filters.sortDirection())

	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()

	args := []interface{}{title, pq.Array(genres), filters.limit(), filters.offset()}
	rows, err := m.DB.QueryContext(ctx, query, args...)
	if err != nil {
		return nil, Metadata{}, err // Actualiza esto para devolver una estructura Metadata vacía.
	}
	defer rows.Close()

	// Declara una variable totalRecords.
	totalRecords := 0
	movies := []*Movie{}

	for rows.Next() {
		var movie Movie
		// Escanea el recuento de la función de ventana en totalRecords.
		err := rows.Scan(
			&totalRecords,
			&movie.ID,
			&movie.CreatedAt,
			&movie.Title,
			&movie.Year,
			&movie.Runtime,
			pq.Array(&movie.Genres),
			&movie.Version,
		)
		if err != nil {
			return nil, Metadata{}, err // Actualiza esto para devolver una estructura Metadata vacía.
		}
		movies = append(movies, &movie)
	}

	if err = rows.Err(); err != nil {
		return nil, Metadata{}, err // Actualiza esto para devolver una estructura Metadata vacía.
	}

	// Genera una estructura Metadata, pasando el recuento total de registros y los parámetros de paginación desde el cliente.
	metadata := calculateMetadata(totalRecords, filters.Page, filters.PageSize)

	// Incluye la estructura de metadatos al devolver.
	return movies, metadata, nil
}

func (app *application) listMoviesHandler(w http.ResponseWriter, r *http.Request) {
	var input struct {
		Title  string
		Genres []string
		data.Filters
	}
	v := validator.New()
	qs := r.URL.Query()
	input.Title = app.readString(qs, "title", "")
	input.Genres = app.readCSV(qs, "genres", []string{})
	input.Filters.Page = app.readInt(qs, "page", 1, v)
	input.Filters.PageSize = app.readInt(qs, "page_size", 20, v)
	input.Filters.Sort = app.readString(qs, "sort", "id")
	input.Filters.SortSafelist = []string{"id", "title", "year", "runtime", "-id", "-title", "-year", "-runtime"}
	if data.ValidateFilters(v, input.Filters); !v.Valid() {
		app.failedValidationResponse(w, r, v.Errors)
		return
	}
	// Accept the metadata struct as a return value.
	movies, metadata, err := app.models.Movies.GetAll(input.Title, input.Genres, input.Filters)
	if err != nil {
		app.serverErrorResponse(w, r, err)
		return
	}
	// Include the metadata in the response envelope.
	err = app.writeJSON(w, http.StatusOK, envelope{"movies": movies, "metadata": metadata}, nil)
	if err != nil {
		app.serverErrorResponse(w, r, err)
	}
}

curl "localhost:4000/v1/movies?page=1&page_size=2"
{
  "metadata": {
    "current_page": 1,
    "page_size": 2,
    "first_page": 1,
    "last_page": 2,
    "total_records": 3
  },
  "movies": [
    {
      "id": 1,
      "title": "Moana",
      "year": 2015,
      "runtime": "107 mins",
      "genres": [
        "animation",
        "adventure"
      ],
      "version": 1
    },
    {
      "id": 2,
      "title": "Black Panther",
      "year": 2018,
      "runtime": "134 mins",
      "genres": [
        "sci-fi",
        "action",
        "adventure"
      ],
      "version": 2
    }
  ]
}

$ curl localhost:4000/v1/movies?genres=adventure
{
  "metadata": {
    "current_page": 1,
    "page_size": 20,
    "first_page": 1,
    "last_page": 1,
    "total_records": 2
  },
  "movies": [
    {
      "id": 1,
      "title": "Moana",
      "year": 2015,
      "runtime": "107 mins",
      "genres": [
        "animation",
        "adventure"
      ],
      "version": 1
    },
    {
      "id": 2,
      "title": "Black Panther",
      "year": 2018,
      "runtime": "134 mins",
      "genres": [
        "sci-fi",
        "action",
        "adventure"
      ],
      "version": 2
    }
  ]
}

$ curl localhost:4000/v1/movies?page=100
{
	"metadata": {},
	"movies": []
}