Building REST APIs

Master Class Video Training Community Support
Search…
Building REST APIs
Overview
REST APIs are a popular and easy way to add HTTP endpoints to your web applications to act as web services for third parties or even other internal systems. REST is simpler and requires less verbosity and overhead than other protocols such as SOAP or XML-RPC.
Creating a fully-featured REST API is easy with the ColdBox Platform. Everything you need for creating routes, working with headers, basic auth, massaging data, and enforcing security comes out of the box. We even have several application templates just for REST, so you can use CommandBox to create your first RESTFul app:
1
## create app
2
coldbox create app name=MyRestAPP skeleton=rest
3
​
4
## Start up a server with rewrites
5
server start
Copied!
You will then see the following JSON output:
1
{
2
    data: "Welcome to my ColdBox RESTFul Service",
3
    error: false,
4
    messages: [ ],
5
    errorcode: "0"
6
}
Copied!
The rest template is a basic REST template that does not rely on modules or versioning. If you would like to add versioning and HMVC modularity use the rest-hmvc template. You can also find a full demo here: https://github.com/lmajano/hmvc-presso-demo​
Quick Reference Card
Below you can download our quick reference card on RESTFul APIs
​Download RefCard​
Introduction To REST
REST stands for Representational State Transfer and builds upon the basic idea that data is represented as resources and accessed via a URI, or unique address. An HTTP client (such as a browser, or the CFHTTP tag) can send requests to a URI to interact with it. The HTTP verb (GET, POST, etc) sent in the header of the request tells the server how the client wants to interact with that resource.
As far as how your data is formatted or how you implement security is left up to you. REST is less prescriptive than other standards such as SOAP (which uses tons of heavy XML and strictly-typed parameters). This makes it more natural to understand and easier to test and debug.
Defining Resources
A REST API can define its resources on its own domain (https://api.example.com), or after a static placeholder that differentiates it from the rest of the app (https://www.example.com/api/). We'll use the latter for these examples.
Please note that we have an extensive Routing mechanism. Please check out our routing sections of the docs.
Let's consider a resource we need to represent called user. Resources should usually be nouns. If you have a verb in your URL, you're probably doing it wrong.
Hint It is also important to note that REST is a style of URL architecture not a mandate, so it is an open avenue of sorts. However, you must stay true to its concepts of resources and usage of the HTTP verbs.
Here are a few pointers when using the HTTP verbs:
1
http://www.example.com/api/user
Copied!
GET /api/user will return a representation of all the users. It is permissible to use a query string to control pagination or filtering.
POST /api/user/ will create a new user
GET /api/user/53 will return a representation of user 53
PUT /api/user/53 will update user 53
DELETE /api/user/53 will delete user 53
GET, PUT, and DELETE methods should be idempotent which means repeated requests to the same URI don't do anything. Repeated POST calls however, would create multiple users.
In ColdBox, the easiest way to represent our /api/user resource is to create a handler called user.cfc in the /handlers/api/ directory. In this instance, ColdBox will consider the api to be a handler package. You can leverage CommandBox for this:
1
coldbox create handler name=api.user actions=index,view,save,remove
Copied!
Hint This command will create all the necessary files for you and even the integration tests for you.
Here in my handler, I have stubbed out actions for each of the operations I need to perform against my user resource.
/handlers/api/user.cfc
1
component {
2
​
3
  function index( event, rc, prc ) {
4
    // List all users
5
  }
6
​
7
  function view( event, rc, prc ) {
8
    // View a single user
9
  }
10
​
11
  function save( event, rc, prc ) {
12
    // Save a user
13
  }
14
​
15
  function remove( event, rc, prc ) {
16
    // Remove a user
17
  }
18
​
19
}
Copied!
Defining URL Routes
Now that we have this skeleton in place to represent our user resource, let's move on to show how you can have full control of the URL as well as mapping HTTP verbs to specific handler actions.
The default route for our user.cfc handler is /api/user, but what if we want the resource in the URL to be completely different than the handler name convention? To do this, use the /config/Router.cfc. file to declare URL routes we want the application to capture and define how to process them. This is your URL Router and it is your best friend!
Install the route-visualizer module to visualize the router graphically. This is a huuuuge help when building APIs or anything with routes.
install route-visualizer
Let's add our new routes BEFORE the default route. We add them BEFORE because you must declare routes from the most specific to the most generic. Remember, routes fire in declared order.
1
// Map route to specific user.  Different verbs call different actions!
2
component{
3
​
4
    function configure(){
5
        setFullRewrites( true );
6
​
7
        // User Resource
8
        route( "/api/user/:userID" )
9
            .withAction( {
10
                GET    = 'view',
11
                POST   = 'save',
12
                PUT    = 'save',
13
                DELETE = 'remove'
14
            } )
15
            .toHandler( "api.user" );
16
​
17
        route( ":handler/:action?" ).end();
18
    }
19
​
20
}
Copied!
You can see if that if action is a string, all HTTP verbs will be mapped there, however a struct can also be provided that maps different verbs to different actions. This gives you exact control over how the requests are routed. We recommend you check out our Routing DSL guide as you can build very expressive and detailed URL patterns.
Route Placeholders
The :userID part of the route pattern is a placeholder. It matches whatever text is in the URL in that position. The value of the text that is matched will be available to you in the request collection as rc.userID. You can get even more specific about what kind of text you want to match in your route pattern.
Numeric Pattern Matcher
Append -numeric to the end of the placeholder to only match numbers.
addRoute( pattern = 'user/:userID-numeric' );
This route will match user/123 but not user/bob.
Alphabetic Pattern Matcher
Append -alpha to the end of the placeholder to only match upper and lowercase letters.
addRoute( pattern = 'page/:slug-alpha' );
This route will match page/contactus but not page/contact-us3.
Regex Pattern Matcher
For full control, you can specify your own regex pattern to match parts of the route
addRoute( pattern = 'api/:resource-regex(user|person)' );
This route will match api/user and api/person, but not /api/contact
Placeholder Quantifiers
You can also add the common regex {} quantifier to restrict how many digits a placeholder should have or be between:
1
// two digits
2
:state{2}
3
​
4
// 2-4 digits
5
:year{2,4}
6
​
7
// 2 or more
8
:page{2,}
Copied!
If a route is not matched it will be skipped and the next route will be inspected. If you want to validate parameters and return custom error messages inside your handler, then don't put the validations on the route.
As you can see, you have many options to craft the URL routes your API will use. Routes can be as long as you need. You can even nest levels for URLs like /api/users/contact/address/27 which would refer to the address resource inside the contact belonging to a user.
Returning Representations (Data)
REST does not dictate the format you use to represent your data. It can be JSON, XML, WDDX, plain text, a binary file or something else of your choosing.
Handler Return Data
The most common way to return data from your handlers is to simply return it. This leverages the auto marshalling capabilities of ColdBox, which will detect the return variables and marshal accordingly:
String => HTML
Complex => JSON
1
function index( event, rc, prc ) {
2
    // List all users
3
    return userService.getUserList();
4
}
5
​
6
function 404( event, rc, prc ) {
7
    return "<h1>Page not found</h1>";
8
}
Copied!
This approach allows the user to render back any string representation and be able to output any content type they like.
renderData()
The next most common way to return data from your handler's action is to use the Request Context renderData() method. It takes complex data and turns it into a string representation. Here are some of the most common formats supported by event.renderData():
XML
JSON/JSONP
TEXT
WDDX
PDF
Custom
1
// xml marshalling
2
function getUsersXML( event, rc, prc ){
3
    var qUsers = getUserService().getUsers();
4
    event.renderData( type="XML", data=qUsers );
5
}
6
//json marshalling
7
function getUsersJSON( event, rc, prc ){
8
    var qUsers = getUserService().getUsers();
9
    event.renderData( type="json", data=qUsers );
10
}
11
// pdf marshalling
12
function getUsersAsPDF( event, rc, prc ){
13
    prc.user = userService.getUser( rc.id );
14
    event.renderData( data=renderView( "users/pdf" ), type="pdf" );
15
}
16
// Multiple formats
17
function listUsers( event, rc, prc ){
18
    prc.users = userService.getAll();
19
    event.renderData( data=prc.users, formats="json,xml,html,pdf" );
20
}
Copied!
Format Detection
Many APIs allow the user to choose the format they want back from the endpoint. ColdBox will inspect the Accepts header to determine the right format to use by default or the URI for an extension.
Another way to do this is by appending a file extension to the end of the URL:
1
http://www.example.com/api/user.json
2
http://www.example.com/api/user.xml
3
http://www.example.com/api/user.text
Copied!
ColdBox has built-in support for detecting an extension in the URL and will save it into the request collection in a variable called format. What's even better is that renderData() can find the format variable and automatically render your data in the appropriate way. All you need to do is pass in a list of valid rendering formats and renderData() will do the rest.
1
function index( event, rc, prc ) {
2
    var qUsers = getUserService().getUsers();
3
    // Correct format auto-detected from the URL
4
    event.renderData( data=qUsers, formats="json,xml,text" );
5
}
Copied!
Status Codes
Status codes are a core concept in HTTP and REST APIs use them to send messages back to the client. Here are a few sample REST status codes and messages.
200 - OK - Everything is hunky-dory
201 - Created - The resource was created successfully
202 - Accepted - A 202 response is typically used for actions that take a long while to process.  It indicates that the request has been accepted for processing, but the processing has not been completed
400 - Bad Request - The server couldn't figure out what the client was sending it
401 - Unauthorized - The client isn't authorized to access this resource
404 - Not Found - The resource was not found
500 - Server Error - Something bad happened on the server
You can easily set status codes as well as the status message with renderData(). HTTP status codes and messages are not part of the response body. They live in the HTTP header.
1
function view( event, rc, prc ){
2
    var qUser = getUserService().getUser( rc.userID );
3
    if( qUser.recordCount ) {
4
        event.renderData( type="JSON", data=qUser );
5
    } else {
6
        event.renderData( type="JSON", data={}, statusCode=404, statusMessage="User not found");
7
    }
8
}
9
​
10
function save( event, rc, prc ){
11
    // Save the user represented in the request body
12
    var userIDNew = userService.saveUser( event.getHTTPContent() );
13
    // Return back the new userID to the client
14
    event.renderData( type="JSON", data={ userID = userIDNew }, statusCode=201, statusMessage="We have created your user");
15
}
Copied!
Status codes can also be set manually by using the event.setHTTPHeader()method in your handler.
1
function worldPeace( event, rc, prc ){
2
    event.setHTTPHeader( statusCode=501, statusText='Not Implemented' );
3
    return 'Try back later.';
4
}
Copied!
Caching
One of the great benefits of building your REST API on the ColdBox platform is tapping into awesome features such as event caching. Event caching allows you to cache the entire response for a resource using the incoming FORM and URL variables as the cache key. To enable event caching, set the following flag to true in your ColdBox config: Coldbox.cfc:
config/ColdBox.cfc
1
coldbox.eventCaching = true;
Copied!
Next, simply add the cache=true annotation to any action you want to be cached. That's it! You can also get fancy, and specify an optional cacheTimeout and cacheLastAccesstimeout (in minutes) to control how long to cache the data.
1
// Cache for default timeout
2
function showEntry( event, rc, prc ) cache="true" {
3
    prc.qEntry = getEntryService().getEntry( event.getValue( 'entryID', 0 ) );        
4
    event.renderData( type="JSON", data=prc.qEntry );
5
}
6
​
7
// Cache for one hour, or 20 minutes from the last time accessed.
8
function showEntry( event, rc, prc ) cache="true" cacheTimeout="60" cacheLastAccessTimeout="20" {
9
    prc.qEntry = getEntryService().getEntry( event.getValue( 'entryID', 0 ) );        
10
    event.renderData( type="JSON", data=prc.qEntry );
11
}
Copied!
Data is stored in CacheBox's template cache. You can configure this cache to store its contents anywhere including a Couchbase cluster!
Auto-Deserialization of JSON Payloads
If you are working with any modern JavaScript framework, this feature is for you. ColdBox on any incoming request will inspect the HTTP Body content and if the payload is JSON, it can deserialize it for you and if it is a structure/JS object, it will append itself to the request collection for you. So if we have the following incoming payload:
1
{
2
    "name" : "Jon Clausen",
3
    "type" : "awesomeness",
4
    "data" : [ 1,2,3 ]
5
}
Copied!
The request collection will have 3 keys for name, type and data according to their native CFML type.
To disable this feature go to your Coldbox config: coldbox.jsonPayloadToRC = false
Security
Adding authentication to an API is a common task and while there is no standard for REST, ColdBox supports just about anything you might need.
Requiring SSL
To prevent man-in-the-middle attacks or HTTP sniffing, we recommend your API require SSL. (This assumes you have purchased an SSL Cert and installed it on your server). When you define your routes, you can add withSSL() and ColdBox will only allow those routes to be accessed securely
1
// Secure Route
2
route( "/api/user/:userID" )
3
    .withSSL()
4
    .withAction( {
5
        GET    = 'view',
6
        POST   = 'save',
7
        PUT    = 'save',
8
        DELETE = 'remove'
9
    } )
10
    .toHandler( "api.user" );
Copied!
If your client is capable of handling cookies (like a web browser), you can use the session or client scopes to store login details. Generally speaking, your REST API should be stateless, meaning nothing is stored on the server after the request completes. In this scenario, authentication information is passed along with every request. It can be passed in HTTP headers or as part of the request body. How you do this is up to you.
Another approach to force SSL for all routes is to create an interceptor that listens to the request and inspects if ssl is enabled.
Basic HTTP Auth
One of the simplest and easiest forms of authentication is Basic HTTP Auth. Note, this is not the most robust or secure method of authentication and most major APIs such as Twitter and FaceBook have all moved away from it. In Basic HTTP Auth, the client sends a header called Authorization that contains a base 64 encoded concatenation of the username and password.
You can easily get the username and password using event.getHTTPBasicCredentials().
1
function preHandler( event, action, eventArguments ){
2
    var authDetails = event.getHTTPBasicCredentials();
3
    if( !securityService.authenticate( authDetails.username, authDetails.password ) ) {
4
        event.renderData( type="JSON", data={ message = 'Please check your credentials' }, statusCode=401, statusMessage="You're not authorized to do that");
5
    }
6
}
Copied!
Custom
The previous example put the security check in a preHandler() method which will get automatically run prior to each action in that handler. You can implement a broader solution by tapping into any of the ColdBox interception points such as preProcess which is announced at the start of every request.
Remember interceptors can include an eventPattern annotation to limit what ColdBox events they apply to.
In addition to having access to the entire request collection, the event object also has handy methods such as event.getHTTPHeader() to pull specific headers from the HTTP request.
/interceptors/APISecurity.cfc
1
/**
2
* This interceptor secures all API requests
3
*/
4
component{
5
    // This will only run when the event starts with "api."
6
    function preProcess( event, interceptData, buffer ) eventPattern = '^api\.' {
7
        var APIUser = event.getHTTPHeader( 'APIUser', 'default' );
8
​
9
        // Only Honest Abe can access our API
10
        if( APIUser != 'Honest Abe' ) {
11
            // Every one else will get the error response from this event
12
            event.overrideEvent( 'api.general.authFailed' );
13
        }
14
    }
15
}
Copied!
Register the interceptor with ColdBox in your ColdBox.cfc:
config/ColdBox.cfc
1
interceptors = [
2
  { class="interceptors.APISecurity" }
3
];
Copied!
As you can see, there are many points to apply security to your API. One not covered here would be to tap into WireBox's AOP and place your security checks into an advice that can be bound to whatever API method you need to be secured.
Restricting HTTP Verbs
In our route configuration we mapped HTTP verbs to handlers and actions, but what if users try to access resources directly with an invalid HTTP verb? You can easily enforce valid verbs (methods) by adding this.allowedMethods at the top of your handler. In this handler the list() method can only be accessed via a GET, and the remove() method can only be accessed via POST and DELETE.
1
component{
2
​
3
    this.allowedMethods = { 
4
        remove = "POST,DELETE",
5
        list   = "GET"
6
    };
7
​
8
    function list( event, rc, prc ){}
9
​
10
    function remove( event, rc, prc ){}
11
}
Copied!
The key is the name of the action and the value is a list of allowed HTTP methods. If the action is not listed in the structure, then it means allow all. If the request action HTTP method is not found in the list then it throws a 405 exception. You can catch this scenario and still return a properly-formatted response to your clients by using the onError() or the onInvalidHTTPMethod() convention in your handler or an exception handler which applies to the entire app.
Error Handling
ColdBox REST APIs can use all the same error faculties that an ordinary ColdBox application has. We'll cover three of the most common ways here.
Handler onError()
If you create a method called onError() in a handler, ColdBox will automatically call that method for runtime errors that occur while executing any of the actions in that handler. This allows for localized error handling that is customized to that resource.
1
// error uniformity for resources
2
function onError( event, rc, prc, faultaction, exception ){
3
    prc.response = getModel("ResponseObject");
4
​
5
    // setup error response
6
    prc.response.setError(true);
7
    prc.response.addMessage("Error executing resource #arguments.exception.message#");
8
​
9
    // log exception
10
    log.error( "The action: #arguments.faultaction# failed when requesting resource: #arguments.event.getCurrentRoutedURL()#", getHTTPRequestData() );
11
​
12
    // display
13
    arguments.event.setHTTPHeader(statusCode="500",statusText="Error executing resource #arguments.exception.message#")
14
        .renderData( data=prc.response.getDataPacket(), type="json" );
15
}
Copied!
Handler onInvalidHTTPMethod()
If you create a method called onInvalidHTTPMethod() in a handler, ColdBox will automatically call that method whenever an action is trying to be executed with an invalid HTTP verb. This allows for localized error handling that is customized to that resource.
1
/**
2
* on invalid http verbs
3
*/
4
function onInvalidHTTPMethod( event, rc, prc, faultAction, eventArguments ){
5
    // Log Locally
6
    log.warn( "InvalidHTTPMethod Execution of (#arguments.faultAction#): #event.getHTTPMethod()#", getHTTPRequestData() );
7
    // Setup Response
8
    prc.response = getModel( "Response" )
9
        .setError( true )
10
        .setErrorCode( 405 )
11
        .addMessage( "InvalidHTTPMethod Execution of (#arguments.faultAction#): #event.getHTTPMethod()#" )
12
        .setStatusCode( 405 )
13
        .setStatusText( "Invalid HTTP Method" );
14
    // Render Error Out
15
    event.renderData( 
16
        type        = prc.response.getFormat(),
17
        data         = prc.response.getDataPacket(),
18
        contentType = prc.response.getContentType(),
19
        statusCode     = prc.response.getStatusCode(),
20
        statusText     = prc.response.getStatusText(),
21
        location     = prc.response.getLocation(),
22
        isBinary     = prc.response.getBinary()
23
    );
24
}
Copied!
Global Exception Handler
The global exception handler will get called for any runtime errors that happen anywhere in the typical flow of your application. This is like the onError() convention but covers the entire application. First, configure the event you want called in the ColdBox.cfc config file. The event must have the handler plus action that you want called.
config/ColdBox.cfc
1
coldbox = {
2
    ...
3
    exceptionHandler = "main.onException"
4
    ...
5
};
Copied!
Then create that action and put your exception handling code inside. You can choose to do error logging, notifications, or custom output here. You can even run other events.
1
// /handlers/main.cfc
2
component {
3
    function onException( event, rc, prc ){
4
        // Log the exception via LogBox
5
        log.error( prc.exception.getMessage() & prc.exception.getDetail(), prc.exception.getMemento() );
6
​
7
        // Flash where the exception occurred
8
        flash.put("exceptionURL", event.getCurrentRoutedURL() );
9
​
10
        // Relocate to fail page
11
        relocate("main.fail");
12
    }
13
}
Copied!
ColdBox Relax
ColdBox Relax is a set of ReSTful Tools For Lazy Experts. We pride ourselves in helping you (the developer) work smarter and ColdBox Relax is a tool to help you document your projects faster. ColdBox Relax provides you with the necessary tools to automagically model, document and test your ReSTful services. One can think of ColdBox Relax as a way to describe ReSTful web services, test ReSTful web services, monitor ReSTful web services and document ReSTful web services–all while you relax!
1
install relax --saveDev
Copied!
Please note: Installing relax via CommandBox installs without the examples, if required you will need to obtain the examples from the Relax Github repo here: https://github.com/ColdBox/coldbox-relax​
To install the examples place them into the models directory in a subdirectory called 'resources' (as per the Github repo), then add the following relax structure to your Coldbox.cfc file:
1
relax = {
2
    // The location of the relaxed APIs, defaults to models.resources
3
    APILocation = "models.resources",
4
    // Default API to load, name of the directory inside of resources
5
    defaultAPI = "myapi",
6
    // History stack size, the number of history items to track in the RelaxURL
7
    maxHistory = 10
8
};
Copied!
You can then visit http://[yourhost]/relax to view Relax.
You can read more about Relax on the Official Relax Doc page (http://www.ortussolutions.com/products/relax) or at it's repository: https://github.com/coldbox/coldbox-relax​
Ref Card - https://github.com/ColdBox/cbox-refcards/raw/master/ColdBox REST APIs/ColdBox-REST-APIs-Refcard.pdf​
Digging Deeper - Previous
Recipes
Application Templates
Last modified 1yr ago
Overview

Quick Reference Card

Introduction To REST

Defining Resources

Defining URL Routes

Route Placeholders

Numeric Pattern Matcher

Alphabetic Pattern Matcher

Regex Pattern Matcher

Placeholder Quantifiers

Returning Representations (Data)

Handler Return Data

renderData()

Format Detection

Status Codes

Caching

Auto-Deserialization of JSON Payloads

Security

Requiring SSL

Basic HTTP Auth

Custom

Restricting HTTP Verbs

Error Handling

Handler `onError()`

Handler `onInvalidHTTPMethod()`

Global Exception Handler

ColdBox Relax
