

AdonisJS
AdonisJS 5 is a NodeJS framework that's comes packed with everything you'll need to quickly build scalable and secure applications or APIs.
AdonisJS Sub-Topics
AdonisJS Series
AdonisJS 5 Infinite Load
In this two-part mini-series, we'll be creating an infinite load functionality within our AdonisJS 5 application. We'll make use of a Model Factory & Seeder to make dummy data. We'll then use our Model's paginate method to easily track our progress


AdonisJS Bouncer
In this series, we'll be introducing and covering AdonisJS Bouncer, AdonisJS' first-party authorization package.


AdonisJS in 15
In this series, we'll highlight various features in AdonisJS you can complete in about 15 minutes or less.


AdonisJS + InertiaJS
In this series, we'll learn how to integrate, configure and use InertiaJS within an AdonisJS project. In this series, we'll be using Vue 3 as our client-side framework. We'll look at things like authentication, form submissions, redirects, and more.


AdonisJS Quick Tip
Quick tips, lessons, and screencasts covering specific topics on AdonisJS.


AdonisJS User Roles
In this series, we'll walk through the process of creating your own user role management system. In this system we'll be able to manage users, their roles, permissions, access to our application and more.


HTMX & AdonisJS Filters
In this mini-series, we'll learn how to install HTMX within an AdonisJS project. Once installed, we'll implement a basic filtering system with AdonisJS and initiate form handlers with HTMX to update our DOM.


Let's Build A Changelog App
We'll be building a changelog application with AdonisJS through a series of livestreams.


Let's Build with AdonisJS
Livestreams where we build applications using AdonisJS 5. Starting out, we'll be rebuilding Adocasts, formerly called Jagr.Co.


Let's Learn AdonisJS 5
Learn AdonisJS 5 in-depth as we step through all the major functionalities of the framework in-depth. Learn about Routing, Controllers, Lucid, Auth, and much more.
Recently Released on AdonisJS

How To Create An AdonisJS 5 & Inertia 1 Project with SSR
In this lesson, we’ll take a look at how to set up AdonisJS 5 and InertiaJS V1 using server-side rendering (SSR).

How To Use AdonisJS Model Hooks To Log All User Actions
In this lesson, we’ll be taking a look at how we can log any and every user action performed against our AdonisJS models.

AdonisJS 5 API & Nuxt 3 SSR Authentication in 15 Minutes
In this lesson, we’ll learn how to set up authentication in an AdonisJS API application while using server-side rendered (SSR) Nuxt 3 as our front end.

Gracefully Checking and Handling An Expired Auth Session
In this lesson, we’ll take a look at how to gracefully reset the user’s stale session, which includes authentication, CSRF tokens, or anything else you may have set for the user.

Updating Our URL & Populating Filter Field Values
In this lesson, we'll learn how we can use HTMX to easily update our URL via our AdonisJS response. Then, we'll use our URL's query string to pre-populate our filter form field values.

Posting & Swapping Filtered Content with HTMX
In this lesson, we'll utilize the filter form handler we defined in our last lesson by adding an HTMX post handler to our filter form that will retrieve the filtered results HTML and swap it with the pre-existing results.

Defining Our AdonisJS Filter Form Handler
In this lesson, we'll expand on the filter query we built in the last lesson by reusing the query within a service for our filter form handler.

Creating Our Filter Query with AdonisJS
In this lesson, we'll create the route and query we'll need to get filtered results with our filter form using the Lucid ORM and AdonisJS.

Installing HTMX & Project Overview
In this lesson, we'll briefly outline the project structure and then install HTMX inside our project.

Exploring My Favorite AdonisJS Model Query Builder Macros: Tips and Examples
In this lesson, I'll highlight a few of my favorite Model Query Builder Macros that I carry with me from project to project. Have a favorite of your own? Let me know in the comments!

Easy Querying with Static Model Query Methods
In this lesson, we'll learn what static methods are available on our Lucid Models to help us easily query records from our database. These methods offer a convenient query option compared to the query builder.

How To Seamlessly Share AdonisJS Sessions & Authentication Across Subdomains
In this lesson, we'll learn how one simple tweak to our AdonisJS project allows us to seamlessly share sessions and user authentication across multiple subdomains, as well as our application's primary domain.

Password Hashing & Model Hook Overview
In this lesson, we'll learn briefly about the model hooks available and how they work. Then, we'll walk through an example by hashing our password anytime it is changed.

Creating Records with Lucid ORM
In this lesson, we'll learn various ways we can create and bulk-create records using the AdonisJS Lucid ORM.

Defining Model Relationships
In this lesson, we'll learn how to define relationships on our Lucid Models. We'll cover one-to-one, many-to-one, one-to-many, and many-to-many relationship definitions.

Team / User Management
In this stream, we'll add the ability for admins to invite others to their team. They'll be able to either invite them as a member or another admin.

Remember Me in AdonisJS Authentication
In this lesson, we'll take a look at how to remember the user's authentication session in AdonisJS Auth. We'll learn how to define the remember me checkbox within our form and more.

Creating Teams & Setting Default Team
In this stream, we'll be adding the ability to create new teams, set the default team for a user when they switch between teams, and auto-forward users to their default team after login.

Database Migrations To Lucid Models
In this lesson, we'll walk through examples of transferring our database migrations into our Lucid Models. This will pave the way for us to begin CRUD operations in later lessons.

Database Schema to Migration
In this lesson, we'll walk through a real-world example of a database schema and how to create migrations. We'll define each table's columns, primary keys, and foreign keys.

What Is A Model?
In this lesson, we'll delve into AdonisJS Models learning what they are, what they represent, how to create them, what we can do with them, and more.

How To Redirect Back to the Previous Page After Login with AdonisJS
In this lesson, we'll learn an easy way we can redirect our user's back to their original page after they login or register in an AdonisJS application.

Creating A Default Team After Sign Up
In this stream, we'll create a default team for users after signing up for our changelog application. After signing up, we'll take the user to a screen where they can update details on their default team.

Minify Your AdonisJS HTML in 5 Minutes
We'll learn how we can alter all our AdonisJS HTML response bodies using a simple global middleware to add HTML minification.

Simple Steps To Require Email Verification In Your AdonisJS App
Learn how to require your users to verify their email address using a Token model with AdonisJS and Lucid ORM.

Creating Our AdonisJS Project & Getting Setup
In this stream, we'll start building a changelog application with AdonisJS

How To Create Your Own Global Helpers in AdonisJS
In this lesson, we'll learn how we can create our own globally available helper methods & properties in AdonisJS.

How To Create A Password Reset Flow in NodeJS with AdonisJS
In this lesson, we'll cover, from start to finish, how to create your own password reset (or forgot password) flow in your NodeJS application with AdonisJS.

What To Know Before Altering Your Database with Migrations
In this lesson, we'll discuss two different flows you can use to alter your database. One, when working completely locally and another when a migration has already been executed on your production database.

AdonisJS User Role Management
In this lesson, we'll learn how to create a user management screen that'll allow administrators to change any of our registered user's roles

AdonisJS User Role Authentication in 15 Minutes
In this lesson, we'll learn how we can specify user roles using a User and Role AdonisJS Model within our project.

The Middleware Mountain
In this lesson, we'll learn about the two different types of middleware, global middleware and registered middleware. We'll also take a deep dive into how they play into the flow of an AdonisJS Request.

Recreating YouTube's Chapters Functionality
In this stream, we'll be working to recreate YouTube's chapter functionality on Adocasts.

Migrations & Understanding the Flow of Migrations
In this lesson, we'll learn all about migrations, what they are, how they're used, and how they're tracked. We'll also learn about the flow of migrations and how they work similarly to a timeline.

Altering Adocasts' Lesson 404 Page Behavior
In this stream, we'll alter our soon-to-be-published lessons to display a "Coming Soon" notice when visited instead of the current 404 page.

Create a NodeJS PDF Generator that Sends the PDF as an Email Attachment with AdonisJS & Puppeteer
In this lesson, we'll be creating an application that creates a PDF from a styled page using AdonisJS, EdgeJS, and Puppeteer. Then, we'll learn how we can send this PDF as an email attachment.

Form Validation Error Handling
In this lesson, we'll see just how nice InertiaJS is when it comes to form validation error handling. As you'll see, little work needs to be done on our part.

How To Use Vue 3 with TypeScript in an AdonisJS Project
In this lesson, we’ll learn how to set up a Vue 3 TypeScript application within our AdonisJS project using Webpack Encore. We’ll start by getting Vue 3 working, then sprinkle in TypeScript support.

Introducing InertiaJS Forms & The InertiaJS Form Helper
In this lesson, we'll learn about InertiaJS and how it differs when it comes to forms. We'll see how it helps simplify response handling and treats forms as a hybrid between APIs and a Monolith. We'll also learn about Inertia's form helper.

Simplifying Imports with Path Aliases & Global Components
In this lesson, we'll learn how to add a path alias with Webpack Encore to eliminate relative paths from our client-side imports. We'll also learn how to register global Vue 3 components.

Http Method Spoofing & Helper Components in AdonisJS
In this lesson, we'll learn how we can utilize Http Method Spoofing to send PUT, PATCH, and DELETE requests using native HTML forms. We'll then create utility functions to make the implementation cleaner.

Introducing, Installing, and Configuring Lucid ORM
In this lesson, we'll learn about Lucid ORM; its capabilities, Ace CLI commands, and the difference between it and the Database module. We'll then install and configure it within our project.

How To Do Multi Model Authentication with AdonisJS and Lucid ORM
In this lesson, we'll learn how to set up multi-model authentication using a User and Admin model with AdonisJS and Lucid ORM.

Naive UI and Vue 3 Component Import on Demand
In this lesson, we'll be installing Naive UI, a Vue 3 component library, to our Inertia and Vue 3 application. Then, we'll set up Import on Demand so components will auto-resolve as we use them.

Adding TailwindCSS to our Adonis, Inertia, Vue Application
In this lesson, we'll learn how to add TailwindCSS to an Adonis, Inertia, and Vue 3 application using Webpack Encore.

The AdonisJS InertiaJS Adapter Now Supports Vue Server-Side Rendering (SSR)
The AdonisJS Adapter by Lev Eidelman Nagar for InertiaJS now supports server-side rendering (SSR) for both Vue 2 and Vue 3.

Creating Layouts and Defining Default Layouts
In this lesson, we'll learn how to create and define layouts within our AdonisJS and InertiaJS app. We'll also learn how we can easily add support for default layouts as well.

Understanding The Flow Between Adonis, Inertia, and Vue 3
In this lesson, we'll be inspecting the request flow from Adonis through Inertia and to Vue for both initial and subsequent requests.

How To Make A Simple AdonisJS Package
Learn about AdonisJS' MRM Preset and how we can use it to easily make an AdonisJS package. In particular, we'll be building a Honeypot package that defines a provider, middleware, global component, and types.

How To Add InertiaJS to a New AdonisJS Project
In this lesson, we'll create a new AdonisJS project, then install and configure InertiaJS with Vue 3 using the InertiaJS-AdonisJS adapter.

How To Make Your AdonisJS Authentication Login Case-Insensitive
Learn how to make the AdonisJS login attempt query case-insensitive easily by adding a simple method to our User Model.

Comment Likes & Unlikes
In this stream, we'll be adding the ability to like and unlike a comment on the new upcoming Jagr.Co site, built with AdonisJS.

Working A Bit with AdonisJS Social Auth
In this stream, we worked on fixing an issue I have on the new, not yet released, Jagr site where I didn't account for changing emails within my social auth.

Building An XML Sitemap
In this stream, we'll be going over how to build a sitemap of all our site's pages for search engines using XML to help bolster SEO.

How To Add A Custom Method to the Model Query Builder in AdonisJS
In this lesson, we'll learn how to define a macro for the Model Query Builder within an AdonisJS project to provide a new method onto all our Model's Query Builder.

Service Providers & The IoC Container
We'll learn about Service Providers and how they interact with the IoC Container. We'll then put this to practice by wrapping a NodeJS package so it's easy to use within AdonisJS

Building A Comment System
In this stream, we focused on building a comment system that allowed infinitely nestable responses. It's all done server-side too, so it's SEO friendly!

Static, Non-Static, & Singleton Services
We'll learn what services are. We'll then discuss three different ways we can use them within our AdonisJS application, including static, non-static, and singleton services.

How To Serialize All AdonisJS Lucid Model Properties As Camel Case
In this lesson, we'll learn how to use Naming Strategies in AdonisJS to alter the serialization behavior for all our model properties from snake case to camel case.

How To Add TailwindCSS to a New AdonisJS Project
This lesson covers creating a new AdonisJS project that includes Webpack Encore, then adding and configuring PostCSS and TailwindCSS within the project.

Creating & Using Bouncer Policies
We'll learn about policies and how we can use them to group resource-based actions. We'll also learn how to create and share hooks with policies.

Implementing Authorization Actions
We'll take what we learned about AdonisJS Bouncer actions in the last lesson to finalize the needed authorization checks for our blog application.

Bouncer Actions & Authorizations
We'll learn about AdonisJS Bouncer actions and how we can use these actions to check if a user is authorized to perform a specific task. Plus, conditional check authorizations.

Introducing, Installing, & Configuring Bouncer
In this lesson, we'll introduce AdonisJS Bouncer, the first-party AdonisJS package for authorization checking. We'll also get a start project setup and install and configure Bouncer.

AdonisJS Authentication in 15 Minutes
We'll be creating a new AdonisJS project and adding authentication to it within 15 minutes. You'll be able to logout, register, and login with either your username or email.

How To Add AdonisJS Edge Support to your WebStorm Environment
A quick tip on how to add AdonisJS Edge syntax highlighting to your JetBrains WebStorm environment using the VSCode plugin and TextMate Bundles.

Route & Controller Resources
In this lesson, we'll learn what a resource is and how we can quickly and easily define a route resource and handle each resourceful route with a resource controller.

Rebuilding Jagr.Co, Adding Posts & SubCollections to Collections
In this stream, we focus on adding the ability to add posts and subcollections to a collection.

Rebuilding Jagr.Co, Post, Collection, & Taxonomy Models
In this stream, we focus on setting up the models and migrations for the Collection and Taxonomy models and tables. We set up their relationships and get the Collection CRUD operations setup

Rebuilding Jagr.Co, Social Auth & Image Management
In this stream, we work on finishing up social authentication using AdonisJS Ally. Then, we'll add project and permission settings and image uploading to Digital Ocean Spaces.

Debugging, Inspecting, and Freezing Code Execution
In this lesson, we cover a couple of ways to debug your AdonisJS application using the Edge inspect global function, the debugger keyword, and the Chromium NodeJS Devtools.

Rebuilding Jagr.Co, Password Reset & Account Locking
In this livestream, we'll add a system to lock users' accounts after so many bad login attempts and we'll also add in the password reset flow.

Handling Routes with Controllers
In this lesson, we'll learn about Controllers and how we can keep our route definitions clean and easy to scan by extracting our route handlers into these Controllers.

Rebuilding Jagr.Co, Username Sign In & Post CRUD
In this livestream we cover adding the ability to sign in using either a username or email address. We also dig into setting up the ability to create, read, update, and delete our posts.

Getting Data by the User's Timezone with Luxon's DateTime
In this lesson, we'll learn how we can use the user's current time zone to create, update, or query time-sensitive information in AdonisJS using Luxon's DateTime object.

Rebuilding Jagr.Co, Start & Auth
In this livestream we create a new project, install and configure the Lucid and Auth packages. Define our migrations and model schema. And hammer down basic authentication.

How To Add A Global Property To Your HttpContext in AdonisJS 5
In this lesson, we'll be covering how we can extend our HttpContext with a new property that we'll populate using a route parameter.

Extending the Adonis Router and Route Matchers
In this lesson, we'll be learning how we can add our own chainable methods using macros to the Adonis Router's Route, Route Group, Route Resource, Brisk Route, and Matchers properties.

Generating URLs and Signed URLs
In this lesson, we'll be focusing specifically on generating URLs from our route definitions. We'll cover generating generic URLs, signed URLs, redirect URLs, and more.

Multi-File Route Grouping Strategies
In this lesson, we'll discuss strategies you can use to apply multiple files worth of route definitions into a single route group without redefining the route group in each file.

Naming, Grouping, & Prefixing Routes
In this lesson, we'll learn about naming routes and using groups with prefixes to structure our routes and reduce redundancies.

Moving & Organizing Routes
In this lesson, we'll cover various different ways you can structure your routes within your Adonis project, including moving the routes.ts file, and using a module approach

Dynamic Routing with Route Parameters
In this lesson, we go in-depth with route parameters covering optional route params, validation using matchers, casting, wildcards, and a few things to watch out for.

Routing Introduction
We'll learn how to define routes in Adonis using the Route module. We'll cover defining routes for specific HTTP Methods (like GET, POST, PUT/PATCH, and DELETE), Caveats, and Brisk Routes.

Understanding the HttpContext
The HttpContext object contains unique information about individual requests our application receives. In this lesson, we'll cover what it is, how it's passed, and how we can mutate it.

Introducing the Ace CLI
In this lesson, we'll be learning about Adonis' command-line interface (CLI). Including what the Ace CLI is, its options, how it'll be expanded, and how we can create custom commands

How To Create An Infinite Loader
In this lesson, we'll be going over how to add an infinite loader to our app. We'll specifically be utilizing an Edge component and our Model's paginate method to make this happen.

Project Setup & Creating Dummy Data
In this lesson, we'll be setting up our project with fake data using a Model Factory and a Seeder. We'll also set up our initial list of posts so that we're all set and squared away to cover

Project Structure
In this lesson, we'll get familiar with our Adonis 5 project by running through all the folders and files and their purposes. We'll learn which folders and files within our project structure

Prerequisites & Creating A New Project
In this lesson, we'll learn about AdonisJS 5; what it is, what it offers, its prerequisites, and how to create a new project. We'll then start our project up to ensure everything is working.

Let's Learn Adonis 5: Introducing The Edge Template Engine
In this lesson, we learn the basics of the Edge Templating Engine, which allows us to dynamically inject our server-side data into our HTML views.

Let's Learn Adonis 5: Validating Requests
In this lesson, we focus on Adonis' built-in Validator. We'll learn how to define a validation schema, custom messages, custom rules, and more

Let's Learn Adonis 5: Writing Reusable Queries with Query Scopes
In this lesson, we'll learn how we can extract repetitive query builder statements into reusable query scopes as a way to keep our codebase easy to maintain.

Let's Learn Adonis 5: Querying, Checking Existence, and Aggregating Relationships
In this lesson we'll learn how to query relationships, determine if a relationship exists, and how to aggregate relationship data.

Let's Learn Adonis 5: The Query Builder
In this lesson we'll be focusing specifically on the query builder. We'll discuss how we can filter down data, order, limit, and aggregate our data.

Let's Learn Adonis 5: Creating Data & Relationships Records
In this lesson, we learn about conditional inserts and how to reach through to relationships to create relationships and related records.

Let's Learn Adonis 5: Intro to Creating, Reading, Updating, and Deleting (CRUD)
In this lesson, we'll learn the two different modules Adonis' Lucid provides us to communicate with our database. We'll then introduce basic CRUD operations using these modules.

Let's Learn Adonis 5: Defining Model Relationships
In this lesson, we'll learn about the different types of database relationships, how Adonis supports these relationship types, and how to define these relationships.

Let's Learn Adonis 5: Intro to Models
This lesson is all about models. We'll learn what they are, how to define them, what they're used for, and some of the extended capabilities they provide.

Let's Learn Adonis 5: Altering Tables with Migrations
In this lesson, we'll expand on migrations a bit further by discussing how to alter existing databases using migrations.

Let's Learn Adonis 5: Migrations
This lesson is all about migrations. We'll discuss what they are, how to use them, and how they're integrated within Adonis. Then we'll put them to use.

Let's Learn Adonis 5: Installing and Configuring Lucid
In this lesson, we'll be learning how to install and configure Lucid, Adonis' Object-Relational Mapping (ORM) system, within our application.

Let's Learn Adonis 5: Controllers, Services, Resources, and Namespacing
In this lesson, we'll be hammering down several Adonis topics in one swoop. We'll be covering Controllers, which in turn allow us to utilize Services, Resources, and Namespacing.

Let's Learn Adonis 5: Routes and Route Handling
In this lesson, we learn the basics of Adonis routing and route handling by covering how to define a route, render a page, respond with JSON, simplify our route definitions, and more.

Let's Learn Adonis 5: Project Structure and the Ace CLI
We'll learn our way around Adonis' project structure and gain an understanding of what goes where. We'll also discuss Adonis' Ace CLI.

Let's Learn Adonis 5: Prerequisites & Creating A New Project
We'll be learning a little about what Adonis is, the prerequisites to get started, and how to create a new project.