Routes and URI

Stratox Pilot is a JavaScript router designed for ease of use and flexibility. It employs regular expressions to offer dynamic routing, allowing for both straightforward and complex navigation paths.

Stratox Pilot can be used as a standalone library. As a universal library, it works across different platforms without needing any external dependencies. This independence makes Stratox Pilot a practical option for developers in search of a dependable routing tool that combines advanced features and modular design in a compact package.

You can find the router file at: src/routes/app.js

A Really Basic Example

// Possible path: #about
router.get('/about', function({ http, services, helper, context }) {
});

You can, of course, add multiple paths:

// Possible path: #about/contact
router.get('/about/contact', function({ http }) {
});

Using Regular Expressions

To incorporate regular expressions in routing patterns, enclose the expression within curly brackets: {PATTERN}. This syntax allows for flexible and powerful URL matching based on specified patterns.

// Possible path: #about/location/stockholm
router.get('/about/location/{[a-z]+}', function({ http }) {
});

Binding Router Patterns to a Key

It is strongly advised to associate each URI path you wish to access with a specific key. This approach enhances the clarity and manageability of your route definitions.

// Possible path: #about/location/stockholm
router.get('/{page:about}/location/{city:[^/]+}', function({ http }) {
    // http.vars.page[0] is expected to be "about"
    // http.vars.city[0] is expected to be any string value (stockholm, denmark, new-york) from passed URI.
});

You can also map an entire path to a key, allowing for more concise and organized route management.

// Possible path: #about/contact
router.get('/{page:about/location}', function({ http }) {
    // http.vars.page[0] is expected to be "about"
    // http.vars.page[1] is expected to be "location"
});

Combining Pattern with Keywords

Combining patterns with keywords (e.g., post-[0-9]+) enables you to create more expressive and versatile route definitions.

// Possible path: #articles/post-824/hello-world
router.get('/articles/{id:post-[0-9]+}/{slug:[^/]+}', function({ http }) {
    // http.vars.id[0] is expected to be "post-824"
    // http.vars.slug[0] is expected to be "hello-world"
});

Handling Unlimited Nested Paths

To accommodate an unlimited number of nested paths within your routing configuration, you can utilize the pattern .+. However, it's strongly advised to precede such a router pattern with a specific prefix to maintain clarity and structure, as demonstrated in the example below with the prefix /shop.

// Example of accessing a single category: #shop/furniture
// Example of accessing multiple nested categories: #shop/furniture/sofas/chesterfield
router.get('/shop/{category:.+}', function({ http }) {
    // Retrieves the last category segment from the path
    const category = http.vars.category.pop();
    console.log(`The current category is: ${category}`);
});

This approach allows for the dynamic handling of deeply nested routes under a common parent path, offering flexibility in how URLs are structured and processed.

Optional URI Paths

To define one or more optional URI paths, enclose the path segment (excluding the slash) in brackets followed by a question mark, for example: /(PATH_NAME)?. This syntax allows for flexibility in route matching by making certain path segments non-mandatory.

// Possible path: #articles
// Possible path: #articles/post-824/hello-world
router.get('/articles/({id:post-[0-9]+})?/({slug:[^/]+})?', function(http) {
});

It's important to note that you should not enclose the leading slash in brackets. The leading slash is automatically excluded from the pattern, ensuring the correct interpretation of the route.

Catch Status Errors

There is an optional and special router pattern that lets you catch HTTP status errors within a router.

router.get('[STATUS_ERROR]', function({ http, services, helper, context }) {
    if (http.status === 404) {
        console.log("404 Page not found", http.status);
    } else {
        console.log("405 Method not allowed", http.status);
    }
});

This route can be used to handle specific error codes, such as 404 Not Found or 405 Method Not Allowed, providing a better user experience.