App contains all the environment variables for the application

AuthHandler represents the HTTP handler for authentication-related requests

UserService is an interface for interacting with user authentication-related business logic

** * AuthService implements port.AuthService interface * and provides an access to the user repository * and token service */

go:generate mockgen -source=cache.go -destination=mock/cache.go -package=mock CacheRepository is an interface for interacting with cache-related busin

Category is an entity that represents a category of product

CategoryHandler represents the HTTP handler for category-related requests

go:generate mockgen -source=category.go -destination=mock/category.go -package=mock CategoryRepository is an interface for interacting with category-r

** * CategoryRepository implements port.CategoryRepository interface * and provides an access to the postgres database */

CategoryService is an interface for interacting with category-related business logic

** * CategoryService implements port.CategoryService interface * and provides an access to the category repository * and cache service */

Container contains environment variables for the application, database, cache, token, and http server

** * DB is a wrapper for PostgreSQL database connection * that uses pgxpool as database driver. * It also holds a reference to squirrel.StatementBu

Database contains all the environment variables for the database

HTTP contains all the environment variables for the http server

MockAuthService is a mock of AuthService interface.

MockAuthServiceMockRecorder is the mock recorder for MockAuthService.

MockCacheRepository is a mock of CacheRepository interface.

MockCacheRepositoryMockRecorder is the mock recorder for MockCacheRepository.

MockCategoryRepository is a mock of CategoryRepository interface.

MockCategoryRepositoryMockRecorder is the mock recorder for MockCategoryRepository.

MockCategoryService is a mock of CategoryService interface.

MockCategoryServiceMockRecorder is the mock recorder for MockCategoryService.

MockOrderRepository is a mock of OrderRepository interface.

MockOrderRepositoryMockRecorder is the mock recorder for MockOrderRepository.

MockOrderService is a mock of OrderService interface.

MockOrderServiceMockRecorder is the mock recorder for MockOrderService.

MockPaymentRepository is a mock of PaymentRepository interface.

MockPaymentRepositoryMockRecorder is the mock recorder for MockPaymentRepository.

MockPaymentService is a mock of PaymentService interface.

MockPaymentServiceMockRecorder is the mock recorder for MockPaymentService.

MockProductRepository is a mock of ProductRepository interface.

MockProductRepositoryMockRecorder is the mock recorder for MockProductRepository.

MockProductService is a mock of ProductService interface.

MockProductServiceMockRecorder is the mock recorder for MockProductService.

MockTokenService is a mock of TokenService interface.

MockTokenServiceMockRecorder is the mock recorder for MockTokenService.

MockUserRepository is a mock of UserRepository interface.

MockUserRepositoryMockRecorder is the mock recorder for MockUserRepository.

MockUserService is a mock of UserService interface.

MockUserServiceMockRecorder is the mock recorder for MockUserService.

Order is an entity that represents an order

OrderHandler represents the HTTP handler for order-related requests

OrderProduct is an entity that represents pivot table between order and product

go:generate mockgen -source=order.go -destination=mock/order.go -package=mock OrderRepository is an interface for interacting with order-related data

** * OrderRepository implements port.OrderRepository interface * and provides an access to the postgres database */

OrderService is an interface for interacting with order-related business logic

** * OrderService implements port.OrderService, port.ProductService, * port.UserService and port.PaymentService interfaces and provides * an access

** * PasetoToken implements port.TokenService interface * and provides an access to the paseto library */

Payment is an entity that represents a payment

PaymentHandler represents the HTTP handler for payment-related requests

go:generate mockgen -source=payment.go -destination=mock/payment.go -package=mock PaymentRepository is an interface for interacting with payment-relat

** * PaymentRepository implements port.PaymentRepository interface * and provides an access to the postgres database */

PaymentService is an interface for interacting with payment-related business logic

** * PaymentService implements port.PaymentService interface * and provides an access to the payment repository * and cache service */

PaymentType is an enum for payment's type

Product is an entity that represents a product

ProductHandler represents the HTTP handler for product-related requests

go:generate mockgen -source=product.go -destination=mock/product.go -package=mock ProductRepository is an interface for interacting with product-relat

** * ProductRepository implements port.ProductRepository interface * and provides an access to the postgres database */

ProductService is an interface for interacting with product-related business logic

** * ProductService implements port.ProductService and port.CategoryService * interfaces and provides an access to the product and category reposito

** * Redis implements port.CacheRepository interface * and provides an access to the redis library */

Redis contains all the environment variables for the cache service

Router is a wrapper for HTTP router

Token contains all the environment variables for the token service

TokenPayload is an entity that represents the payload of the token

go:generate mockgen -source=auth.go -destination=mock/auth.go -package=mock TokenService is an interface for interacting with token-related business l

User is an entity that represents a user

UserHandler represents the HTTP handler for user-related requests

go:generate mockgen -source=user.go -destination=mock/user.go -package=mock UserRepository is an interface for interacting with user-related data

** * UserRepository implements port.UserRepository interface * and provides an access to the postgres database */

UserRole is an enum for user's role

UserService is an interface for interacting with user-related business logic

** * UserService implements port.UserService interface * and provides an access to the user repository * and cache service */

authResponse represents an authentication response body

categoryResponse represents a category response body

createCategoryRequest represents a request body for creating a new category

createOrderRequest represents a request body for creating a new order

createPaymentRequest represents a request body for creating a new payment

createProductRequest represents a request body for creating a new product

deleteCategoryRequest represents a request body for deleting a category

deletePaymentRequest represents a request body for deleting a payment

deleteProductRequest represents a request body for deleting a product

deleteUserRequest represents the request body for deleting a user

errorResponse represents an error response body format