feat: openapi changes

api/api.gen.go

@@ -16,13 +16,57 @@ import (
 	openapi_types "github.com/oapi-codegen/runtime/types"
 )
 
+// Defines values for ReleaseSeason.
+const (
+	Fall   ReleaseSeason = "fall"
+	Spring ReleaseSeason = "spring"
+	Summer ReleaseSeason = "summer"
+	Winter ReleaseSeason = "winter"
+)
+
+// Defines values for TitleStatus.
+const (
+	Finished TitleStatus = "finished"
+	Ongoing  TitleStatus = "ongoing"
+	Planned  TitleStatus = "planned"
+)
+
+// ReleaseSeason Title release season
+type ReleaseSeason string
+
+// Title defines model for Title.
+type Title struct {
+	EpisodesAired *int32     `json:"episodes_aired,omitempty"`
+	EpisodesAll   *int32     `json:"episodes_all,omitempty"`
+	EpisodesLen   *[]float64 `json:"episodes_len,omitempty"`
+
+	// Id Unique title ID (primary key)
+	Id          *int64   `json:"id,omitempty"`
+	PosterId    *int64   `json:"poster_id,omitempty"`
+	Rating      *float64 `json:"rating,omitempty"`
+	RatingCount *int32   `json:"rating_count,omitempty"`
+
+	// ReleaseSeason Title release season
+	ReleaseSeason *ReleaseSeason `json:"release_season,omitempty"`
+	ReleaseYear   *int32         `json:"release_year,omitempty"`
+	StudioId      *int64         `json:"studio_id,omitempty"`
+	TitleNames    *[]string      `json:"title_names,omitempty"`
+
+	// TitleStatus Title status
+	TitleStatus          *TitleStatus           `json:"title_status,omitempty"`
+	AdditionalProperties map[string]interface{} `json:"-"`
+}
+
+// TitleStatus Title status
+type TitleStatus string
+
 // User defines model for User.
 type User struct {
 	// AvatarId ID of the user avatar (references images table)
 	AvatarId *int64 `json:"avatar_id"`
 
 	// CreationDate Timestamp when the user was created
-	CreationDate time.Time `json:"creation_date"`
+	CreationDate *time.Time `json:"creation_date,omitempty"`
 
 	// DispName Display name
 	DispName *string `json:"disp_name,omitempty"`
@@ -40,13 +84,267 @@ type User struct {
 	UserDesc *string `json:"user_desc,omitempty"`
 }
 
+// GetTitleParams defines parameters for GetTitle.
+type GetTitleParams struct {
+	Word          *string        `form:"word,omitempty" json:"word,omitempty"`
+	Status        *TitleStatus   `form:"status,omitempty" json:"status,omitempty"`
+	Rating        *float64       `form:"rating,omitempty" json:"rating,omitempty"`
+	ReleaseYear   *int32         `form:"release_year,omitempty" json:"release_year,omitempty"`
+	ReleaseSeason *ReleaseSeason `form:"release_season,omitempty" json:"release_season,omitempty"`
+	Limit         *int           `form:"limit,omitempty" json:"limit,omitempty"`
+	Offset        *int           `form:"offset,omitempty" json:"offset,omitempty"`
+	Fields        *string        `form:"fields,omitempty" json:"fields,omitempty"`
+}
+
 // GetUsersUserIdParams defines parameters for GetUsersUserId.
 type GetUsersUserIdParams struct {
 	Fields *string `form:"fields,omitempty" json:"fields,omitempty"`
 }
 
+// PostUsersJSONRequestBody defines body for PostUsers for application/json ContentType.
+type PostUsersJSONRequestBody = User
+
+// Getter for additional properties for Title. Returns the specified
+// element and whether it was found
+func (a Title) Get(fieldName string) (value interface{}, found bool) {
+	if a.AdditionalProperties != nil {
+		value, found = a.AdditionalProperties[fieldName]
+	}
+	return
+}
+
+// Setter for additional properties for Title
+func (a *Title) Set(fieldName string, value interface{}) {
+	if a.AdditionalProperties == nil {
+		a.AdditionalProperties = make(map[string]interface{})
+	}
+	a.AdditionalProperties[fieldName] = value
+}
+
+// Override default JSON handling for Title to handle AdditionalProperties
+func (a *Title) UnmarshalJSON(b []byte) error {
+	object := make(map[string]json.RawMessage)
+	err := json.Unmarshal(b, &object)
+	if err != nil {
+		return err
+	}
+
+	if raw, found := object["episodes_aired"]; found {
+		err = json.Unmarshal(raw, &a.EpisodesAired)
+		if err != nil {
+			return fmt.Errorf("error reading 'episodes_aired': %w", err)
+		}
+		delete(object, "episodes_aired")
+	}
+
+	if raw, found := object["episodes_all"]; found {
+		err = json.Unmarshal(raw, &a.EpisodesAll)
+		if err != nil {
+			return fmt.Errorf("error reading 'episodes_all': %w", err)
+		}
+		delete(object, "episodes_all")
+	}
+
+	if raw, found := object["episodes_len"]; found {
+		err = json.Unmarshal(raw, &a.EpisodesLen)
+		if err != nil {
+			return fmt.Errorf("error reading 'episodes_len': %w", err)
+		}
+		delete(object, "episodes_len")
+	}
+
+	if raw, found := object["id"]; found {
+		err = json.Unmarshal(raw, &a.Id)
+		if err != nil {
+			return fmt.Errorf("error reading 'id': %w", err)
+		}
+		delete(object, "id")
+	}
+
+	if raw, found := object["poster_id"]; found {
+		err = json.Unmarshal(raw, &a.PosterId)
+		if err != nil {
+			return fmt.Errorf("error reading 'poster_id': %w", err)
+		}
+		delete(object, "poster_id")
+	}
+
+	if raw, found := object["rating"]; found {
+		err = json.Unmarshal(raw, &a.Rating)
+		if err != nil {
+			return fmt.Errorf("error reading 'rating': %w", err)
+		}
+		delete(object, "rating")
+	}
+
+	if raw, found := object["rating_count"]; found {
+		err = json.Unmarshal(raw, &a.RatingCount)
+		if err != nil {
+			return fmt.Errorf("error reading 'rating_count': %w", err)
+		}
+		delete(object, "rating_count")
+	}
+
+	if raw, found := object["release_season"]; found {
+		err = json.Unmarshal(raw, &a.ReleaseSeason)
+		if err != nil {
+			return fmt.Errorf("error reading 'release_season': %w", err)
+		}
+		delete(object, "release_season")
+	}
+
+	if raw, found := object["release_year"]; found {
+		err = json.Unmarshal(raw, &a.ReleaseYear)
+		if err != nil {
+			return fmt.Errorf("error reading 'release_year': %w", err)
+		}
+		delete(object, "release_year")
+	}
+
+	if raw, found := object["studio_id"]; found {
+		err = json.Unmarshal(raw, &a.StudioId)
+		if err != nil {
+			return fmt.Errorf("error reading 'studio_id': %w", err)
+		}
+		delete(object, "studio_id")
+	}
+
+	if raw, found := object["title_names"]; found {
+		err = json.Unmarshal(raw, &a.TitleNames)
+		if err != nil {
+			return fmt.Errorf("error reading 'title_names': %w", err)
+		}
+		delete(object, "title_names")
+	}
+
+	if raw, found := object["title_status"]; found {
+		err = json.Unmarshal(raw, &a.TitleStatus)
+		if err != nil {
+			return fmt.Errorf("error reading 'title_status': %w", err)
+		}
+		delete(object, "title_status")
+	}
+
+	if len(object) != 0 {
+		a.AdditionalProperties = make(map[string]interface{})
+		for fieldName, fieldBuf := range object {
+			var fieldVal interface{}
+			err := json.Unmarshal(fieldBuf, &fieldVal)
+			if err != nil {
+				return fmt.Errorf("error unmarshaling field %s: %w", fieldName, err)
+			}
+			a.AdditionalProperties[fieldName] = fieldVal
+		}
+	}
+	return nil
+}
+
+// Override default JSON handling for Title to handle AdditionalProperties
+func (a Title) MarshalJSON() ([]byte, error) {
+	var err error
+	object := make(map[string]json.RawMessage)
+
+	if a.EpisodesAired != nil {
+		object["episodes_aired"], err = json.Marshal(a.EpisodesAired)
+		if err != nil {
+			return nil, fmt.Errorf("error marshaling 'episodes_aired': %w", err)
+		}
+	}
+
+	if a.EpisodesAll != nil {
+		object["episodes_all"], err = json.Marshal(a.EpisodesAll)
+		if err != nil {
+			return nil, fmt.Errorf("error marshaling 'episodes_all': %w", err)
+		}
+	}
+
+	if a.EpisodesLen != nil {
+		object["episodes_len"], err = json.Marshal(a.EpisodesLen)
+		if err != nil {
+			return nil, fmt.Errorf("error marshaling 'episodes_len': %w", err)
+		}
+	}
+
+	if a.Id != nil {
+		object["id"], err = json.Marshal(a.Id)
+		if err != nil {
+			return nil, fmt.Errorf("error marshaling 'id': %w", err)
+		}
+	}
+
+	if a.PosterId != nil {
+		object["poster_id"], err = json.Marshal(a.PosterId)
+		if err != nil {
+			return nil, fmt.Errorf("error marshaling 'poster_id': %w", err)
+		}
+	}
+
+	if a.Rating != nil {
+		object["rating"], err = json.Marshal(a.Rating)
+		if err != nil {
+			return nil, fmt.Errorf("error marshaling 'rating': %w", err)
+		}
+	}
+
+	if a.RatingCount != nil {
+		object["rating_count"], err = json.Marshal(a.RatingCount)
+		if err != nil {
+			return nil, fmt.Errorf("error marshaling 'rating_count': %w", err)
+		}
+	}
+
+	if a.ReleaseSeason != nil {
+		object["release_season"], err = json.Marshal(a.ReleaseSeason)
+		if err != nil {
+			return nil, fmt.Errorf("error marshaling 'release_season': %w", err)
+		}
+	}
+
+	if a.ReleaseYear != nil {
+		object["release_year"], err = json.Marshal(a.ReleaseYear)
+		if err != nil {
+			return nil, fmt.Errorf("error marshaling 'release_year': %w", err)
+		}
+	}
+
+	if a.StudioId != nil {
+		object["studio_id"], err = json.Marshal(a.StudioId)
+		if err != nil {
+			return nil, fmt.Errorf("error marshaling 'studio_id': %w", err)
+		}
+	}
+
+	if a.TitleNames != nil {
+		object["title_names"], err = json.Marshal(a.TitleNames)
+		if err != nil {
+			return nil, fmt.Errorf("error marshaling 'title_names': %w", err)
+		}
+	}
+
+	if a.TitleStatus != nil {
+		object["title_status"], err = json.Marshal(a.TitleStatus)
+		if err != nil {
+			return nil, fmt.Errorf("error marshaling 'title_status': %w", err)
+		}
+	}
+
+	for fieldName, field := range a.AdditionalProperties {
+		object[fieldName], err = json.Marshal(field)
+		if err != nil {
+			return nil, fmt.Errorf("error marshaling '%s': %w", fieldName, err)
+		}
+	}
+	return json.Marshal(object)
+}
+
 // ServerInterface represents all server handlers.
 type ServerInterface interface {
+	// Get titles
+	// (GET /title)
+	GetTitle(c *gin.Context, params GetTitleParams)
+	// Add new user
+	// (POST /users)
+	PostUsers(c *gin.Context)
 	// Get user info
 	// (GET /users/{user_id})
 	GetUsersUserId(c *gin.Context, userId string, params GetUsersUserIdParams)
@@ -61,6 +359,101 @@ type ServerInterfaceWrapper struct {
 
 type MiddlewareFunc func(c *gin.Context)
 
+// GetTitle operation middleware
+func (siw *ServerInterfaceWrapper) GetTitle(c *gin.Context) {
+
+	var err error
+
+	// Parameter object where we will unmarshal all parameters from the context
+	var params GetTitleParams
+
+	// ------------- Optional query parameter "word" -------------
+
+	err = runtime.BindQueryParameter("form", true, false, "word", c.Request.URL.Query(), &params.Word)
+	if err != nil {
+		siw.ErrorHandler(c, fmt.Errorf("Invalid format for parameter word: %w", err), http.StatusBadRequest)
+		return
+	}
+
+	// ------------- Optional query parameter "status" -------------
+
+	err = runtime.BindQueryParameter("form", true, false, "status", c.Request.URL.Query(), &params.Status)
+	if err != nil {
+		siw.ErrorHandler(c, fmt.Errorf("Invalid format for parameter status: %w", err), http.StatusBadRequest)
+		return
+	}
+
+	// ------------- Optional query parameter "rating" -------------
+
+	err = runtime.BindQueryParameter("form", true, false, "rating", c.Request.URL.Query(), &params.Rating)
+	if err != nil {
+		siw.ErrorHandler(c, fmt.Errorf("Invalid format for parameter rating: %w", err), http.StatusBadRequest)
+		return
+	}
+
+	// ------------- Optional query parameter "release_year" -------------
+
+	err = runtime.BindQueryParameter("form", true, false, "release_year", c.Request.URL.Query(), &params.ReleaseYear)
+	if err != nil {
+		siw.ErrorHandler(c, fmt.Errorf("Invalid format for parameter release_year: %w", err), http.StatusBadRequest)
+		return
+	}
+
+	// ------------- Optional query parameter "release_season" -------------
+
+	err = runtime.BindQueryParameter("form", true, false, "release_season", c.Request.URL.Query(), &params.ReleaseSeason)
+	if err != nil {
+		siw.ErrorHandler(c, fmt.Errorf("Invalid format for parameter release_season: %w", err), http.StatusBadRequest)
+		return
+	}
+
+	// ------------- Optional query parameter "limit" -------------
+
+	err = runtime.BindQueryParameter("form", true, false, "limit", c.Request.URL.Query(), &params.Limit)
+	if err != nil {
+		siw.ErrorHandler(c, fmt.Errorf("Invalid format for parameter limit: %w", err), http.StatusBadRequest)
+		return
+	}
+
+	// ------------- Optional query parameter "offset" -------------
+
+	err = runtime.BindQueryParameter("form", true, false, "offset", c.Request.URL.Query(), &params.Offset)
+	if err != nil {
+		siw.ErrorHandler(c, fmt.Errorf("Invalid format for parameter offset: %w", err), http.StatusBadRequest)
+		return
+	}
+
+	// ------------- Optional query parameter "fields" -------------
+
+	err = runtime.BindQueryParameter("form", true, false, "fields", c.Request.URL.Query(), &params.Fields)
+	if err != nil {
+		siw.ErrorHandler(c, fmt.Errorf("Invalid format for parameter fields: %w", err), http.StatusBadRequest)
+		return
+	}
+
+	for _, middleware := range siw.HandlerMiddlewares {
+		middleware(c)
+		if c.IsAborted() {
+			return
+		}
+	}
+
+	siw.Handler.GetTitle(c, params)
+}
+
+// PostUsers operation middleware
+func (siw *ServerInterfaceWrapper) PostUsers(c *gin.Context) {
+
+	for _, middleware := range siw.HandlerMiddlewares {
+		middleware(c)
+		if c.IsAborted() {
+			return
+		}
+	}
+
+	siw.Handler.PostUsers(c)
+}
+
 // GetUsersUserId operation middleware
 func (siw *ServerInterfaceWrapper) GetUsersUserId(c *gin.Context) {
 
@@ -123,9 +516,65 @@ func RegisterHandlersWithOptions(router gin.IRouter, si ServerInterface, options
 		ErrorHandler:       errorHandler,
 	}
 
+	router.GET(options.BaseURL+"/title", wrapper.GetTitle)
+	router.POST(options.BaseURL+"/users", wrapper.PostUsers)
 	router.GET(options.BaseURL+"/users/:user_id", wrapper.GetUsersUserId)
 }
 
+type GetTitleRequestObject struct {
+	Params GetTitleParams
+}
+
+type GetTitleResponseObject interface {
+	VisitGetTitleResponse(w http.ResponseWriter) error
+}
+
+type GetTitle200JSONResponse []Title
+
+func (response GetTitle200JSONResponse) VisitGetTitleResponse(w http.ResponseWriter) error {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(200)
+
+	return json.NewEncoder(w).Encode(response)
+}
+
+type GetTitle204Response struct {
+}
+
+func (response GetTitle204Response) VisitGetTitleResponse(w http.ResponseWriter) error {
+	w.WriteHeader(204)
+	return nil
+}
+
+type GetTitle500Response struct {
+}
+
+func (response GetTitle500Response) VisitGetTitleResponse(w http.ResponseWriter) error {
+	w.WriteHeader(500)
+	return nil
+}
+
+type PostUsersRequestObject struct {
+	Body *PostUsersJSONRequestBody
+}
+
+type PostUsersResponseObject interface {
+	VisitPostUsersResponse(w http.ResponseWriter) error
+}
+
+type PostUsers200JSONResponse struct {
+	Error    *string `json:"error,omitempty"`
+	Success  *bool   `json:"success,omitempty"`
+	UserJson *User   `json:"user_json,omitempty"`
+}
+
+func (response PostUsers200JSONResponse) VisitPostUsersResponse(w http.ResponseWriter) error {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(200)
+
+	return json.NewEncoder(w).Encode(response)
+}
+
 type GetUsersUserIdRequestObject struct {
 	UserId string `json:"user_id"`
 	Params GetUsersUserIdParams
@@ -154,6 +603,12 @@ func (response GetUsersUserId404Response) VisitGetUsersUserIdResponse(w http.Res
 
 // StrictServerInterface represents all server handlers.
 type StrictServerInterface interface {
+	// Get titles
+	// (GET /title)
+	GetTitle(ctx context.Context, request GetTitleRequestObject) (GetTitleResponseObject, error)
+	// Add new user
+	// (POST /users)
+	PostUsers(ctx context.Context, request PostUsersRequestObject) (PostUsersResponseObject, error)
 	// Get user info
 	// (GET /users/{user_id})
 	GetUsersUserId(ctx context.Context, request GetUsersUserIdRequestObject) (GetUsersUserIdResponseObject, error)
@@ -171,6 +626,66 @@ type strictHandler struct {
 	middlewares []StrictMiddlewareFunc
 }
 
+// GetTitle operation middleware
+func (sh *strictHandler) GetTitle(ctx *gin.Context, params GetTitleParams) {
+	var request GetTitleRequestObject
+
+	request.Params = params
+
+	handler := func(ctx *gin.Context, request interface{}) (interface{}, error) {
+		return sh.ssi.GetTitle(ctx, request.(GetTitleRequestObject))
+	}
+	for _, middleware := range sh.middlewares {
+		handler = middleware(handler, "GetTitle")
+	}
+
+	response, err := handler(ctx, request)
+
+	if err != nil {
+		ctx.Error(err)
+		ctx.Status(http.StatusInternalServerError)
+	} else if validResponse, ok := response.(GetTitleResponseObject); ok {
+		if err := validResponse.VisitGetTitleResponse(ctx.Writer); err != nil {
+			ctx.Error(err)
+		}
+	} else if response != nil {
+		ctx.Error(fmt.Errorf("unexpected response type: %T", response))
+	}
+}
+
+// PostUsers operation middleware
+func (sh *strictHandler) PostUsers(ctx *gin.Context) {
+	var request PostUsersRequestObject
+
+	var body PostUsersJSONRequestBody
+	if err := ctx.ShouldBindJSON(&body); err != nil {
+		ctx.Status(http.StatusBadRequest)
+		ctx.Error(err)
+		return
+	}
+	request.Body = &body
+
+	handler := func(ctx *gin.Context, request interface{}) (interface{}, error) {
+		return sh.ssi.PostUsers(ctx, request.(PostUsersRequestObject))
+	}
+	for _, middleware := range sh.middlewares {
+		handler = middleware(handler, "PostUsers")
+	}
+
+	response, err := handler(ctx, request)
+
+	if err != nil {
+		ctx.Error(err)
+		ctx.Status(http.StatusInternalServerError)
+	} else if validResponse, ok := response.(PostUsersResponseObject); ok {
+		if err := validResponse.VisitPostUsersResponse(ctx.Writer); err != nil {
+			ctx.Error(err)
+		}
+	} else if response != nil {
+		ctx.Error(fmt.Errorf("unexpected response type: %T", response))
+	}
+}
+
 // GetUsersUserId operation middleware
 func (sh *strictHandler) GetUsersUserId(ctx *gin.Context, userId string, params GetUsersUserIdParams) {
 	var request GetUsersUserIdRequestObject

go.mod

@@ -34,6 +34,7 @@ require (
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/quic-go/qpack v0.5.1 // indirect
 	github.com/quic-go/quic-go v0.54.0 // indirect
+	github.com/sirupsen/logrus v1.9.3 // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/ugorji/go/codec v1.3.0 // indirect
 	go.uber.org/mock v0.5.0 // indirect

go.sum

@@ -68,6 +68,8 @@ github.com/quic-go/qpack v0.5.1 h1:giqksBPnT/HDtZ6VhtFKgoLOWmlyo9Ei6u9PqzIMbhI=
 github.com/quic-go/qpack v0.5.1/go.mod h1:+PC4XFrEskIVkcLzpEkbLqq1uCoxPhQuvK5rH1ZgaEg=
 github.com/quic-go/quic-go v0.54.0 h1:6s1YB9QotYI6Ospeiguknbp2Znb/jZYjZLRXn9kMQBg=
 github.com/quic-go/quic-go v0.54.0/go.mod h1:e68ZEaCdyviluZmy44P6Iey98v/Wfz6HCjQEm+l8zTY=
+github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
+github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
 github.com/spkg/bom v0.0.0-20160624110644-59b7046e48ad/go.mod h1:qLr4V1qq6nMqFKkMo8ZTx3f+BZEkzsRUY10Xsm2mwU0=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
@@ -95,6 +97,7 @@ golang.org/x/net v0.42.0 h1:jzkYrhi3YQWD6MLBJcsklgQsoAcw89EcZbJw8Z614hs=
 golang.org/x/net v0.42.0/go.mod h1:FF1RA5d3u7nAYA4z2TkclSCKh68eSXtiFwcWQpPXdt8=
 golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
 golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=

modules/backend/queries.sql

@@ -38,12 +38,39 @@ WHERE id = $1;
 -- DELETE FROM users
 -- WHERE user_id = $1;
 
--- -- name: GetTitleByID :one
--- SELECT title_id, title_names, studio_id, poster_id, signal_ids,
---        title_status, rating, rating_count, release_year, release_season,
---        season, episodes_aired, episodes_all, episodes_len
--- FROM titles
--- WHERE title_id = $1;
+-- name: SearchTitles :many
+SELECT 
+    *
+FROM titles
+WHERE 
+    CASE 
+        WHEN sqlc.narg('word')::text IS NOT NULL THEN
+            (
+                SELECT bool_and(
+                    EXISTS (
+                        SELECT 1 
+                        FROM jsonb_each_text(title_names) AS t(key, val)
+                        WHERE val ILIKE pattern
+                    )
+                )
+                FROM unnest(
+                    ARRAY(
+                        SELECT '%' || trim(w) || '%'
+                        FROM unnest(string_to_array(sqlc.narg('word')::text, ' ')) AS w
+                        WHERE trim(w) <> ''
+                    )
+                ) AS pattern
+            )
+        ELSE true
+    END
+
+    AND (sqlc.narg('status')::title_status_t IS NULL OR title_status = sqlc.narg('status')::title_status_t)
+    AND (sqlc.narg('rating')::float IS NULL OR rating >= sqlc.narg('rating')::float)
+    AND (sqlc.narg('release_year')::int IS NULL OR release_year = sqlc.narg('release_year')::int)
+    AND (sqlc.narg('release_season')::release_season_t IS NULL OR release_season = sqlc.narg('release_season')::release_season_t)
+
+LIMIT COALESCE(sqlc.narg('limit')::int, 100) -- 100 is default limit
+OFFSET sqlc.narg('offset')::int;
 
 -- -- name: ListTitles :many
 -- SELECT title_id, title_names, studio_id, poster_id, signal_ids,