About LiteNode

Overview

LiteNode is a lightweight and modular Node.js web framework designed to provide essential web server functionalities with a clean and intuitive API. It leverages modern JavaScript features while ensuring compatibility with both CommonJS and ES6 modules, making it versatile for various development environments. LiteNode is suitable for developers seeking a straightforward yet powerful solution for building web applications.

Key Features

1. Routing: LiteNode offers a robust routing system that allows defining routes with different HTTP methods (GET, POST, PUT, DELETE, PATCH). It supports parameterized routes, optional parameters, wildcard routes, and nested routing, providing flexibility in organizing route handlers.

2. Enhanced Route Matching: LiteNode supports versatile route matching patterns:

   • Optional Parameters: Routes like /users/:id? that can match both /users and /users/123
   • Single Segment Wildcard: Using wildcard() method or /* syntax to match a single path segment
   • Multi-Segment Wildcard: Using catchAll() method or /** syntax to match multiple path segments
   • Any HTTP Method: The any() method to register a route for all HTTP methods at once

3. Middleware: The framework supports middleware functions, enabling developers to execute code, make changes to the request and response objects, end the request-response cycle, and call the next middleware in the stack.

4. Cookie Management: A comprehensive cookie management system with:

   • Cookie Parsing: Automatic parsing of incoming cookies via enableCookieParser()
   • Setting Cookies: Simple API for setting cookies with various options
   • Signed Cookies: Secure cookie signing and verification with createSignedCookies()
   • Cookie Options: Support for all standard cookie attributes (Max-Age, Expires, Path, Domain, Secure, HttpOnly, SameSite)

5. Error Handling: LiteNode includes comprehensive error handling capabilities, allowing custom error handlers to be defined. This ensures that errors are managed gracefully and that appropriate responses are sent to the client.

6. Request Body Parsing: The framework includes built-in support for parsing request bodies, simplifying the handling of POST requests. It supports application/json, application/x-www-form-urlencoded and multipart/form-data content types, ensuring that data is correctly parsed and accessible.

7. Static Asset Serving: LiteNode can serve static files from a specified directory, making it easy to deliver images, CSS files, JavaScript files, and other assets to clients, without server restart.

8. Extensibility: LiteNode supports nesting routers (nest method) and merging routes from other routers (merge method). This allows for modularizing route handling and reusing code.

9. Server Initialization: The framework provides a simple and efficient way to start the server with customizable options such as port configuration.

10. Utility Methods: LiteNode includes utility methods like printTree, which helps visualize the routing structure, aiding in debugging and understanding the application's routing hierarchy. It also provides several utility methods to simplify response handling and routing management. The txt method allows for easy sending of plain text responses by setting the Content-Type header to text/plain and sending the provided text as the response body. This complements other response methods such as json, status, sendFile, html, xml, and render, making it straightforward to return various types of content to the client.

11. Parameters (params and queryParams): The framework supports route parameters and query parameters, making it easy to capture dynamic values from URLs and query strings.

12. Redirect: The redirect method allows for easy redirection of requests to different URLs, with support for specifying HTTP status codes for temporary or permanent redirects.

13. .json: The json method simplifies sending JSON responses by setting the appropriate headers and stringifying the data.

14. .status: The status method allows setting HTTP status codes before sending a response, supporting method chaining for cleaner code.

15. .sendFile: The sendFile method facilitates sending files as responses, setting the appropriate Content-Type headers based on file extensions.

16. .txt: The txt method enhances the versatility of the response object, allowing developers to easily send plain text responses without manually setting headers and ending the response. This contributes to cleaner and more readable code.

17. .html: By setting the Content-Type header to text/html and delivering the provided HTML content as the response body, this method ensures that HTML content is correctly handled and returned to the client, enabling users to employ another template engine with LiteNode than its integrated Simple Template Engine.

18. .xml: The xml method is a useful addition to the response object, simplifying the process of sending XML responses. This method is particularly useful for API endpoints or responses where XML is the desired format, such as RSS feeds and sitemaps.

19. Templating: LiteNode features an integrated, powerful AST-based template engine, called STE (Simple Template Engine), for rendering HTML files. It supports placeholders, dynamic data injection, and includes directives for modular and reusable templates. Additionally, STE provides the ability to render templates to files, making it easy to generate static HTML files for various use cases such as static site generation.

20. Markdown: LiteNode enhances the parsing and rendering of Markdown files, a feature inherited from Blog-Doc CMS & SSG. It includes methods for parsing individual Markdown files, parsing multiple Markdown files from a directory, and extracting specific properties from the frontmatter. This makes LiteNode a powerful and flexible tool for managing content-rich applications, offering robust capabilities for handling Markdown files efficiently.

21. Environment Variables: LiteNode provides built-in support for environment variables through .env files, allowing you to manage configuration without external dependencies.

Working with Cookies

LiteNode provides a comprehensive cookie management system:

// Enable cookie parsing middleware
app.enableCookieParser();

// Set a cookie
app.get('/set-cookie', (req, res) => {
  res.setCookie('username', 'john_doe', {
    maxAge: 3600,         // 1 hour
    httpOnly: true,       // Not accessible via JavaScript
    path: '/',            // Available across the site
    sameSite: 'Strict'    // CSRF protection
  });
  res.txt('Cookie set!');
});

// Read cookies
app.get('/get-cookie', (req, res) => {
  const username = req.cookies.username;
  res.json({ username });
});

// Working with signed cookies for enhanced security
app.get('/secure-cookies', (req, res) => {
  const signedCookies = app.createSignedCookies('your-strong-secret-key');

  // Set a signed cookie
  await signedCookies.setCookie(res, 'userId', '12345', { httpOnly: true });

  // In another route, verify the signed cookie
  const userId = await signedCookies.getCookie(req, 'userId');
  // userId will be null if tampered with
});

Advanced Routing Examples

Wildcard Routes

LiteNode supports single-segment and multi-segment wildcard routes:

// Single segment wildcard - matches /files/image.jpg but not /files/subfolder/image.jpg
app.wildcard("/files", (req, res) => {
    const filename = req.params["*"]
    res.txt(`Viewing file: ${filename}`)
})

// Multi-segment wildcard - matches any path under /api, including nested paths
app.catchAll("/api", (req, res) => {
    const path = req.params["**"]
    res.json({ message: `API path: ${path}` })
})

Any HTTP Method

Register a route handler for all HTTP methods at once:

// This will respond to GET, POST, PUT, DELETE, etc.
app.any("/health", (req, res) => {
    res.json({
        status: "healthy",
        method: req.method,
    })
})

Optional Parameters

Define routes with optional parameters:

// Matches both /users and /users/123
app.get("/users/:id?", (req, res) => {
    if (req.params.id) {
        res.json({ message: `User details for ID: ${req.params.id}` })
    } else {
        res.json({ message: "List of all users" })
    }
})

Strengths

• Lightweight and Fast: LiteNode is designed to be lightweight, ensuring quick response times and efficient handling of requests.
• Modular Design: The framework's modularity allows for easy customization and extension, enabling developers to add or modify functionalities as needed.
• Modern JavaScript Support: LiteNode leverages ES6 features, making the codebase clean and modern while maintaining compatibility with CommonJS.
• Comprehensive Built-in Features: The framework includes essential web server features out of the box, reducing the need for additional dependencies and simplifying development.
• Security-Focused: Features like signed cookies and proper HTTP headers show a strong emphasis on security best practices.

Use Cases

• Small to Medium Web Applications: LiteNode is ideal for building small to medium-sized web applications where simplicity and performance are key.
• APIs and Microservices: The framework's lightweight nature and robust routing capabilities make it suitable for developing APIs and microservices.
• Static Websites: With its static asset serving capabilities, LiteNode can be used to build and serve static websites efficiently.
• Prototyping and MVPs: LiteNode's ease of use and minimal setup requirements make it an excellent choice for prototyping and building Minimum Viable Products (MVPs).
• Content-Rich Applications: The Markdown handling features make LiteNode particularly suitable for blogs, documentation sites, and content management systems.

Conclusion

LiteNode is a versatile and efficient web framework for Node.js, offering a range of features that cater to modern web development needs. Its lightweight design, coupled with powerful routing, middleware, and templating capabilities, makes it an excellent choice for developers seeking a balance between simplicity and functionality. Whether building small web applications, APIs, or static websites, LiteNode provides a solid foundation for rapid development and deployment.

Origins

LiteNode routing system is built on the foundation of Velocy.
LiteNode extends and improves upon Velocy's features to provide a seamless development experience for building web applications. You can read more about it in LiteNode, Node.js Web Framework.

License

LiteNode is licensed under the MIT License. See the LICENSE file for details.

Issues

If you encounter any issues or have suggestions for improvement, please report them on the GitHub Issues page.

Contributing

Contributions are welcome! Feel free to fork the repository and submit pull requests with your enhancements.

Author

LiteNode is authored by LebCit.