11.5.11. /db/_design/design-doc/_rewrite/path

ANY /{db}/_design/{ddoc}/_rewrite/{path}

Rewrites the specified path by rules defined in the specified design document. The rewrite rules are defined by the rewrites field of the design document. The rewrites field can either be a string containing the a rewrite function or an array of rule definitions.

11.5.11.1. Using a stringified function for rewrites

New in version 2.0: When the rewrites field is a stringified function, the query server is used to pre-process and route requests.

The function takes a Request2 object.

The return value of the function will cause the server to rewrite the request to a new location or immediately return a response.

To rewrite the request, return an object containing the following properties:

  • path (string): Rewritten path.
  • query (array): Rewritten query. If omitted, the original query keys are used.
  • headers (object): Rewritten headers. If omitted, the original request headers are used.
  • method (string): HTTP method of rewritten request ("GET", "POST", etc). If omitted, the original request method is used.
  • body (string): Body for "POST"/"PUT" requests. If omitted, the original request body is used.

To immediately respond to the request, return an object containing the following properties:

  • code (number): Returned HTTP status code (200, 404, etc).
  • body (string): Body of the response to user.

Example A. Restricting access.

function(req2) {
  var path = req2.path.slice(4),
    isWrite = /^(put|post|delete)$/i.test(req2.method),
    isFinance = req2.userCtx.roles.indexOf("finance") > -1;
  if (path[0] == "finance" && isWrite && !isFinance) {
    // Deny writes to  DB "finance" for users
    // having no "finance" role
    return {
      code: 403,
      body: JSON.stringify({
        error: "forbidden".
        reason: "You are not allowed to modify docs in this DB"
      })
    };
  }
  // Pass through all other requests
  return { path: "../../../" + path.join("/") };
}

Example B. Different replies for JSON and HTML requests.

function(req2) {
  var path = req2.path.slice(4),
    h = headers,
    wantsJson = (h.Accept || "").indexOf("application/json") > -1,
    reply = {};
  if (!wantsJson) {
    // Here we should prepare reply object
    // for plain HTML pages
  } else {
    // Pass through JSON requests
    reply.path = "../../../"+path.join("/");
  }
  return reply;
}

11.5.11.2. Using an array of rules for rewrites

When the rewrites field is an array of rule objects, the server will rewrite the request based on the first matching rule in the array.

Each rule in the array is an object with the following fields:

  • method (string): HTTP request method to bind the request method to the rule. If omitted, uses "*", which matches all methods.
  • from (string): The pattern used to compare against the URL and define dynamic variables.
  • to (string): The path to rewrite the URL to. It can contain variables depending on binding variables discovered during pattern matching and query args (URL args and from the query member).
  • query (object): Query args passed to the rewritten URL. They may contain dynamic variables.

The to and from paths may contains string patterns with leading : or * characters to define dynamic variables in the match.

The first rule in the rewrites array that matches the incoming request is used to define the rewrite. To match the incoming request, the rule’s method must match the request’s HTTP method and the rule’s from must match the request’s path using the following pattern matching logic.

  • The from pattern and URL are first split on / to get a list of tokens. For example, if from field is /somepath/:var/* and the URL is /somepath/a/b/c, the tokens are somepath, :var, and * for the from pattern and somepath, a, b, and c for the URL.
  • Each token starting with : in the pattern will match the corresponding token in the URL and define a new dynamic variable whose name is the remaining string after the : and value is the token from the URL. In this example, the :var token will match b and set var = a.
  • The star token * in the pattern will match any number of tokens in the URL and must be the last token in the pattern. It will define a dynamic variable with the remaining tokens. In this example, the * token will match the b and c tokens and set * = b/c.
  • The remaining tokens must match exactly for the pattern to be considered a match. In this example, somepath in the pattern matches somepath in the URL and all tokens in the URL have matched, causing this rule to be a match.

Once a rule is found, the request URL is rewritten using the to and query fields. Dynamic variables are substituted into the : and * variables in these fields to produce the final URL.

If no rule matches, a 404 Not Found response is returned.

Examples:

Rule URL Rewrite to Tokens
{“from”: “/a”,
“to”: “/some”}
/a /some  
{“from”: “/a/*”,
“to”: “/some/*}
/a/b/c /some/b/c  
{“from”: “/a/b”,
“to”: “/some”}
/a/b?k=v /some?k=v k=v
{“from”: “/a/b”,
“to”: “/some/:var”}
/a/b /some/b?var=b var=b
{“from”: “/a/:foo/”,
“to”: “/some/:foo/”}
/a/b/c /some/b/c?foo=b foo=b
{“from”: “/a/:foo”,
“to”: “/some”, “query”: { “k”: “:foo” }}
/a/b /some/?k=b&foo=b foo=b
{“from”: “/a”,
“to”: “/some/:foo”}
/a?foo=b /some/?b&foo=b foo=b

Request method, header, query parameters, request payload and response body are dependent on the endpoint to which the URL will be rewritten.

param db:Database name
param ddoc:Design document name
param path:URL path to rewrite