ResourceController class Null safety

Controller for operating on an HTTP Resource.

ResourceControllers provide a means to organize the logic for all operations on an HTTP resource. They also provide conveniences for handling these operations.

This class must be subclassed. Its instance methods handle operations on an HTTP resource. For example, the following are operations: 'GET /employees', 'GET /employees/:id' and 'POST /employees'. An instance method is assigned to handle one of these operations. For example:

    class EmployeeController extends ResourceController {
       @Operation.post()
       Future<Response> createEmployee(...) async => Response.ok(null);
    }

Instance methods must have Operation annotation to respond to a request (see also Operation.get, Operation.post, Operation.put and Operation.delete). These methods are called operation methods. Operation methods also take a variable list of path variables. An operation method is called if the incoming request's method and present path variables match the operation annotation.

For example, the route /employees/[:id] contains an optional route variable named id. A subclass can implement two operation methods, one for when id was present and the other for when it was not:

    class EmployeeController extends ResourceController {
       // This method gets invoked when the path is '/employees'
       @Operation.get()
       Future<Response> getEmployees() async {
        return Response.ok(employees);
       }

       // This method gets invoked when the path is '/employees/id'
       @Operation.get('id')
       Future<Response> getEmployees(@Bind.path("id") int id) async {
        return Response.ok(employees[id]);
       }
    }

If there isn't an operation method for a request, an 405 Method Not Allowed error response is sent to the client and no operation methods are called.

For operation methods to correctly function, a request must have previously been handled by a Router to parse path variables.

Values from a request may be bound to operation method parameters. Parameters must be annotated with Bind.path, Bind.query, Bind.header, or Bind.body. For example, the following binds an optional query string parameter 'name' to the 'name' argument:

    class EmployeeController extends ResourceController {
      @Operation.get()
      Future<Response> getEmployees({@Bind.query("name") String name}) async {
        if (name == null) {
          return Response.ok(employees);
        }

        return Response.ok(employees.where((e) => e.name == name).toList());
      }
    }

Bindings will automatically parse values into other types and validate that requests have the desired values. See Bind for all possible bindings and https://conduit.io/docs/http/resource_controller/ for more details.

To access the request directly, use request. Note that the Request.body of request will be decoded prior to invoking an operation method.