The talk covers essential aspects of building robust Node.js applications, emphasizing test-driven development, avoiding global state, and modularizing business logic. It highlights the benefits of using Fastify over Express for routing efficiency and metaprogramming, and suggests using the Fastify plugin system for modularization and graceful shutdowns. The talk also discusses the importance of using the right test frameworks, recommending alternatives like Vtest and Node-tap instead of Jest for Node.js servers. For SQL database interactions, libraries like AT Database and NearForm SQL are recommended. The talk provides insights into handling JWT authentication in microservices by verifying tokens at the edge and passing relevant information through HTTP headers. It also introduces Platformatic, a tool built on Fastify, for quick setup and automatic API generation.
From Author:
Have you ever struggled with designing and structuring your Node.js applications? Building applications that are well organised, testable and extendable is not always easy. It can often turn out to be a lot more complicated than you expect it to be. In this live event Matteo will show you how he builds Node.js applications from scratch. You’ll learn how he approaches application design, and the philosophies that he applies to create modular, maintainable and effective applications.
Level: intermediate
This workshop has been presented at Node Congress 2023, check out the latest edition of this Tech Conference.
FAQ
The instructor is a board member on the OpenJS Foundation and a part of the Nojest Tech steering committee with over 10 years of experience deploying Node.js systems.
The three key things covered are: test-driven development, avoiding global state, and splitting business logic across multiple modules.
Jest is primarily designed for browser environments and can cause issues with Node.js servers, such as problems with instances of errors and global state. Alternatives like Vtest, Node-tap, and the built-in Node test library are recommended.
The recommended structure involves organizing the application into modules or features based on domains rather than using a traditional Model-View-Controller (MVC) pattern. This helps in managing complexity and scalability.
Fastify uses a Radix prefix tree for routing, which is more efficient and supports metaprogramming on routes, unlike Express which uses an array of regular expressions evaluated in order.
Yes, Fastify can be used in serverless environments, and it works better than Express in AWS Lambda due to its efficient design and lower cold start times.
The Fastify plugin system allows modularization of the application, making it easier to manage, test, and extend functionalities. It also supports graceful shutdowns by managing dependencies and their order of initialization and termination.
Platformatic is a production-ready framework built on top of Fastify. It provides additional features like automatic API generation, environment variable substitution, and a more streamlined setup, while still supporting all Fastify functionalities.
You can handle authentication by verifying the JWT token at the edge (initial request) and then passing relevant information through HTTP headers to avoid redundant validations in internal microservices.
Recommended libraries include 'AT Database', 'NearForm SQL', and 'Kinet'. These libraries allow you to write raw SQL queries while ensuring SQL injection protection.
Platformatic allows you to rapidly develop GraphQL and REST APIs with minimal effort. The best part is that it also allows you to unleash the full potential of Node.js and Fastify whenever you need to. You can fully customise a Platformatic application by writing your own additional features and plugins. In the workshop, we’ll cover both our Open Source modules and our Cloud offering:- Platformatic OSS (open-source software) — Tools and libraries for rapidly building robust applications with Node.js (https://oss.platformatic.dev/).- Platformatic Cloud (currently in beta) — Our hosting platform that includes features such as preview apps, built-in metrics and integration with your Git flow (https://platformatic.dev/). In this workshop you'll learn how to develop APIs with Fastify and deploy them to the Platformatic Cloud.
Deno 1.9 introduced a new web server API that takes advantage of Hyper, a fast and correct HTTP implementation for Rust. Using this API instead of the std/http implementation increases performance and provides support for HTTP2. In this workshop, learn how to create a web server utilizing Hyper under the hood and boost the performance for your web apps.
Passwordless authentication may seem complex, but it is simple to add it to any app using the right tool. We will enhance a full-stack JS application (Node.JS backend + React frontend) to authenticate users with OAuth (social login) and One Time Passwords (email), including:- User authentication - Managing user interactions, returning session / refresh JWTs- Session management and validation - Storing the session for subsequent client requests, validating / refreshing sessions At the end of the workshop, we will also touch on another approach to code authentication using frontend Descope Flows (drag-and-drop workflows), while keeping only session validation in the backend. With this, we will also show how easy it is to enable biometrics and other passwordless authentication methods. Table of contents- A quick intro to core authentication concepts- Coding- Why passwordless matters Prerequisites- IDE for your choice- Node 18 or higher
How to build a fullstack GraphQL application (Postgres + NestJs + React) in the shortest time possible. All beginnings are hard. Even harder than choosing the technology is often developing a suitable architecture. Especially when it comes to GraphQL. In this workshop, you will get a variety of best practices that you would normally have to work through over a number of projects - all in just three hours. If you've always wanted to participate in a hackathon to get something up and running in the shortest amount of time - then take an active part in this workshop, and participate in the thought processes of the trainer.
Node.js test runner is modern, fast, and doesn't require additional libraries, but understanding and using it well can be tricky. You will learn how to use Node.js test runner to its full potential. We'll show you how it compares to other tools, how to set it up, and how to run your tests effectively. During the workshop, we'll do exercises to help you get comfortable with filtering, using native assertions, running tests in parallel, using CLI, and more. We'll also talk about working with TypeScript, making custom reports, and code coverage.
We’ll go through setting up Sentry step--step to get visibility into our frontend and backend. Once integrated, we will track and triage errors + transactions surfaced Sentry from our services to understand why/where/how errors and slowdowns occurred within our application code.
The talk discusses the importance of supply chain security in the open source ecosystem, highlighting the risks of relying on open source code without proper code review. It explores the trend of supply chain attacks and the need for a new approach to detect and block malicious dependencies. The talk also introduces Socket, a tool that assesses the security of packages and provides automation and analysis to protect against malware and supply chain attacks. It emphasizes the need to prioritize security in software development and offers insights into potential solutions such as realms and Deno's command line flags.
There is a need for a standard library of APIs for JavaScript runtimes, as there are currently multiple ways to perform fundamental tasks like base64 encoding. JavaScript runtimes have historically lacked a standard library, causing friction and difficulty for developers. The idea of a small core has both benefits and drawbacks, with some runtimes abusing it to limit innovation. There is a misalignment between Node and web browsers in terms of functionality and API standards. The proposal is to involve browser developers in conversations about API standardization and to create a common standard library for JavaScript runtimes.
ESM Loaders enhance module loading in Node.js by resolving URLs and reading files from the disk. Module loaders can override modules and change how they are found. Enhancing the loading phase involves loading directly from HTTP and loading TypeScript code without building it. The loader in the module URL handles URL resolution and uses fetch to fetch the source code. Loaders can be chained together to load from different sources, transform source code, and resolve URLs differently. The future of module loading enhancements is promising and simple to use.
This talk covers various techniques for getting diagnostics information out of Node.js, including debugging with environment variables, handling warnings and deprecations, tracing uncaught exceptions and process exit, using the v8 inspector and dev tools, and generating diagnostic reports. The speaker also mentions areas for improvement in Node.js diagnostics and provides resources for learning and contributing. Additionally, the responsibilities of the Technical Steering Committee in the TS community are discussed.
Deno aims to provide Node.js compatibility to make migration smoother and easier. While Deno can run apps and libraries offered for Node.js, not all are supported yet. There are trade-offs to consider, such as incompatible APIs and a less ideal developer experience. Deno is working on improving compatibility and the transition process. Efforts include porting Node.js modules, exploring a superset approach, and transparent package installation from npm.
Today's Talk is about logging with Pino, one of the fastest loggers for Node.js. Pino's speed and performance are achieved by avoiding expensive logging and optimizing event loop processing. It offers advanced features like async mode and distributed logging. The use of Worker Threads and Threadstream allows for efficient data processing. Pino.Transport enables log processing in a worker thread with various options for log destinations. The Talk concludes with a demonstration of logging output and an invitation to reach out for job opportunities.
JSNation 2023
Comments