Improve docs and tests, and add instance conditions and href rewriting

Author: Qard

README.md

@@ -62,6 +62,7 @@ console.log(response.body.toString())
   * `docroot` {String} Document root for PHP. **Default:** process.cwd()
   * `throwRequestErrors` {Boolean} Throw request errors rather than returning
     responses with error codes. **Default:** false
+  * `rewriter` {Rewriter} Optional rewrite rules. **Default:** `undefined`
 * Returns: {Php}
 
 Construct a new PHP instance to which to dispatch requests.
@@ -560,9 +561,80 @@ headers.forEach((value, name, headers) => {
 })
 ```
 
+### `new Rewriter(input)`
+
+* `rules` {Array} The set of rewriting rules to apply to each request
+  * `operation` {String} Operation type (`and` or `or`) **Default:** `and`
+  * `conditions` {Array} Conditions to match against the request
+    * `type` {String} Condition type
+    * `args` {String} Arguments to pass to condition constructor
+  * `rewriters` {Array} Rewrites to apply if the conditions match
+    * `type` {String} Rewriter type
+    * `args` {String} Arguments to pass to rewriter constructor
+* Returns: {Rewriter}
+
+Construct a Rewriter to rewrite requests before they are dispatched to PHP.
+
+```js
+import { Rewriter } from '@platformatic/php-node'
+
+const rewriter = new Rewriter([{
+  conditions: [{
+    type: 'header',
+    args: ['User-Agent', '^(Mozilla|Chrome)']
+  }],
+  rewriters: [{
+    type: 'path',
+    args: ['^/old-path/(.*)$', '/new-path/$1']
+  }]
+}])
+```
+
+#### Conditions
+
+There are several types of conditions which may be used to match against the
+request. Each condition type has a set of arguments which are passed to the
+constructor of the condition. The condition will be evaluated against the
+request and if it matches, the rewriters will be applied.
+
+The available condition types are:
+
+- `exists` Matches if request path exists in docroot.
+- `not_exists` Matches if request path does not exist in docroot.
+- `header(name, pattern)` Matches named header against a pattern.
+  - `name` {String} The name of the header to match.
+  - `pattern` {String} The regex pattern to match against the header value.
+- `method(pattern)` Matches request method against a pattern.
+  - `pattern` {String} The regex pattern to match against the HTTP method.
+- `path(pattern)`: Matches request path against a pattern.
+  - `pattern` {String} The regex pattern to match against the request path.
+
+#### Rewriters
+
+There are several types of rewriters which may be used to rewrite the request
+before it is dispatched to PHP. Each rewriter type has a set of arguments which
+are passed to the constructor of the rewriter. The rewriter will be applied to
+the request if the conditions match.
+
+The available rewriter types are:
+
+- `header(name, replacement)` Sets a named header to a given replacement.
+  - `name` {String} The name of the header to set.
+  - `replacement` {String} The replacement string to use for named header.
+- `href(pattern, replacement)` Rewrites request path, query, and fragment to
+  given replacement.
+  - `pattern` {String} The regex pattern to match against the request path.
+  - `replacement` {String} The replacement string to use for request path.
+- `method(replacement)` Sets the request method to a given replacement.
+  - `replacement` {String} The replacement string to use for request method.
+- `path(pattern, replacement)` Rewrites request path to given replacement.
+  - `pattern` {String} The regex pattern to match against the request path.
+  - `replacement` {String} The replacement string to use for request path.
+
 ## Contributing
 
-This project is part of the [Platformatic](https://github.com/platformatic) ecosystem. Please refer to the main repository for contribution guidelines.
+This project is part of the [Platformatic](https://github.com/platformatic)
+ecosystem. Please refer to the main repository for contribution guidelines.
 
 ## License
 

__test__/handler.spec.mjs

@@ -175,19 +175,13 @@ test('Accept rewriter', async (t) => {
   })
   t.teardown(() => mockroot.clean())
 
-  const rewrite = new Rewriter([
+  const rewriter = new Rewriter([
     {
       conditions: [
-        {
-          type: 'path',
-          args: ['^/rewrite_me$']
-        }
+        { type: 'path', args: ['^/rewrite_me$'] }
       ],
       rewriters: [
-        {
-          type: 'path',
-          args: ['^/rewrite_me$', '/index.php']
-        }
+        { type: 'path', args: ['^/rewrite_me$', '/index.php'] }
       ]
     }
   ])
@@ -196,7 +190,7 @@ test('Accept rewriter', async (t) => {
     argv: process.argv,
     docroot: mockroot.path,
     throwRequestErrors: true,
-    rewrite
+    rewriter
   })
 
   const req = new Request({

__test__/rewriter.spec.mjs

@@ -2,36 +2,287 @@ import test from 'ava'
 
 import { Request, Rewriter } from '../index.js'
 
-test('rewrites URLs', (t) => {
+const docroot = import.meta.dirname
+
+test('existence condition', (t) => {
   const req = new Request({
     method: 'GET',
-    url: 'http://example.com/index.php',
+    url: 'http://example.com/util.mjs',
     headers: {
       TEST: ['foo']
     }
   })
 
   const rewriter = new Rewriter([
     {
-      operation: 'and',
       conditions: [
+        { type: 'exists' }
+      ],
+      rewriters: [
         {
           type: 'path',
-          args: ['^/index.php$']
-        },
-        {
-          type: 'header',
-          args: ['TEST', '^foo$']
+          args: ['.*', '/404']
         }
+      ]
+    }
+  ])
+
+  t.is(rewriter.rewrite(req, docroot).url, 'http://example.com/404')
+})
+
+test('non-existence condition', (t) => {
+  const req = new Request({
+    method: 'GET',
+    url: 'http://example.com/index.php',
+    headers: {
+      TEST: ['foo']
+    }
+  })
+
+  const rewriter = new Rewriter([
+    {
+      conditions: [
+        { type: 'not_exists' }
       ],
       rewriters: [
         {
           type: 'path',
-          args: ['^(/index.php)$', '/foo$1']
+          args: ['.*', '/404']
         }
       ]
     }
   ])
 
-  t.is(rewriter.rewrite(req).url, 'http://example.com/foo/index.php')
+  t.is(rewriter.rewrite(req, docroot).url, 'http://example.com/404')
+})
+
+test('condition groups - AND', (t) => {
+  const rewriter = new Rewriter([{
+    conditions: [
+      { type: 'header', args: ['TEST', 'foo'] },
+      { type: 'path', args: ['^(/index.php)$'] }
+    ],
+    rewriters: [
+      { type: 'path', args: ['^(/index.php)$', '/foo$1'] }
+    ]
+  }])
+
+  // Both conditions match, so rewrite is applied
+  {
+    const req = new Request({
+      method: 'GET',
+      url: 'http://example.com/index.php',
+      headers: {
+        TEST: ['foo']
+      }
+    })
+
+    t.is(
+      rewriter.rewrite(req, docroot).url,
+      'http://example.com/foo/index.php'
+    )
+  }
+
+  // Header condition does not match, so rewrite is not applied
+  {
+    const req = new Request({
+      method: 'GET',
+      url: 'http://example.com/index.php'
+    })
+
+    t.is(
+      rewriter.rewrite(req, docroot).url,
+      'http://example.com/index.php'
+    )
+  }
+
+  // Path condition does not match, so rewrite is not applied
+  {
+    const req = new Request({
+      method: 'GET',
+      url: 'http://example.com/nope.php',
+      headers: {
+        TEST: ['foo']
+      }
+    })
+
+    t.is(
+      rewriter.rewrite(req, docroot).url,
+      'http://example.com/nope.php'
+    )
+  }
+})
+
+test('condition groups - OR', (t) => {
+  const rewriter = new Rewriter([{
+    operation: 'or',
+    conditions: [
+      { type: 'method', args: ['GET'] },
+      { type: 'path', args: ['^(/index.php)$'] }
+    ],
+    rewriters: [
+      { type: 'path', args: ['^(.*)$', '/foo$1'] }
+    ]
+  }])
+
+  // Both conditions match, so rewrite is applied
+  {
+    const req = new Request({
+      url: 'http://example.com/index.php'
+    })
+
+    t.is(
+      rewriter.rewrite(req, docroot).url,
+      'http://example.com/foo/index.php'
+    )
+  }
+
+  // Path condition matches, so rewrite is applied
+  {
+    const req = new Request({
+      url: 'http://example.com/index.php'
+    })
+
+    t.is(
+      rewriter.rewrite(req, docroot).url,
+      'http://example.com/foo/index.php'
+    )
+  }
+
+  // Header condition matches, so rewrite is applied
+  {
+    const req = new Request({
+      url: 'http://example.com/nope.php'
+    })
+
+    t.is(
+      rewriter.rewrite(req, docroot).url,
+      'http://example.com/foo/nope.php'
+    )
+  }
+
+  // Neither condition matches, so rewrite is not applied
+  {
+    const req = new Request({
+      method: 'POST',
+      url: 'http://example.com/nope.php'
+    })
+
+    t.is(
+      rewriter.rewrite(req, docroot).url,
+      'http://example.com/nope.php'
+    )
+  }
+})
+
+test('header rewriting', (t) => {
+  const rewriter = new Rewriter([{
+    rewriters: [
+      { type: 'header', args: ['TEST', '(.*)', '${1}bar'] }
+    ]
+  }])
+
+  const req = new Request({
+    method: 'GET',
+    url: 'http://example.com/index.php',
+    headers: {
+      TEST: ['foo']
+    }
+  })
+
+  t.is(rewriter.rewrite(req, docroot).headers.get('TEST'), 'foobar')
+})
+
+test('href rewriting', (t) => {
+  const rewriter = new Rewriter([{
+    rewriters: [
+      { type: 'href', args: [ '^(.*)$', '/index.php?route=${1}' ] }
+    ]
+  }])
+
+  const req = new Request({
+    url: 'http://example.com/foo/bar'
+  })
+
+  t.is(
+    rewriter.rewrite(req, docroot).url,
+    'http://example.com/index.php?route=/foo/bar'
+  )
+})
+
+test('method rewriting', (t) => {
+  const rewriter = new Rewriter([{
+    rewriters: [
+      { type: 'method', args: ['GET', 'POST'] }
+    ]
+  }])
+
+  const req = new Request({
+    url: 'http://example.com/index.php'
+  })
+
+  t.is(rewriter.rewrite(req, docroot).method, 'POST')
+})
+
+test('path rewriting', (t) => {
+  const rewriter = new Rewriter([{
+    rewriters: [
+      { type: 'path', args: ['^(/index.php)$', '/foo$1'] }
+    ]
+  }])
+
+  const req = new Request({
+    method: 'GET',
+    url: 'http://example.com/index.php',
+    headers: {
+      TEST: ['foo']
+    }
+  })
+
+  t.is(rewriter.rewrite(req, docroot).url, 'http://example.com/foo/index.php')
+})
+
+test('rewriter sequencing', (t) => {
+  const rewriter = new Rewriter([{
+    conditions: [
+      { type: 'path', args: ['^(/index.php)$'] }
+    ],
+    rewriters: [
+      { type: 'path', args: ['^(/index.php)$', '/bar$1'] },
+      { type: 'path', args: ['^(/bar)', '/foo$1'] }
+    ]
+  }])
+
+  // Condition matches, and both rewriters are applied in sequence
+  {
+    const req = new Request({
+      method: 'GET',
+      url: 'http://example.com/index.php',
+      headers: {
+        TEST: ['foo']
+      }
+    })
+
+    t.is(
+      rewriter.rewrite(req, docroot).url,
+      'http://example.com/foo/bar/index.php'
+    )
+  }
+
+  // Condition does not match, so no rewrites are applied even if the second
+  // rewriter would match
+  {
+    const req = new Request({
+      method: 'GET',
+      url: 'http://example.com/bar/baz.php',
+      headers: {
+        TEST: ['foo']
+      }
+    })
+
+    t.is(
+      rewriter.rewrite(req, docroot).url,
+      'http://example.com/bar/baz.php'
+    )
+  }
 })

crates/lang_handler/src/handler.rs

@@ -1,3 +1,49 @@
+//! # Handling Requests
+//!
+//! The `Handler` trait is used to define how requests are handled. It provides
+//! a method `handle` which takes a `Request` and returns a `Response`. This
+//! allows you to implement custom logic for handling requests, such as routing
+//! them to different services or processing them in some way.
+//!
+//! ```rust
+//! use lang_handler::{
+//!   Handler,
+//!   Request,
+//!   RequestBuilder,
+//!   Response,
+//!   ResponseBuilder
+//! };
+//!
+//! pub struct EchoServer;
+//! impl Handler for EchoServer {
+//!   type Error = String;
+//!   fn handle(&self, request: Request) -> Result<Response, Self::Error> {
+//!     let response = Response::builder()
+//!       .status(200)
+//!       .body(request.body())
+//!       .build();
+//!
+//!     Ok(response)
+//!   }
+//! }
+//!
+//! let handler = EchoServer;
+//!
+//! let request = Request::builder()
+//!   .method("POST")
+//!   .url("http://example.com")
+//!   .header("Accept", "application/json")
+//!   .body("Hello, world!")
+//!   .build()
+//!   .expect("should build request");
+//!
+//! let response = handler.handle(request)
+//!   .expect("should handle request");
+//!
+//! assert_eq!(response.status(), 200);
+//! assert_eq!(response.body(), "Hello, world!");
+//! ```
+
 use super::{Request, Response};
 
 /// Enables a type to support handling HTTP requests.

crates/lang_handler/src/headers.rs

@@ -1,3 +1,50 @@
+//! # Managing Headers
+//!
+//! The `Headers` type provides methods to read and manipulate HTTP headers.
+//!
+//! ```rust
+//! use lang_handler::Headers;
+//!
+//! // Setting and getting headers
+//! let mut headers = Headers::new();
+//! headers.set("Content-Type", "application/json");
+//! assert_eq!(headers.get("Content-Type"), Some("application/json".to_string()));
+//!
+//! // Checking if a header exists
+//! assert!(headers.has("Content-Type"));
+//!
+//! // Removing headers
+//! headers.remove("Content-Type");
+//! assert_eq!(headers.get("Content-Type"), None);
+//!
+//! // Adding multiple values to a header
+//! headers.add("Set-Cookie", "sessionid=abc123");
+//! headers.add("Set-Cookie", "userid=42");
+//!
+//! // Iterating over headers
+//! for (name, value) in headers.iter() {
+//!   println!("{}: {:?}", name, value);
+//! }
+//!
+//! // Getting all values for a header
+//! let cookies = headers.get_all("Set-Cookie");
+//! assert_eq!(cookies, vec!["sessionid=abc123", "userid=42"]);
+//!
+//! // Getting a set of headers as a string line
+//! headers.add("Accept", "text/plain");
+//! headers.add("Accept", "application/json");
+//! let accept_header = headers.get_line("Accept");
+//!
+//! // Counting header lines
+//! assert!(headers.len() > 0);
+//!
+//! // Clearing all headers
+//! headers.clear();
+//!
+//! // Checking if headers are empty
+//! assert!(headers.is_empty());
+//! ```
+
 use std::collections::{hash_map::Entry, HashMap};
 
 #[derive(Debug, Clone)]

crates/lang_handler/src/lib.rs

@@ -1,3 +1,12 @@
+//! # HTTP Request Management
+//!
+//! Lang Handler is a library intended for managing HTTP requests between
+//! multiple languages. It provides types for representing Headers, Request,
+//! and Response, as well as providing a Handler trait for dispatching
+//! Request objects into some other system which produces a Response.
+//! This may be another language runtime, or it could be a server application
+//! directly in Rust.
+
 #[cfg(feature = "c")]
 mod ffi;
 mod handler;
@@ -11,7 +20,7 @@ mod test;
 pub use ffi::*;
 pub use handler::Handler;
 pub use headers::{Header, Headers};
-pub use request::{Request, RequestBuilder};
+pub use request::{Request, RequestBuilder, RequestBuilderException};
 pub use response::{Response, ResponseBuilder};
 pub use test::{MockRoot, MockRootBuilder};
 pub use url::Url;

crates/lang_handler/src/request.rs

@@ -1,3 +1,45 @@
+//! # Building a Request
+//!
+//! The `Request` type provides a `builder` method which allows you to
+//! construct a `Request` object using a fluent API. This allows you to
+//! set the URL, HTTP method, headers, body, and other properties of the
+//! request in a clear and concise manner.
+//!
+//! # Example
+//!
+//! ```rust
+//! use lang_handler::{Request, RequestBuilder};
+//!
+//! let request = Request::builder()
+//!   .method("GET")
+//!   .url("http://example.com")
+//!   .header("Accept", "application/json")
+//!   .build()
+//!   .expect("should build request");
+//! ```
+//!
+//! # Reading a Request
+//!
+//! The `Request` type also provides methods to read the URL, HTTP method,
+//! headers, and body of the request. This allows you to access the properties
+//! of the request in a straightforward manner.
+//!
+//! ```rust
+//! # use lang_handler::Request;
+//! #
+//! # let request = Request::builder()
+//! #   .method("GET")
+//! #   .url("http://example.com")
+//! #   .header("Accept", "application/json")
+//! #   .build()
+//! #   .expect("should build request");
+//! #
+//! assert_eq!(request.method(), "GET");
+//! assert_eq!(request.url().to_string(), "http://example.com/");
+//! assert_eq!(request.headers().get("Accept"), Some("application/json".to_string()));
+//! assert_eq!(request.body(), "");
+//! ```
+
 use std::{fmt::Debug, net::SocketAddr};
 
 use bytes::{Bytes, BytesMut};
@@ -276,7 +318,7 @@ impl Request {
 }
 
 /// Errors which may be produced when building a Request from a RequestBuilder.
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Eq, Hash)]
 pub enum RequestBuilderException {
   /// Url is required
   UrlMissing,

crates/lang_handler/src/response.rs

@@ -1,3 +1,45 @@
+//! # Building a Response
+//!
+//! The `Response` type also provides a `builder` method which allows you to
+//! construct a `Response` object using a fluent API. This allows you to
+//! set the status code, headers, body, and other properties of the
+//! response in a clear and concise manner.
+//!
+//! ```rust
+//! use lang_handler::{Response, ResponseBuilder};
+//!
+//! let response = Response::builder()
+//!   .status(200)
+//!   .header("Content-Type", "application/json")
+//!   .body("{\"message\": \"Hello, world!\"}")
+//!   .log("This is a log message")
+//!   .exception("This is an exception message")
+//!   .build();
+//! ```
+//!
+//! # Reading a Response
+//!
+//! The `Response` type provides methods to read the status code, headers,
+//! body, log, and exception of the response.
+//!
+//! ```rust
+//! # use lang_handler::{Response, ResponseBuilder};
+//! #
+//! # let response = Response::builder()
+//! #   .status(200)
+//! #   .header("Content-Type", "text/plain")
+//! #   .body("Hello, World!")
+//! #   .log("This is a log message")
+//! #   .exception("This is an exception message")
+//! #   .build();
+//! #
+//! assert_eq!(response.status(), 200);
+//! assert_eq!(response.headers().get("Content-Type"), Some("text/plain".to_string()));
+//! assert_eq!(response.body(), "Hello, World!");
+//! assert_eq!(response.log(), "This is a log message");
+//! assert_eq!(response.exception(), Some(&"This is an exception message".to_string()));
+//! ```
+
 use bytes::{Bytes, BytesMut};
 
 use super::Headers;
@@ -250,6 +292,31 @@ impl ResponseBuilder {
     }
   }
 
+  /// Builds the response.
+  ///
+  /// # Example
+  ///
+  /// ```
+  /// use lang_handler::ResponseBuilder;
+  ///
+  /// let response = ResponseBuilder::new()
+  ///   .build();
+  ///
+  /// assert_eq!(response.status(), 200);
+  /// assert_eq!(response.body(), "");
+  /// assert_eq!(response.log(), "");
+  /// assert_eq!(response.exception(), None);
+  /// ```
+  pub fn build(&self) -> Response {
+    Response {
+      status: self.status.unwrap_or(200),
+      headers: self.headers.clone(),
+      body: self.body.clone().freeze(),
+      log: self.log.clone().freeze(),
+      exception: self.exception.clone(),
+    }
+  }
+
   /// Creates a new response builder that extends the given response.
   ///
   /// # Example
@@ -385,31 +452,6 @@ impl ResponseBuilder {
     self.exception = Some(exception.into());
     self
   }
-
-  /// Builds the response.
-  ///
-  /// # Example
-  ///
-  /// ```
-  /// use lang_handler::ResponseBuilder;
-  ///
-  /// let response = ResponseBuilder::new()
-  ///   .build();
-  ///
-  /// assert_eq!(response.status(), 200);
-  /// assert_eq!(response.body(), "");
-  /// assert_eq!(response.log(), "");
-  /// assert_eq!(response.exception(), None);
-  /// ```
-  pub fn build(&self) -> Response {
-    Response {
-      status: self.status.unwrap_or(200),
-      headers: self.headers.clone(),
-      body: self.body.clone().freeze(),
-      log: self.log.clone().freeze(),
-      exception: self.exception.clone(),
-    }
-  }
 }
 
 impl Default for ResponseBuilder {

crates/lang_handler/src/rewrite/condition/closure.rs

@@ -1,16 +1,20 @@
+use std::path::Path;
+
 use super::{Condition, Request};
 
 impl<F> Condition for F
 where
-  F: Fn(&Request) -> bool + Sync + Send,
+  F: Fn(&Request, &Path) -> bool + Sync + Send,
 {
   /// Matches if calling the Fn(&Request) with the given request returns true
   ///
   /// # Examples
   ///
   /// ```
+  /// # use std::path::Path;
   /// # use lang_handler::{Request, rewrite::Condition};
-  /// let condition = |request: &Request| {
+  /// # let docroot = std::env::temp_dir();
+  /// let condition = |request: &Request, _docroot: &Path| {
   ///   request.url().path().contains("/foo")
   /// };
   ///
@@ -19,9 +23,9 @@ where
   ///   .build()
   ///   .expect("request should build");
   ///
-  /// assert_eq!(condition.matches(&request), false);
+  /// assert_eq!(condition.matches(&request, &docroot), false);
   /// ```
-  fn matches(&self, request: &Request) -> bool {
-    self(request)
+  fn matches(&self, request: &Request, docroot: &Path) -> bool {
+    self(request, docroot)
   }
 }

crates/lang_handler/src/rewrite/condition/existence.rs

@@ -1,29 +1,11 @@
-use std::path::PathBuf;
+use std::path::Path;
 
 use super::Condition;
 use super::Request;
 
 /// Match if request path exists
-#[derive(Clone, Debug)]
-pub struct ExistenceCondition(PathBuf);
-
-impl ExistenceCondition {
-  /// Construct an ExistenceCondition to check within a given base directory.
-  ///
-  /// # Examples
-  ///
-  /// ```
-  /// # use lang_handler::rewrite::{Condition, ExistenceCondition};
-  /// # use lang_handler::Request;
-  /// let condition = ExistenceCondition::new("/foo/bar");
-  /// ```
-  pub fn new<P>(base: P) -> Self
-  where
-    P: Into<PathBuf>,
-  {
-    Self(base.into())
-  }
-}
+#[derive(Clone, Debug, Default)]
+pub struct ExistenceCondition;
 
 impl Condition for ExistenceCondition {
   /// An ExistenceCondition matches a request if the path segment of the
@@ -32,21 +14,35 @@ impl Condition for ExistenceCondition {
   /// # Examples
   ///
   /// ```
-  /// # use lang_handler::rewrite::{Condition, ExistenceCondition};
-  /// # use lang_handler::Request;
-  /// let condition = ExistenceCondition::new("/foo/bar");
+  /// # use lang_handler::{
+  /// #   rewrite::{Condition, ExistenceCondition},
+  /// #   Request,
+  /// #   MockRoot
+  /// # };
+  /// #
+  /// # let docroot = MockRoot::builder()
+  /// #   .file("exists.php", "<?php echo \"Hello, world!\"; ?>")
+  /// #   .build()
+  /// #   .expect("should prepare docroot");
+  /// let condition = ExistenceCondition;
   ///
   /// let request = Request::builder()
-  ///   .url("http://example.com/index.php")
+  ///   .url("http://example.com/exists.php")
   ///   .build()
   ///   .expect("should build request");
   ///
-  /// assert_eq!(condition.matches(&request), false);
+  /// assert!(condition.matches(&request, &docroot));
+  /// # assert!(!condition.matches(
+  /// #   &request.extend()
+  /// #      .url("http://example.com/does_not_exist.php")
+  /// #      .build()
+  /// #      .expect("should build request"),
+  /// #   &docroot
+  /// # ));
   /// ```
-  fn matches(&self, request: &Request) -> bool {
+  fn matches(&self, request: &Request, docroot: &Path) -> bool {
     let path = request.url().path();
-    self
-      .0
+    docroot
       .join(path.strip_prefix("/").unwrap_or(path))
       .canonicalize()
       .is_ok()
@@ -55,25 +51,7 @@ impl Condition for ExistenceCondition {
 
 /// Match if request path does not exist
 #[derive(Clone, Debug, Default)]
-pub struct NonExistenceCondition(PathBuf);
-
-impl NonExistenceCondition {
-  /// Construct a NonExistenceCondition to check within a given base directory.
-  ///
-  /// # Examples
-  ///
-  /// ```
-  /// # use lang_handler::rewrite::{Condition, NonExistenceCondition};
-  /// # use lang_handler::Request;
-  /// let condition = NonExistenceCondition::new("/foo/bar");
-  /// ```
-  pub fn new<P>(base: P) -> Self
-  where
-    P: Into<PathBuf>,
-  {
-    Self(base.into())
-  }
-}
+pub struct NonExistenceCondition;
 
 impl Condition for NonExistenceCondition {
   /// A NonExistenceCondition matches a request if the path segment of the
@@ -82,60 +60,37 @@ impl Condition for NonExistenceCondition {
   /// # Examples
   ///
   /// ```
-  /// # use lang_handler::rewrite::{Condition, NonExistenceCondition};
-  /// # use lang_handler::Request;
-  /// let condition = NonExistenceCondition::new("/foo/bar");
+  /// # use lang_handler::{
+  /// #   rewrite::{Condition, NonExistenceCondition},
+  /// #   Request,
+  /// #   MockRoot
+  /// # };
+  /// #
+  /// # let docroot = MockRoot::builder()
+  /// #   .file("exists.php", "<?php echo \"Hello, world!\"; ?>")
+  /// #   .build()
+  /// #   .expect("should prepare docroot");
+  /// let condition = NonExistenceCondition;
   ///
   /// let request = Request::builder()
-  ///   .url("http://example.com/index.php")
+  ///   .url("http://example.com/does_not_exist.php")
   ///   .build()
   ///   .expect("should build request");
   ///
-  /// assert!(condition.matches(&request));
+  /// assert!(condition.matches(&request, &docroot));
+  /// # assert!(!condition.matches(
+  /// #   &request.extend()
+  /// #      .url("http://example.com/exists.php")
+  /// #      .build()
+  /// #      .expect("should build request"),
+  /// #   &docroot
+  /// # ));
   /// ```
-  fn matches(&self, request: &Request) -> bool {
+  fn matches(&self, request: &Request, docroot: &Path) -> bool {
     let path = request.url().path();
-    self
-      .0
+    docroot
       .join(path.strip_prefix("/").unwrap_or(path))
       .canonicalize()
       .is_err()
   }
 }
-
-#[cfg(test)]
-mod test {
-  use super::*;
-  use crate::MockRoot;
-
-  #[test]
-  fn test_existence_condition() {
-    let docroot = MockRoot::builder()
-      .file("exists.php", "<?php echo \"Hello, world!\"; ?>")
-      .build()
-      .expect("should prepare docroot");
-
-    let condition = ExistenceCondition::new(docroot.clone());
-
-    let request = Request::builder()
-      .url("http://example.com/exists.php")
-      .build()
-      .expect("request should build");
-
-    assert!(condition.matches(&request));
-  }
-
-  #[test]
-  fn test_non_existence_condition() {
-    let docroot = MockRoot::builder().build().expect("should prepare docroot");
-
-    let condition = NonExistenceCondition::new(docroot.clone());
-
-    let request = Request::builder()
-      .url("http://example.com/does_not_exist.php")
-      .build()
-      .expect("request should build");
-
-    assert!(condition.matches(&request));
-  }
-}

crates/lang_handler/src/rewrite/condition/group.rs

@@ -1,3 +1,5 @@
+use std::path::Path;
+
 use super::{Condition, Request};
 
 // Tested via Condition::and(...) and Condition::or(...) doctests
@@ -32,10 +34,34 @@ where
   A: Condition + ?Sized,
   B: Condition + ?Sized,
 {
-  fn matches(&self, request: &Request) -> bool {
+  /// Evaluates the condition group against the provided request.
+  ///
+  /// # Examples
+  ///
+  /// ```
+  /// # use std::path::Path;
+  /// # let docroot = std::env::temp_dir();
+  /// # use lang_handler::{Request, rewrite::{Condition, ConditionGroup}};
+  /// let condition = ConditionGroup::or(
+  ///   Box::new(|_req: &Request, _docroot: &Path| true),
+  ///   Box::new(|_req: &Request, _docroot: &Path| false),
+  /// );
+  ///
+  /// let request = Request::builder()
+  ///   .url("http://example.com")
+  ///   .build()
+  ///   .expect("should build request");
+  ///
+  /// assert!(condition.matches(&request, &docroot));
+  /// ```
+  fn matches(&self, request: &Request, docroot: &Path) -> bool {
     match self {
-      ConditionGroup::Or(a, b) => a.matches(request) || b.matches(request),
-      ConditionGroup::And(a, b) => a.matches(request) && b.matches(request),
+      ConditionGroup::Or(a, b) => {
+        a.matches(request, docroot) || b.matches(request, docroot)
+      },
+      ConditionGroup::And(a, b) => {
+        a.matches(request, docroot) && b.matches(request, docroot)
+      },
     }
   }
 }

crates/lang_handler/src/rewrite/condition/header.rs

@@ -1,4 +1,4 @@
-use std::fmt::Debug;
+use std::{fmt::Debug, path::Path};
 
 use regex::{Error, Regex};
 
@@ -45,6 +45,7 @@ impl Condition for HeaderCondition {
   /// ```
   /// # use lang_handler::rewrite::{Condition, HeaderCondition};
   /// # use lang_handler::Request;
+  /// # let docroot = std::env::temp_dir();
   /// let condition = HeaderCondition::new("TEST", "^foo$")
   ///   .expect("should be valid regex");
   ///
@@ -54,9 +55,9 @@ impl Condition for HeaderCondition {
   ///   .build()
   ///   .expect("should build request");
   ///
-  /// assert!(condition.matches(&request));
+  /// assert!(condition.matches(&request, &docroot));
   /// ```
-  fn matches(&self, request: &Request) -> bool {
+  fn matches(&self, request: &Request, _docroot: &Path) -> bool {
     request
       .headers()
       .get_line(&self.name)

crates/lang_handler/src/rewrite/condition/mod.rs

@@ -2,21 +2,25 @@ mod closure;
 mod existence;
 mod group;
 mod header;
+mod method;
 mod path;
 
+use std::path::Path;
+
 use crate::Request;
 
 pub use existence::{ExistenceCondition, NonExistenceCondition};
 pub use group::ConditionGroup;
 pub use header::HeaderCondition;
+pub use method::MethodCondition;
 pub use path::PathCondition;
 
 /// A Condition is used to match against request state before deciding to apply
 /// a given Rewrite or set of Rewrites.
 pub trait Condition: Sync + Send {
   /// A Condition must implement a `matches(request) -> bool` method which
   /// receives a request object to determine if the condition is met.
-  fn matches(&self, request: &Request) -> bool;
+  fn matches(&self, request: &Request, docroot: &Path) -> bool;
 }
 
 impl<T: ?Sized> ConditionExt for T where T: Condition {}
@@ -31,6 +35,7 @@ pub trait ConditionExt: Condition {
   /// #  Request,
   /// #  rewrite::{Condition, ConditionExt, PathCondition, HeaderCondition}
   /// # };
+  /// # let docroot = std::env::temp_dir();
   /// let path = PathCondition::new("^/index.php$")
   ///   .expect("should be valid regex");
   ///
@@ -45,7 +50,7 @@ pub trait ConditionExt: Condition {
   ///   .build()
   ///   .expect("should build request");
   ///
-  /// assert!(condition.matches(&request));
+  /// assert!(condition.matches(&request, &docroot));
   /// #
   /// # // SHould _not_ match if either condition does not match
   /// # let only_header = Request::builder()
@@ -54,14 +59,14 @@ pub trait ConditionExt: Condition {
   /// #   .build()
   /// #   .expect("request should build");
   /// #
-  /// # assert!(!condition.matches(&only_header));
+  /// # assert!(!condition.matches(&only_header, &docroot));
   /// #
   /// # let only_url = Request::builder()
   /// #   .url("http://example.com/index.php")
   /// #   .build()
   /// #   .expect("request should build");
   /// #
-  /// # assert!(!condition.matches(&only_url));
+  /// # assert!(!condition.matches(&only_url, &docroot));
   /// ```
   fn and<C>(self: Box<Self>, other: Box<C>) -> Box<ConditionGroup<Self, C>>
   where
@@ -79,6 +84,7 @@ pub trait ConditionExt: Condition {
   /// #  Request,
   /// #  rewrite::{Condition, ConditionExt, PathCondition, HeaderCondition}
   /// # };
+  /// # let docroot = std::env::temp_dir();
   /// let path = PathCondition::new("^/index.php$")
   ///   .expect("should be valid regex");
   ///
@@ -92,7 +98,7 @@ pub trait ConditionExt: Condition {
   ///   .build()
   ///   .expect("should build request");
   ///
-  /// assert!(condition.matches(&request));
+  /// assert!(condition.matches(&request, &docroot));
   /// #
   /// # // Should match if one condition does not
   /// # let only_header = Request::builder()
@@ -101,14 +107,14 @@ pub trait ConditionExt: Condition {
   /// #   .build()
   /// #   .expect("request should build");
   /// #
-  /// # assert!(condition.matches(&only_header));
+  /// # assert!(condition.matches(&only_header, &docroot));
   /// #
   /// # let only_url = Request::builder()
   /// #   .url("http://example.com/index.php")
   /// #   .build()
   /// #   .expect("request should build");
   /// #
-  /// # assert!(condition.matches(&only_url));
+  /// # assert!(condition.matches(&only_url, &docroot));
   /// ```
   fn or<C>(self: Box<Self>, other: Box<C>) -> Box<ConditionGroup<Self, C>>
   where

crates/lang_handler/src/rewrite/condition/path.rs

@@ -1,4 +1,4 @@
-use std::fmt::Debug;
+use std::{path::Path, fmt::Debug};
 
 use regex::{Error, Regex};
 
@@ -32,6 +32,7 @@ impl Condition for PathCondition {
   /// ```
   /// # use lang_handler::rewrite::{Condition, PathCondition};
   /// # use lang_handler::Request;
+  /// # let docroot = std::env::temp_dir();
   /// let condition = PathCondition::new("^/index.php$")
   ///   .expect("should be valid regex");
   ///
@@ -40,9 +41,9 @@ impl Condition for PathCondition {
   ///   .build()
   ///   .expect("should build request");
   ///
-  /// assert!(condition.matches(&request));
+  /// assert!(condition.matches(&request, &docroot));
   /// ```
-  fn matches(&self, request: &Request) -> bool {
+  fn matches(&self, request: &Request, _docroot: &Path) -> bool {
     self.pattern.is_match(request.url().path())
   }
 }

crates/lang_handler/src/rewrite/conditional_rewriter.rs

@@ -1,6 +1,9 @@
+use std::path::Path;
+
 use crate::{
   rewrite::{Condition, Rewriter},
   Request,
+  RequestBuilderException
 };
 
 // Tested via Rewriter::when(...) doc-test
@@ -25,8 +28,8 @@ where
   R: Rewriter + ?Sized,
   C: Condition + ?Sized,
 {
-  fn matches(&self, request: &Request) -> bool {
-    self.1.matches(request)
+  fn matches(&self, request: &Request, docroot: &Path) -> bool {
+    self.1.matches(request, docroot)
   }
 }
 
@@ -35,11 +38,12 @@ where
   R: Rewriter + ?Sized,
   C: Condition + ?Sized,
 {
-  fn rewrite(&self, request: Request) -> Request {
-    self
-      .matches(&request)
-      .then(|| self.0.rewrite(request.clone()))
-      .or(Some(request))
-      .expect("should produce a request")
+  fn rewrite(&self, request: Request, docroot: &Path)
+    -> Result<Request, RequestBuilderException> {
+    if !self.matches(&request, docroot) {
+      return Ok(request);
+    }
+
+    self.0.rewrite(request, docroot)
   }
 }

crates/lang_handler/src/rewrite/mod.rs

@@ -20,6 +20,7 @@
 //! may be dispatched to any thread, these functions must be `Send + Sync`.
 //!
 //! ```
+//! # use lang_handler::{Request, rewrite::Condition};
 //! let condition = |request: &Request| -> bool {
 //!   request.url().path().starts_with("/foo")
 //! };
@@ -42,7 +43,8 @@
 //! be dispatched to any thread, these functions must be `Send + Sync`
 //!
 //! ```
-//! let rewriter = |request: Request| -> Request {
+//! # use lang_handler::{Request, RequestBuilderException, rewrite::Rewriter};
+//! let rewriter = |request: Request| -> Result<Request, RequestBuilderException> {
 //!   request.extend()
 //!     .url("http://example.com/rewritten")
 //!     .build()
@@ -65,8 +67,16 @@
 //! achieve some quite complex rewriting logic.
 //!
 //! ```rust
-//! # use lang_handler::rewrite::{Condition, Rewriter, PathCondition, PathRewriter};
-//!
+//! # use lang_handler::rewrite::{
+//! #   Condition,
+//! #   ConditionExt,
+//! #   HeaderCondition,
+//! #   PathCondition,
+//! #   Rewriter,
+//! #   RewriterExt,
+//! #   PathRewriter
+//! # };
+//! #
 //! let admin = {
 //!   let is_admin_path = PathCondition::new("^/admin")
 //!     .expect("regex is valid");

crates/lang_handler/src/rewrite/rewriter/closure.rs

@@ -1,33 +1,37 @@
-use super::{Request, Rewriter};
+use std::path::Path;
+
+use super::{Request, RequestBuilderException, Rewriter};
 
 impl<F> Rewriter for F
 where
-  F: Fn(Request) -> Request + Sync + Send,
+  F: Fn(Request, &Path) -> Result<Request, RequestBuilderException> + Sync + Send,
 {
   /// Rewrites the request by calling the Fn(&Request) with the given request
   ///
   /// # Examples
   ///
   /// ```
+  /// # use std::path::Path;
   /// # use lang_handler::{Request, rewrite::Rewriter};
-  /// let rewriter = |request: Request| {
+  /// # let docroot = std::env::temp_dir();
+  /// let rewriter = |request: Request, docroot: &Path| {
   ///   request.extend()
   ///     .url("http://example.com/foo/bar")
   ///     .build()
-  ///     .expect("should build new request")
   /// };
   ///
   /// let request = Request::builder()
   ///   .url("http://example.com/index.php")
   ///   .build()
   ///   .expect("request should build");
   ///
-  /// assert_eq!(
-  ///   rewriter.rewrite(request).url().path(),
-  ///   "/foo/bar".to_string()
-  /// );
+  /// let new_request = rewriter.rewrite(request, &docroot)
+  ///   .expect("rewriting should succeed");
+  ///
+  /// assert_eq!(new_request.url().path(), "/foo/bar".to_string());
   /// ```
-  fn rewrite(&self, request: Request) -> Request {
-    self(request)
+  fn rewrite(&self, request: Request, docroot: &Path)
+    -> Result<Request, RequestBuilderException> {
+    self(request, docroot)
   }
 }

crates/lang_handler/src/rewrite/rewriter/header.rs

@@ -1,6 +1,8 @@
+use std::path::Path;
+
 use regex::{Error, Regex};
 
-use super::{Request, Rewriter};
+use super::{Request, RequestBuilderException, Rewriter};
 
 /// Rewrite a request header using a given pattern and replacement.
 pub struct HeaderRewriter {
@@ -47,6 +49,7 @@ impl Rewriter for HeaderRewriter {
   /// ```
   /// # use lang_handler::rewrite::{Rewriter, HeaderRewriter};
   /// # use lang_handler::Request;
+  /// # let docroot = std::env::temp_dir();
   /// let rewriter = HeaderRewriter::new("TEST", "(foo)", "${1}bar")
   ///   .expect("should be valid regex");
   ///
@@ -56,25 +59,28 @@ impl Rewriter for HeaderRewriter {
   ///   .build()
   ///   .expect("should build request");
   ///
+  /// let new_request = rewriter.rewrite(request, &docroot)
+  ///   .expect("should rewrite request");
+  ///
   /// assert_eq!(
-  ///   rewriter.rewrite(request).headers().get("TEST"),
+  ///   new_request.headers().get("TEST"),
   ///   Some("foobar".to_string())
   /// );
   /// ```
-  fn rewrite(&self, request: Request) -> Request {
+  fn rewrite(&self, request: Request, _docroot: &Path)
+    -> Result<Request, RequestBuilderException> {
     let HeaderRewriter {
       name,
       pattern,
       replacement,
     } = self;
 
     match request.headers().get(name) {
-      None => request,
+      None => Ok(request),
       Some(value) => request
         .extend()
         .header(name, pattern.replace(&value, replacement.clone()))
-        .build()
-        .unwrap_or(request),
+        .build(),
     }
   }
 }

crates/lang_handler/src/rewrite/rewriter/mod.rs

@@ -1,21 +1,29 @@
+use std::path::Path;
+
 use crate::{
   rewrite::{Condition, ConditionalRewriter},
   Request,
+  RequestBuilderException,
 };
 
 mod closure;
 mod header;
+mod href;
+mod method;
 mod path;
 mod sequence;
 
 pub use header::HeaderRewriter;
+pub use href::HrefRewriter;
+pub use method::MethodRewriter;
 pub use path::PathRewriter;
 pub use sequence::RewriterSequence;
 
 /// A Rewriter simply applies its rewrite function to produce a possibly new
 /// request object.
 pub trait Rewriter: Sync + Send {
-  fn rewrite(&self, request: Request) -> Request;
+  fn rewrite(&self, request: Request, docroot: &Path)
+    -> Result<Request, RequestBuilderException>;
 }
 
 impl<T: ?Sized> RewriterExt for T where T: Rewriter {}
@@ -30,6 +38,7 @@ pub trait RewriterExt: Rewriter {
   /// #  Request,
   /// #  rewrite::{Rewriter, RewriterExt, PathCondition, PathRewriter}
   /// # };
+  /// # let docroot = std::env::temp_dir();
   /// let rewriter = PathRewriter::new("^(/index\\.php)$", "/foo$1")
   ///   .expect("should be valid regex");
   ///
@@ -43,10 +52,10 @@ pub trait RewriterExt: Rewriter {
   ///   .build()
   ///   .expect("should build request");
   ///
-  /// assert_eq!(
-  ///   conditional_rewriter.rewrite(request).url().path(),
-  ///   "/foo/index.php".to_string()
-  /// );
+  /// let new_request = conditional_rewriter.rewrite(request, &docroot)
+  ///   .expect("should rewrite request");
+  ///
+  /// assert_eq!(new_request.url().path(), "/foo/index.php".to_string());
   /// ```
   fn when<C>(self: Box<Self>, condition: Box<C>) -> Box<ConditionalRewriter<Self, C>>
   where
@@ -64,6 +73,7 @@ pub trait RewriterExt: Rewriter {
   /// #   Request,
   /// #   rewrite::{Rewriter, RewriterExt, PathRewriter, HeaderRewriter}
   /// # };
+  /// # let docroot = std::env::temp_dir();
   /// let first = PathRewriter::new("^(/index.php)$", "/foo$1")
   ///   .expect("should be valid regex");
   ///
@@ -78,10 +88,10 @@ pub trait RewriterExt: Rewriter {
   ///   .build()
   ///   .expect("should build request");
   ///
-  /// assert_eq!(
-  ///   sequence.rewrite(request).url().path(),
-  ///   "/foo/bar.php".to_string()
-  /// );
+  /// let new_request = sequence.rewrite(request, &docroot)
+  ///   .expect("should rewrite request");
+  ///
+  /// assert_eq!(new_request.url().path(), "/foo/bar.php".to_string());
   /// ```
   fn then<R>(self: Box<Self>, rewriter: Box<R>) -> Box<RewriterSequence<Self, R>>
   where

crates/lang_handler/src/rewrite/rewriter/path.rs

@@ -1,6 +1,8 @@
+use std::path::Path;
+
 use regex::{Error, Regex};
 
-use super::{Request, Rewriter};
+use super::{Request, RequestBuilderException, Rewriter};
 
 /// Rewrite a request path using a given pattern and replacement.
 pub struct PathRewriter {
@@ -42,6 +44,7 @@ impl Rewriter for PathRewriter {
   /// ```
   /// # use lang_handler::rewrite::{Rewriter, PathRewriter};
   /// # use lang_handler::Request;
+  /// # let docroot = std::env::temp_dir();
   /// let rewriter = PathRewriter::new("^(/foo)$", "/index.php")
   ///   .expect("should be valid regex");
   ///
@@ -50,23 +53,28 @@ impl Rewriter for PathRewriter {
   ///   .build()
   ///   .expect("should build request");
   ///
-  /// assert_eq!(
-  ///   rewriter.rewrite(request).url().path(),
-  ///   "/index.php".to_string()
-  /// );
+  /// let new_request = rewriter.rewrite(request, &docroot)
+  ///   .expect("should rewrite request");
+  ///
+  /// assert_eq!(new_request.url().path(), "/index.php".to_string());
   /// ```
-  fn rewrite(&self, request: Request) -> Request {
-    let url = request.url();
+  fn rewrite(&self, request: Request, _docroot: &Path)
+    -> Result<Request, RequestBuilderException> {
+    let PathRewriter { pattern, replacement, } = self;
 
-    let PathRewriter {
-      pattern,
-      replacement,
-    } = self;
-    let path = pattern.replace(url.path(), replacement.clone());
+    let input = request.url().path();
+    let output = pattern.replace(input, replacement.clone());
+
+    // No change, return original request
+    if input == output {
+      return Ok(request);
+    }
 
-    let mut copy = url.clone();
-    copy.set_path(path.as_ref());
+    let mut copy = request.url().clone();
+    copy.set_path(output.as_ref());
 
-    request.extend().url(copy).build().unwrap_or(request)
+    request.extend()
+      .url(copy)
+      .build()
   }
 }

crates/lang_handler/src/rewrite/rewriter/sequence.rs

@@ -1,4 +1,6 @@
-use super::{Request, Rewriter};
+use std::path::Path;
+
+use super::{Request, RequestBuilderException, Rewriter};
 
 // Tested via Rewriter::then(...) doc-test
 
@@ -23,8 +25,9 @@ where
   A: Rewriter + ?Sized,
   B: Rewriter + ?Sized,
 {
-  fn rewrite(&self, request: Request) -> Request {
-    let request = self.0.rewrite(request);
-    self.1.rewrite(request)
+  fn rewrite(&self, request: Request, docroot: &Path)
+    -> Result<Request, RequestBuilderException> {
+    let request = self.0.rewrite(request, docroot)?;
+    self.1.rewrite(request, docroot)
   }
 }

crates/php/src/embed.rs

@@ -189,7 +189,8 @@ impl Handler for Embed {
     // Apply request rewriting rules
     let mut request = request.clone();
     if let Some(rewriter) = &self.rewriter {
-      request = rewriter.rewrite(request)
+      request = rewriter.rewrite(request, &docroot)
+        .map_err(EmbedRequestError::RequestRewriteError)?;
     }
 
     // Initialize the SAPI module

crates/php/src/exception.rs

@@ -1,3 +1,5 @@
+use lang_handler::RequestBuilderException;
+
 /// Set of exceptions which may be produced by php::Embed
 #[derive(Debug, PartialEq, Eq, Hash)]
 pub enum EmbedStartError {
@@ -37,6 +39,7 @@ pub enum EmbedRequestError {
   FailedToDetermineContentType,
   FailedToSetServerVar(String),
   FailedToSetRequestInfo(String),
+  RequestRewriteError(RequestBuilderException),
 }
 
 impl std::fmt::Display for EmbedRequestError {
@@ -68,6 +71,9 @@ impl std::fmt::Display for EmbedRequestError {
       }
       EmbedRequestError::FailedToSetRequestInfo(name) => {
         write!(f, "Failed to set request info: \"{}\"", name)
+      },
+      EmbedRequestError::RequestRewriteError(e) => {
+        write!(f, "Request rewrite error: {}", e)
       }
     }
   }

crates/php/src/lib.rs

@@ -9,7 +9,18 @@ mod scopes;
 mod strings;
 mod test;
 
-pub use lang_handler::{rewrite, Handler, Header, Headers, Request, RequestBuilder, Response, Url};
+pub use lang_handler::{
+  rewrite,
+  Handler,
+  Header,
+  Headers,
+  Request,
+  RequestBuilder,
+  RequestBuilderException,
+  Response,
+  ResponseBuilder,
+  Url,
+};
 
 pub use embed::Embed;
 pub use exception::{EmbedRequestError, EmbedStartError};

crates/php_node/src/rewriter.rs

@@ -1,14 +1,26 @@
-use std::str::FromStr;
+use std::{path::Path, str::FromStr};
 
 // use napi::bindgen_prelude::*;
 use napi::{Error, Result};
 
 use php::{
   rewrite::{
-    Condition, ConditionExt, HeaderCondition, HeaderRewriter, PathCondition, PathRewriter,
-    Rewriter, RewriterExt,
+    Condition,
+    ConditionExt,
+    ExistenceCondition,
+    HeaderCondition,
+    MethodCondition,
+    NonExistenceCondition,
+    PathCondition,
+    HeaderRewriter,
+    HrefRewriter,
+    MethodRewriter,
+    PathRewriter,
+    Rewriter,
+    RewriterExt,
   },
   Request,
+  RequestBuilderException,
 };
 
 use crate::PhpRequest;
@@ -18,28 +30,38 @@ use crate::PhpRequest;
 //
 
 #[napi(object)]
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct PhpRewriteCondOptions {
   #[napi(js_name = "type")]
   pub cond_type: String,
-  pub args: Vec<String>,
+  pub args: Option<Vec<String>>,
 }
 
 pub enum PhpRewriteCond {
-  Path(String),
+  Exists,
   Header(String, String),
+  Method(String),
+  NotExists,
+  Path(String),
 }
 
 impl Condition for PhpRewriteCond {
-  fn matches(&self, request: &php::Request) -> bool {
+  fn matches(&self, request: &php::Request, docroot: &Path) -> bool {
     let condition: Box<dyn Condition> = match self {
-      PhpRewriteCond::Path(pattern) => PathCondition::new(pattern.as_str()).unwrap(),
+      PhpRewriteCond::Exists => Box::new(ExistenceCondition),
       PhpRewriteCond::Header(name, pattern) => {
         HeaderCondition::new(name.as_str(), pattern.as_str()).unwrap()
-      }
+      },
+      PhpRewriteCond::Method(pattern) => {
+        MethodCondition::new(pattern.as_str()).unwrap()
+      },
+      PhpRewriteCond::NotExists => Box::new(NonExistenceCondition),
+      PhpRewriteCond::Path(pattern) => {
+        PathCondition::new(pattern.as_str()).unwrap()
+      },
     };
 
-    condition.matches(request)
+    condition.matches(request, docroot)
   }
 }
 
@@ -49,23 +71,38 @@ impl TryFrom<&PhpRewriteCondOptions> for Box<PhpRewriteCond> {
   fn try_from(value: &PhpRewriteCondOptions) -> std::result::Result<Self, Self::Error> {
     let PhpRewriteCondOptions { cond_type, args } = value;
     let cond_type = cond_type.to_lowercase();
+    let args = args.to_owned().unwrap_or(vec![]);
     match cond_type.as_str() {
-      "path" => match args.len() {
-        1 => Ok(Box::new(PhpRewriteCond::Path(args[0].to_owned()))),
-        _ => Err(Error::from_reason("Wrong number of parameters")),
-      },
+      "exists" => if args.is_empty() {
+        Ok(Box::new(PhpRewriteCond::Exists))
+      } else {
+        Err(Error::from_reason("Wrong number of parameters"))
+      }
       "header" => match args.len() {
         2 => {
           let name = args[0].to_owned();
           let pattern = args[1].to_owned();
           Ok(Box::new(PhpRewriteCond::Header(name, pattern)))
         }
         _ => Err(Error::from_reason("Wrong number of parameters")),
-      },
+      }
+      "method" => match args.len() {
+        1 => Ok(Box::new(PhpRewriteCond::Method(args[0].to_owned()))),
+        _ => Err(Error::from_reason("Wrong number of parameters")),
+      }
+      "not_exists" | "not-exists" => if args.is_empty() {
+        Ok(Box::new(PhpRewriteCond::NotExists))
+      } else {
+        Err(Error::from_reason("Wrong number of parameters"))
+      }
+      "path" => match args.len() {
+        1 => Ok(Box::new(PhpRewriteCond::Path(args[0].to_owned()))),
+        _ => Err(Error::from_reason("Wrong number of parameters")),
+      }
       _ => Err(Error::from_reason(format!(
         "Unknown condition type: {}",
         cond_type
-      ))),
+      )))
     }
   }
 }
@@ -75,30 +112,39 @@ impl TryFrom<&PhpRewriteCondOptions> for Box<PhpRewriteCond> {
 //
 
 #[napi(object)]
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct PhpRewriterOptions {
   #[napi(js_name = "type")]
   pub rewriter_type: String,
   pub args: Vec<String>,
 }
 
 pub enum PhpRewriterType {
-  Path(String, String),
   Header(String, String, String),
+  Href(String, String),
+  Method(String, String),
+  Path(String, String),
 }
 
 impl Rewriter for PhpRewriterType {
-  fn rewrite(&self, request: Request) -> Request {
+  fn rewrite(&self, request: Request, docroot: &Path)
+    -> std::result::Result<Request, RequestBuilderException> {
     let rewriter: Box<dyn Rewriter> = match self {
       PhpRewriterType::Path(pattern, replacement) => {
         PathRewriter::new(pattern.as_str(), replacement.as_str()).unwrap()
       }
+      PhpRewriterType::Href(pattern, replacement) => {
+        HrefRewriter::new(pattern.as_str(), replacement.as_str()).unwrap()
+      }
+      PhpRewriterType::Method(pattern, replacement) => {
+        MethodRewriter::new(pattern.as_str(), replacement.as_str()).unwrap()
+      }
       PhpRewriterType::Header(name, pattern, replacement) => {
         HeaderRewriter::new(name.as_str(), pattern.as_str(), replacement.as_str()).unwrap()
       }
     };
 
-    rewriter.rewrite(request)
+    rewriter.rewrite(request, docroot)
   }
 }
 
@@ -112,14 +158,6 @@ impl TryFrom<&PhpRewriterOptions> for Box<PhpRewriterType> {
     } = value;
     let rewriter_type = rewriter_type.to_lowercase();
     match rewriter_type.as_str() {
-      "path" => match args.len() {
-        2 => {
-          let pattern = args[0].to_owned();
-          let replacement = args[1].to_owned();
-          Ok(Box::new(PhpRewriterType::Path(pattern, replacement)))
-        }
-        _ => Err(Error::from_reason("Wrong number of parameters")),
-      },
       "header" => match args.len() {
         3 => {
           let name = args[0].to_owned();
@@ -133,6 +171,30 @@ impl TryFrom<&PhpRewriterOptions> for Box<PhpRewriterType> {
         }
         _ => Err(Error::from_reason("Wrong number of parameters")),
       },
+      "href" => match args.len() {
+        2 => {
+          let pattern = args[0].to_owned();
+          let replacement = args[1].to_owned();
+          Ok(Box::new(PhpRewriterType::Href(pattern, replacement)))
+        }
+        _ => Err(Error::from_reason("Wrong number of parameters")),
+      },
+      "method" => match args.len() {
+        2 => {
+          let pattern = args[0].to_owned();
+          let replacement = args[1].to_owned();
+          Ok(Box::new(PhpRewriterType::Method(pattern, replacement)))
+        }
+        _ => Err(Error::from_reason("Wrong number of parameters")),
+      },
+      "path" => match args.len() {
+        2 => {
+          let pattern = args[0].to_owned();
+          let replacement = args[1].to_owned();
+          Ok(Box::new(PhpRewriterType::Path(pattern, replacement)))
+        }
+        _ => Err(Error::from_reason("Wrong number of parameters")),
+      },
       _ => Err(Error::from_reason(format!(
         "Unknown rewriter type: {}",
         rewriter_type
@@ -165,37 +227,34 @@ impl FromStr for OperationType {
 }
 
 #[napi(object)]
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct PhpConditionalRewriterOptions {
   pub operation: Option<String>,
-  pub conditions: Vec<PhpRewriteCondOptions>,
+  pub conditions: Option<Vec<PhpRewriteCondOptions>>,
   pub rewriters: Vec<PhpRewriterOptions>,
 }
 
 pub struct PhpConditionalRewriter(Box<dyn Rewriter>);
 
 impl Rewriter for PhpConditionalRewriter {
-  fn rewrite(&self, request: Request) -> Request {
-    self.0.rewrite(request)
+  fn rewrite(&self, request: Request, docroot: &Path)
+    -> std::result::Result<Request, RequestBuilderException> {
+    self.0.rewrite(request, docroot)
   }
 }
 
 impl TryFrom<&PhpConditionalRewriterOptions> for Box<PhpConditionalRewriter> {
   type Error = Error;
 
   fn try_from(value: &PhpConditionalRewriterOptions) -> std::result::Result<Self, Self::Error> {
-    let PhpConditionalRewriterOptions {
-      operation,
-      rewriters,
-      conditions,
-    } = value;
+    let value = value.clone();
 
-    let operation = operation
+    let operation = value.operation
       .clone()
       .unwrap_or("and".into())
       .parse::<OperationType>()?;
 
-    let rewriter = rewriters
+    let rewriter = value.rewriters
       .iter()
       .try_fold(None::<Box<dyn Rewriter>>, |state, next| {
         let converted: std::result::Result<Box<PhpRewriterType>, Error> = next.try_into();
@@ -208,7 +267,8 @@ impl TryFrom<&PhpConditionalRewriterOptions> for Box<PhpConditionalRewriter> {
         })
       })?;
 
-    let condition = conditions
+    let condition = value.conditions
+      .unwrap_or_default()
       .iter()
       .try_fold(None::<Box<dyn Condition>>, |state, next| {
         let converted: std::result::Result<Box<PhpRewriteCond>, Error> = next.try_into();
@@ -249,10 +309,16 @@ impl PhpRewriter {
   }
 
   #[napi]
-  pub fn rewrite(&self, request: &PhpRequest) -> Result<PhpRequest> {
+  pub fn rewrite(&self, request: &PhpRequest, docroot: String) -> Result<PhpRequest> {
     let rewriter = self.into_rewriter()?;
+    let docroot = Path::new(&docroot);
     Ok(PhpRequest {
-      request: rewriter.rewrite(request.request.to_owned()),
+      request: rewriter.rewrite(request.request.to_owned(), docroot).map_err(|err| {
+        Error::from_reason(format!(
+          "Failed to rewrite request: {}",
+          err.to_string()
+        ))
+      })?,
     })
   }
 

crates/php_node/src/runtime.rs

@@ -18,7 +18,7 @@ pub struct PhpOptions {
   /// Throw request errors
   pub throw_request_errors: Option<bool>,
   /// Request rewriter
-  pub rewrite: Option<Reference<PhpRewriter>>,
+  pub rewriter: Option<Reference<PhpRewriter>>,
 }
 
 /// A PHP instance.
@@ -62,7 +62,7 @@ impl PhpRuntime {
       docroot,
       argv,
       throw_request_errors,
-      rewrite,
+      rewriter,
     } = options.unwrap_or_default();
 
     let docroot = docroot
@@ -73,7 +73,7 @@ impl PhpRuntime {
       })
       .map_err(|_| Error::from_reason("Could not determine docroot"))?;
 
-    let rewriter = if let Some(found) = rewrite {
+    let rewriter = if let Some(found) = rewriter {
       Some(found.into_rewriter()?)
     } else {
       None

index.d.ts

@@ -49,15 +49,15 @@ export interface PhpResponseOptions {
 }
 export interface PhpRewriteCondOptions {
   type: string
-  args: Array<string>
+  args?: Array<string>
 }
 export interface PhpRewriterOptions {
   type: string
   args: Array<string>
 }
 export interface PhpConditionalRewriterOptions {
   operation?: string
-  conditions: Array<PhpRewriteCondOptions>
+  conditions?: Array<PhpRewriteCondOptions>
   rewriters: Array<PhpRewriterOptions>
 }
 /** Options for creating a new PHP instance. */
@@ -69,7 +69,7 @@ export interface PhpOptions {
   /** Throw request errors */
   throwRequestErrors?: boolean
   /** Request rewriter */
-  rewrite?: Rewriter
+  rewriter?: Rewriter
 }
 export type PhpHeaders = Headers
 /**
@@ -480,7 +480,7 @@ export declare class Response {
 export type PhpRewriter = Rewriter
 export declare class Rewriter {
   constructor(options: Array<PhpConditionalRewriterOptions>)
-  rewrite(request: Request): Request
+  rewrite(request: Request, docroot: string): Request
 }
 export type PhpRuntime = Php
 /**