Learn Angular, Next and Node

This course is perfect for those looking for a lightweight alternative to NgRx Store that scales effortlessly.

Angular is a development platform for creating applications using modern web standards. Angular includes a wealth of essential features such as mobile gestures, animations, filtering, routing, data binding, security, internationalization, and beautiful UI components. It's extremely modular, lightweight, and easy to learn.

Scalable Signals Angular Architecture with NGRX Signal Store

Dive into the world of real-time web development with this hands-on course! You’ll learn how to build a dynamic chat application using Fauna Streams and Next.js 14, focusing on the essentials and best practices.

**What You’ll Learn:**
- **Next.js Best Practices:** Master Next.js best practices for building fast, maintainable apps.
- **Server-Side Rendering (SSR):** Learn SSR techniques and master features like server actions, server side form submission etc.
- **Database Access Patterns:** Efficiently connect and retrieve data using Fauna.
- **Real-Time Updates:** Implement real-time updates with Fauna Streams.
- **Basic Authentication:** Secure your chat app with simple authentication methods.

**Course Highlights:**
- Practical, project-based learning.
- Clear, step-by-step instructions.
- Focus on modern, real-time web development.
- Tips and tricks for optimizing performance.

By the end of this course, you’ll have a working real-time chat app and a solid grasp of the tools and techniques used to build it.


Next.js is a minimalistic framework for server-rendered React applications.

Build a Real-time Next.js 14 Chat App with Fauna 

Our app is in a good stopping point. A good challenge for you to implement from here is to implement a navbar with a `logout` button.

Challenge: Implement a NavBar for the Application with Logout Functionality

Now that we have user Authentication, we can redirect users to sign in if we don't find a cookie to do so. 

Throughout our app we can now replace our fauna token we have set in environment variables to the user token that we have access to. 

Implement Auth Guards with Tokens throughout an Next.js App

React is one of the web’s most popular frameworks for building JavaScript applications. 

If you know what you’re doing, React can drastically simplify how you build, use, and maintain code.

Whether you’re a React newbie or you’re ready for advanced techniques, you can level-up with egghead. Explore our in-depth courses, lessons, and community resources to build more powerful applications and crack open your career.

react

For user signin, we'll implement a proper server action by creating a `actions.js` file where our server actions can live. In our login page, we'll set the component to be a client component to hold some state. This way we can use the new `useFormState` hook from `react-dom` and pass in our login server action.

Within the action we'll call our `UserLogin` function from Fauna and set a cookie with the secret we get back that we can use throughout our application.

Implement Fauna Signin with Next.js Server Actions and useFormState React Hook

Now it's time to actually sign users up for our appliaction.

We'll implement the `doSignup` function that we created earlier. This function will run on the server with the `'use server'` directive so we can instantiate a fauna client and call `UserRegistration` within this function.

From there we'll redirect the user to the `/signin` page which will error out because it's not implemented yet.

Implement Signup Functionality through Fauna with Next.js 14 Server Actions

To take advantage of Next.js app router, we need to separate our client components that need state from the rest of the page so we can load data on the server.

To do this we'll refactor the list of rooms into it's own `RoomList` component which will take the client-side React hooks with it. This way we can load all our rooms on the server and just pass it to `RoomList` which will start to stream the rooms as we create them.

The final step will be to turn the form for creating rooms into a server action. You'll notice that we will need to instantiate a new fauna client within the server action even though we have a client available in that same page. 

Refactor a Next.js 14 Page to Utilize Both Server and Client-side Rendering 

You'll notice that at the top level, we've set `'use client'` for our page. This means that everything on the page is a client component and we miss out on some benefits Next.js gives us by rendering on the server which includes a smaller bundle where sending to the client. 

We'll fix this in the next lesson.

Understand Server and Client Rendering and Data-fetching

FaunaDB is a global serverless database that gives you ubiquitous, low latency access to app data, without sacrificing data correctness. It eliminates layers of app code for manually handling data anomalies, security, and scale, creating a friendlier dev experience for you and better app experience for your users.

faunadb

To stream messages, we'll implement logic very similar to how we stream the creation of rooms from earlier.

First, we need to convert `MessageList` into a client component. We'll get an interesting error saying that only plain objects can be passed to client components from server components. This happens because the response we get back from Fauna is pretty complex. To fix this error we'll create a simple messages array and pass that down to the `MessageList` component.

In the `MessageList` component we'll create a `useEffect` that will initiate a Fauna stream within a ref and push new messages into state that we are holding in the component.

Stream Chat Messages in Real-time in Next.js from Fauna

Now it's time to actually create messages and display them in rooms within our application.

We'll start by creating a `MessageForm` component that will send a `Message.create` query to Fauna on form submission.

Next, we'll display these messages by updating our room query to also get all the messages for that room. You'll see that we can still just perform one query because we pass in the room id and call `Message.where(.room == room)` to the query.

One note here is if you console log your messages in your page component, you'll notice that the logs show up in the terminal and not the browser. This is because we are using a server component.

Create and Display Messages using Fauna within a Room in Next.js

With rooms being created and displayed on the index page, it's now time to create dynamic routes for each room so that when you click on a room name, you are actually navigated to that room.

We'll do this by using Next.js dynamic route syntax `/rooms/[...id]/page.js`. This will render a page on any `/rooms/:id` passing the component we define the `:id` as params.

Here we'll take that id and fetch the room data from fauna with a `Room.byId` query.

Create Dynamic Routes in Next.js for Chat Rooms

The first step to building a chat app is to have rooms to chat in. We'll need to create a Room collection (or table) in Fauna that we'll be adding to.

In our Next Application we'll create a simple form that has a submit handler that will create those rooms in Fauna. We need to hold some state in our component so we'll turn the page into a client component with `'use client'`.

There will be a little bit more Fauna set up to get things working. We need to create a key for our application to interact with our database so we'll create a key by running `Key.create` in our `fauna shell`. Then we'll install the `fauna` client and make a `client.query` to create the room.

Create a Fauna Room Collection in Next.js with the fauna Client

The first step is to install and configure our database that will be backing our Next.js application. We'll be using Fauna so we head over to the Fauna website and create a database.

Back in our terminal we will install `fauna-shell` so we can interact and manage our database from within our project. After some initializing steps from the CLI we'll be set up to build the app out.

Initialize and Configure a Fauna Database inside a Next.js project with fauna-shell

We'll start off by creating our project with `npx create-next-app`. This is a standard install so we'll select some of the options the CLI offers us.

Next, you'll notice that I'm running into some errors importing packages. This is because we need to update our eslint config so we'll edit `.babelrc` and `.eslintrc` to get those errors to go away.

Set up a Next 14 Project with create-next-app

In this lesson, you'll learn about the `path` configuration for Keystatic collections and singletons. It gives you a lot of flexibility over where your content should be stored on your file system.

Define where Keystatic should store your content

angular

Using Angular's `toSignal` function with the HTTP client enables components to reactively fetch and display data from external services. 

This approach simplifies code and handles undefined initial values, but note that `toSignal` immediately subscribes and makes the HTTP request when used. So, keep in mind if you're using it in a component or some root level service.

Fetch Data via HTTP Using RxJS Observables and toSignal

The `toSignal` function in Angular enables the conversion of an RxJS observable into a signal. 

It allows you to wrap an observable and handle the initial value of the resulting signal. You can explicitly define the initial value, require a synchronous emission from the observable, and more! 

Turn an RxJS Observable Into an Angular Signal With toSignal

Angular's `toObservable` function enables converting signals to RxJS observables. This allows creating observable properties that stay synchronized with signal values. 

Whenever the signal value changes, the corresponding observable emits a notification, facilitating the interoperability between signals and observables.

Turn an Angular Signal Into an RxJS Observable

In Angular, effects are often assigned to class properties during the constructor phase. However, there may be cases where the effect needs to be parameterized with values from parent components, which are not available during construction.

When running effects outside the constructor, such as in the `ngOnInit` lifecycle hook, you need to manually provide the `injector` instance to the `effect` configuration.

Bind an Angular Signal Effect to an Injector for Automatic Cleanup

Angular provides a `manualCleanup` configuration option for effects, preventing automatic cleanup when the owner component/service is destroyed. 

With `manualCleanup: true`, you gain control but must manually call `.destroy()` on the `EffectRef` that is returned by your `effect` to release resources like intervals or subscriptions. 

Remember, with great power comes great responsibility!

Destroy an Angular Signal Effect Automatically or Manually

Sometimes you will need to properly clean up your effects to prevent memory leaks. Like if you use timeouts or intervals. 

Implement cleanup logic using the `onCleanup` callback. In your effect you can call `onCleanup`, pass it a callback, and define actions like clearing intervals or unsubscribing from observables when effects are no longer needed. 

Set up an Angular Signal Effect Cleanup Handler



Discover how to harness the power of Cursor IDE's Composer Agent feature to optimize your code. In this lesson, you'll witness an AI agent doing all the work to generate test suites, implement performance benchmarks, and create optimized function variations - all without writing a single line of code. You'll learn how to validate performance improvements through data-driven benchmarking, ensuring that optimizations are backed by concrete metrics rather than speculation. This hands-on demonstration showcases a groundbreaking approach to automated function development that combines the precision of test-driven development with the efficiency of AI-powered optimization.


Agent-Driven Development in Cursor: Testing, Benchmarking, and Optimizing Functions

This course is aimed for using `zod` effectively in projects based on TypeScript (both browser and node.js). The benefits you gain with this course is not just simply coding, but also understanding when/why/how should you perform runtime validation.

`zod` is the missing piece to TypeScript's capabilities, which can guarantee type-safety only in compile-time.

`zod` can be used whenever the compiler cannot guarantee what happens in runtime. And... it's a very frequent usecase, such as HTTP calls, websockets, etc.

In this course you get quickly up and running by:
1. using `zod` with primitives and objects
2. adapting `zod` quickly to existing projects thanks to automatic generators
3. changing the strategy frm type-first to schema-first
4. using error-throwing `parse` or non-error-throwing `safeParse` basing on your needs
5. applying `zod` to the most common usecase - validating API responses
6. handling errors the most convenient way (out of many!)

Take advantage of runtime validation with `zod`. Take advantage of the detailed lessons in this course 🔥

Effective Runtime Type Checks with Zod


Cursor can now automatically run commands in the terminal and walk step-by-step towards building out your entire project. You give it a goal, then it will suggest the commands you need to run and the files that you need to create and you can work with it to achieve what you're building. This lesson does a quick walkthough of using a Cursor Agent to build a project from scratch and guide it along the way. Cursor Agents definitely feel like a sneak peek at the future of programming!

Cursor Agents Initial Impressions - Allow an AI to Build Your Entire Project

Mock Service Worker is an API mocking library that allows you to write client-agnostic mocks and reuse them across any frameworks, tools, and environments.



Mocking WebSocket APIs with Mock Service Worker


While using anonymous functions might seem convenient, they can create difficulties when trying to identify performance bottlenecks during profiling. This lesson will demonstrate how named functions make it easier to pinpoint and address performance issues, ultimately leading to more efficient and debuggable code. Learning this practice will greatly improve your ability to locate and fix performance issues in complex projects.

Always Name Functions in JavaScript


When attempting to load the same module twice in JavaScript you'll hit a cache and code won't re-run. In scenarios where you actually do want to have state in your modules, you'll have to use a cache-busting technique by passing a query parameter to a dynamic import. This lesson walks through how to add a query parameter, how to add the appropriate types for loading dynamic modules in TypeScript, and when these techniques are valuable.

Import the Same JavaScript Module Multiple Times with Cache Busting



The include keyword in GitHub Actions empowers you to add custom variables to your matrix strategy, providing flexibility beyond standard configurations. In this video, we'll explore how include allows you to define specific combinations of variables, enhancing control over your workflow runs. You'll see how this feature enables you to tailor jobs for unique environments or scenarios not covered by the default matrix options. By leveraging include, you can efficiently manage complex build processes with greater precision. This technique helps you streamline your CI/CD pipeline, making it more adaptable to your project's evolving needs.

Use GitHub Actions Matrix Include for Complex Job Configurations

While running `zod` schema validation agains domain-rich objects, the error message saying that _a string is not a number_ might not be really useful.

Especially, when you need to provide a meaningful feeback to the user, e.g. after they have submitted a form with lots of data.

`zod` allows to customize messages on a very granular level. We can also extract repeatable customization to `zod` error maps.

Finally, in order to process an error message further (e.g. display it to the user), we need to handle the `zod` validation errors effectively. Especially, when a big object validation has failed and we could receive a handful of errors.

That's what we learn in this lesson. 🔥

Customize zod Error Messages and Handle zod Errors Effectively

customize zod validation messages, customize zod schema property messages, reuse error maps across different schemas, navigate through zod error objects

You might want to run `zod` schema checks in different styles.

Sometimes you prefer to conditionally throw the error - that's what `parse` does. But another time you'd prefer to receive a `boolean` property that determines whether the validation was successful or not - and perform further actions accordingly.

Additionally, the error-throwing API of `parse` works extremely well with [TypeScript assertion functions](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#assertion-functions). Their combination is just... perfect! 👌

That's what we learn in this lesson.

Use parse and safeParse Runtime Type-checks with zod

use zod parse function to conditionally throw ZodError, use zod safeParse to get a boolean value and run typescript type guard over success property

In this lesson we learn that TypeScript cannot guarantee correct shapes of responses. That's due to TS performing checks in compile-time, while the response will be availbale in runtime - when TS doesn't exist anymore.

In some situations, such as HTTP requests, runtime type checks such as `zod` are essential for providing quick feedback around data-related errors.

Understand where are the possible mistakes to make while using TypeScript with HTTP calls. Use `fetch` and `axios` along with `zod` schema checks.

Also, note that similar mistakes or mistakes could happen while using web storage (e.g. `localStorage`)

Validate HTTP API Response with zod, fetch and axios

use zod as an HTTP response validation tool along with fetch and axios in order to make sure that the response has expected data structure

Search

Search Results