I have a vapor server running on 127.0.0.1:8080. I added a new login route at residentusers/login. When I use Postman (or the client app) to access this route, I get a 404 error.

I used the command vapor run routes to get the list of routes, and I can see the route I’m trying to access.

+--------+--------------------------+
| POST   | /residentusers/login     |
+--------+--------------------------+
| POST   | /residentusers           |
+--------+--------------------------+
| GET    | /residentusers           |
+--------+--------------------------+
| DELETE | /residentusers/:id       |
+--------+--------------------------+
| DELETE | /residenttokens/:id      |
+--------+--------------------------+

So why the 404?

Here’s my ResidentUserController:

import Vapor

struct ResidentUserController: RouteCollection {
    func boot(routes: RoutesBuilder) throws {
        let usersRoutes = routes.grouped("residentusers")
                
        let tokenAuthMiddleware = Token.authenticator()
        let guardAuthMiddleware = User.guardMiddleware()
        let basicAuthMiddleware = ResidentUser.authenticator()
        
        usersRoutes.post("login", use: loginHandler)
        
        let tokenAuthGroup = usersRoutes.grouped(tokenAuthMiddleware, guardAuthMiddleware)
        
        tokenAuthGroup.post(use: createHandler)
        
        tokenAuthGroup.get(use: getAllResidentUsers)
        
        tokenAuthGroup.group(":id") { user in
            user.delete(use: deleteUser)
        }
    }
    
    // sign up
        func createHandler(_ req: Request) throws -> EventLoopFuture<ResidentUser.Public> {
            let token = try req.auth.require(Token.self)
            // acsess the user username and password
            let user = try req.content.decode(ResidentUser.self)
            // hashing the password with Bcrypt algorthim before saving
            user.password = try Bcrypt.hash(user.password)
            return user.save(on: req.db).map {
              // convert to public to hide the password and return the data in the response
                user.convertToPublic()
            }
        }

        // log in
        func loginHandler(_ req: Request) throws -> EventLoopFuture<ResidentToken> {
            // acsess the user username and password
            let user = try req.auth.require(ResidentUser.self)
            // generate the token and return it in the resposne
            let token = try ResidentToken.generate(for: user)
            return token.save(on: req.db).map {token}
        }
    
    func tokenHandler(_ req: Request) throws -> EventLoopFuture<Token> {
        
        let token = try req.auth.require(Token.self)
        
        return token.save(on: req.db).map {token}
    }
    
    func getAllResidentUsers(req: Request) throws -> EventLoopFuture<[ResidentUser.Public]> {
        let token = try req.auth.require(Token.self)
        
        return ResidentUser.query(on: req.db).all().map { users in
            users.map { user in
                user.convertToPublic()
            }
        }
    }
    
    func deleteUser(req: Request) throws -> EventLoopFuture<HTTPStatus> {
        let token = try req.auth.require(Token.self)
        let id = try req.parameters.require("id", as: UUID.self)
        return User.find(id, on: req.db)
            .unwrap(or: Abort(.notFound))
            .flatMap { resident in
                return resident.delete(on: req.db)
            }
            .transform(to: .noContent)
    }
}