Add validation for create and login user requests.
Add validation for every field in the request.
This will improve the way the request errors are displayed.

Create create user API.
It should handle POST requests and create users.
Without hashing passwords for now.

Implement create and login user functions in gRPC.
Most of the functions will be the same as it was in the gin app.
Main difference are errors and data validation.

Add list posts by author API.
Create a function to handle GET requests and return posts created by an author with the given name (that username or email contains a given string).
It should accept three query parameters - page, page_size, and author.
Test the function.

Add create post API.
It should:

• validate the date
• get or create the category with the name that was sent in the request
• get the authenticated user (to set as an author)
• create a new post
• add tags (sent in the request) to the created post
• send the formatted response with all post details, tags, category name, and author name

Add login user API and test it.

Create functions to perform CRUD operations for the categories table.
To do it - use sqlc
Test created functions.

Add token authentication using PASETO Security Tokens

Add a list all posts API.
Create a function to handle GET requests and return posts.
It should accept two query parameters - page and page_size.
Test the function.

Fix tests that fail because of protecting routes.
create category API tests fail because they ware added to the protected routes.
Add auth to every test that uses protected route.

Add update post API.
The function should handle PATCH requests.
It should get the id of the post from the URI, and new post details from json.
Only the author of the post should be allowed to edit it.

Add get post by title API.
It should handle the /posts/title/{slug} endpoint and return post details - post object with tag list and author and category as names, not ids.
Change url of get post by id to /posts/id/{id} so it does not conflick with this endpoint.

Embed the swagger docs directory into Go binary to serve from an http.FileSystem.
Use statik.

Create functions to perform CRUD operations for the post_tags table.
There should only be functions to:

• add existing tag to the post
• remove the tag from the post

To do it - use sqlc
Test created functions.

Extract metadata from context.
The metadata needed right now is:

• user agent
• client IP

Both of those are required to create a session in the database.

Add handling of refresh tokens.
Create migrations with new sessions table.
Add a function to handle POST requests to renew access tokens.
Test the function.

Add delete category API. It should handle DELETE request to the /category/:name endpoint.
Test the API.

Add create category API.
Test the API.

Create functions to perform CRUD operations for the posts table.
To do it - use sqlc
Test created functions.

Add delete comment API.
Add a function to handle DELETE requests to delete a comment.
Only the author of the comment should be allowed to delete it.
Test the function.

Create go and postgres docker containers.

Add database documentation using dbdocs.io.
Create the .dbml schema of the database and create a webpage with the documentation.

Add github actions to run all tests before merging branches.

Implement update user functions in gRPC.
Create an SQL query code and generate the UpdateUser function with sqlc.
Using this newly created function, implement functionality to update users through gRPC and HTTP.

Add the wait for db command to fix the problem with the app container executing migration commands before the Postgres container is up.

Add update comment API.
Add a function to handle PATCH requests to update a comment.
Only the author of the comment should be allowed to update it.
Test the function.

Split the Dockerfile into two separate files, one for the Gin app and one for the gRPC app. Additionally, split the main.go file into two separate files, each focusing on one of the applications.
By separating the Dockerfile and the main files, we can isolate the build and execution processes for each component, enabling us to scale and maintain them independently.

Add list categories API. It should handle GET requests to the /category endpoint.
It should accept query params:

• page (page number), based on which it will call the database function with Offset: (request.Page - 1) * request.PageSize,
• page_size - Limit: request.PageSize

Test the API.

Create auth middleware that will check/validate the authorization header and token.
Add the create category route to protected routes.
Test the middleware.

Add HTTP gateway.
Use grpc-gateway.
For now, there will be only two endpoints working with this.
The rest will be implemented later.

Implement removing multiple tags from a post.
Create SQL queries / generate with sqlc go functions to be able to pass as an argument to the remove tags from post function a slice of strings - tag names, and int - a post id.
This should delete all post_tags tables (responsible for many-to-many relationships) and check are each tag used by another post. If the tag is unused by any post (it has no connection to any post_tags table) it should be deleted.
Test the function.

Create functions to perform CRUD operations for the users table.
To do it - use sqlc
Test created functions.

Add delete post API.
It should handle deleting posts but only by post authors.
Test the API.

Implement adding multiple tags to a post.
Create SQL queries / generate with sqlc go functions to be able to pass as an argument to the add tags to post function a slice of strings - tag names, and int - a post id.
This should get (if exist) or create tags based on given names and return tag ids.
After this function should create post_tags tables to connect all tags to the post.

Add query options to the posts table. Add option to:

• get posts by category
• get posts by the author
• get posts by tag ids

Create go structs (models) of tables.
To do it - use sqlc

Add an .env file and handle loading environment variables with Biper.

Add create comment API.
It should handle POST requests and create/add a comment to an existing post.
As a post author, the authenticated user should be set.
Test the function.

Implement hashing passwords with bcrypt.
Create functions to:

• hash password
• check password (compare string passed as a password in a POST request to the hashed value in the database)

Create functions to perform CRUD operations for the comments table.
To do it - use sqlc
Test created functions.

Add get post by id API.
It should handle the /posts/{id} endpoint and return post details - post object with tag list and author and category as names, not ids

Test update post API.
It was not tested before because of the issue with the library.
Take another approach to test the function.

Add swagger for the HTTP gateway.
Use swagger-ui to generate a local documentation.
Add docs to the swagger.io.

Add list posts by tags API.
Create a function to handle GET requests and return posts with given tags.
It should accept three query parameters - page, page_size, and tag_ids.
tag_ids should be in a comma-separated int format (1,2,3)
Test the function.

Add golang-migrate to the Dockerfile

Create functions to perform CRUD operations for the tags table.
To do it - use sqlc
Test created functions.

Create migrations init_schema for the project.
It should contain the following tables:

• users
• categories
• posts
• tags
• comments
  Additionally, the many-to-many relationship between posts and tags will require a post_tags table.

Add update category API.
It should handle PATCH requests and update the names of categories.
Test the API.

Add list posts by category API.
Create a function to handle GET requests and return posts from the given category.
It should accept three query parameters - page, page_size, and category_id.
Test the function.

Add list comments for post API.
Add a function to handle GET requests to list comments of a given post.
The post ID should be sent in URI and page and page_size in query params.
Test the function.