Learn Apollo, Chai and Graphql

GraphQL is a query language for APIs and a runtime for fulfilling those queries with your existing data. GraphQL provides a complete and understandable description of the data in your API, gives clients the power to ask for exactly what they need and nothing more, makes it easier to evolve APIs over time, and enables powerful developer tools.

graphql

When your application communicates with multiple GraphQL services, it becomes problematic to distinguish them by operation type and name alone. Learn how to take the service's endpoint into account when intercepting GraphQL queries and mutations with Mock Service Worker.

- [`graphql.link()`](https://mswjs.io/docs/api/graphql#graphqllinkurl)

Endpoint-Based GraphQL Mocking in MSW

Let's improve our schema-first GraphQL mocks by intercepting _all_ GraphQL operations—both queries and mutations—using a single Mock Service Worker `graphql.operation()` request handler. 

- [`graphql.operation()`](https://mswjs.io/docs/api/graphql#graphloperationresolver)

Mock All GraphQL Operations in MSW

Operation-based GraphQL mocking allows you to move fast without investing time into schemas or resolvers. 

But, when integrating Mock Service Worker into an existing application, going schema-first can be advantageous. Here's how you can route every GraphQL request to be resolved against a GraphQL schema, mocked or real, and use mock resolvers to control individual types and fields. 

Resolve GraphQL Requests Against a Mock Schema in MSW

Error responses in GraphQL are a bit unique. They must still produce a "200 OK" response and list the errors in the response body instead. Let's follow the GraphQL specification to produce a valid GraphQL error response in our Mock Service Worker handlers. 

Mock GraphQL Errors in MSW

In this lesson, you will use the Mock Service Worker `graphql.mutation()` request handler to allow the users to leave reviews for the movie they've watched. 

- [`graphql` namespace](http://mswjs.io/docs/api/graphql)

Intercept and Mock GraphQL Mutations in MSW

Let's spice things up by adding GraphQL to our application. 

Since you are prototyping mock-first, you don't have to write any GraphQL schemas or define any resolvers. Instead, you will utilize Mock Service Worker to intercept valid GraphQL queries by their _type_ and _name_, and respond with the same semantic JSON responses matching the queries.

- [Describing GraphQL APIs](http://mswjs.io/docs/network-behavior/graphql)

Intercept and Mock GraphQL Queries in MSW

JavaScript® (often shortened to JS) is a lightweight, interpreted, object-oriented language with first-class functions, most known as the scripting language for Web pages, but used in many non-browser environments as well such as node.js or Apache CouchDB. It is a prototype-based, multi-paradigm scripting language that is dynamic, and supports object-oriented, imperative, and functional programming styles.

javascript

Hi! My name is [Artem](https://kettanaito.com). In this course, I will teach you how to mock REST and GraphQL APIs with [Mock Service Worker](https://mswjs.io). Together, we will build a movie streaming application and you will learn how to intercept both server-side and client-side requests and mock responses using standard JavaScript API. This is a state-of-the-art mock-first prototyping with MSW.

- Join my [Discord server](https://kettanaito.com/discord) to go through the course with others, ask questions, and share feedback. See you there!

Introduction to Mock REST and GraphQL APIs with Mock Service Worker

Controlling the network is the key to fast prototyping, bullet-proof tests, and efficient debugging. 

Mocking the APIs you use gives you this kind of control but most methods in the client and server come up short. 

That's where Mock Service Worker does it right.

With it you can intercept and take control of requests no matter where they're being made.

In this course, you will learn how to:

* setup and your first request handler 
* mock complex flows like authentication
* describe dynamic requests
* respond with HTTP streams,
* and use schema-first GraphQL mocking

After this course you'll be more than ready to bring MSW into your app and start mocking any kind of API you're using!

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. 

Controlling the network is the key to fast prototyping, bullet-proof tests, and efficient debugging. Mocking the APIs you use gives you this kind of control.

Mock REST and GraphQL APIs with Mock Service Worker

Apollo provides a universal GraphQL API on top of your existing services, so you can build new application features fast without waiting on backend changes.

apollo

We will implement the delete shop in our Nextjs application. When the user selects the delete button for a shop in the shop's list, it will execute the `DeleteShopAndProducts` mutation and delete the shop and all associated products. 

Implement Delete Shop Mutation with Apollo Client in Nextjs

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

When a vendor manages their shops, they might want to click into the shop and mange the products associated with that shop. Let's create a page for that.

I'll create a details route that will host this information. On this page we will write a `GetShop` query that will take in the shop id that is pulled from the route. Similar to the shops page, we will iterate over the products on the shop and add buttons to manage individual products.

Create Shop Details View that uses GraphQL to Query Fauna by Shop Id

Each shop will need to have products added to it by the vendor. To do this we'll need to dynamically create pages based on which shop we want to add to. Next.js has dynamically routing that we will utilize here. We'll set the shop id as the dynamic portion of the route and display a new product form. 

Here we will create that product form component and use Apollo `useMutation` like we did before to take in the form data. You'll notice a new keyword in our mutation query `connect` which we can use because we have a `@relation` set between products and shop. This connect will associate the product to the shop through the id that we grab from the route.

Create Dynamic Next.js Shop Page to Add Products for a Shop with Apollo useMutation

It would be great to show a list of shops that a vendor has created. To do this we will need to create a new query `getShopsByOwnerId` that accepts a string that will be our user id. Like before, we'll merge this schema change into Fauna and update our roles to make this request.

On the frontend we'll create a shop list component and pass in the user token that Auth0 gives us for the logged in user.

Query Data by Property with GraphQL and Fauna in Next.js

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

To make an authenticated request, we will need to get logged in users auth tokens from Auth0. Auth0 exposes a `getAccessToken` function that we can use in Next.js `getServerSideProps` to fetch the user token. It's important to note that this function can only be used server side. We'll pass that token into the page we need to send authed requests.

To enable Apollo Client to set the headers we'll extend the client so that allows us to pass in auth tokens and sets the client context. We will then destructure the client from our `useMutation` hook and set the context to include the user token.

Set Dynamic Auth Header for Apollo Client using Next.js getServerSideProps

We are ready to create new shops for our vendors. To do this we'll define a `CreateShop` mutation that will take in all the data that our form provides. Then `useMutation` will accept that mutation and give us a function to pass our data into as well as give us the new created shop data. We'll pass in user information that we get from Auth0. 

This lesson finishes up with an error because Fauna doesn't know if the request came from an authenticated user or not. We'll solve this with dynamic headers in the next lesson.

Create New Shop with Apollo Client useMutation

Fauna is a flexible database so we can update our schema without breaking any existing functionality. You'll notice that our products all have hard coded images. In this lesson, we'll update our `Product` to include an image and import those changes to Fauna.

Update the Product GraphQL Data Model and Upload Changes to Fauna

Now that Apollo Client is set up and ready to be used, we can finally query data from Fauna to use in our application. 

We'll go to the Fauna GraphiQL playground and copy the `findShopById` query that we ran previously. This query will be passed into Apollo's `useQuery` hook.

Query Data with GraphQL in Next.js from a Fauna Database

To build out our Shop products page on the frontend we will need data coming in from the database. To do that we need to connect Fauna to Next.js. We'll do this through Apollo Client because it will give us a lot right out of the box.

To connect our database we'll configure Apollo Client with `httpLink` and `authLink`. On the Fauna side of things we'll create a role and key for Read permissions (just Read for now) and grab the graphql endpoint to supply as environment variables for Next.js.

Connect a Frontend Next.js Application to a Serverless Fauna Database with Apollo Client

With our GraphQL schema in hand, we can create a full-fledged Fauna database. We'll import our GraphQL schema into a newly created database and explore the mutations and queries that were generated for us by creating and searching for a shop.

Upload a GraphQL Schema to Create a FaunaDB Database and Create a Shop

The next step is to model the data that we are going to use for our application, we'll have a Shop and Product. Shops will 'have many' Products. 

You'll see how to type this in a GraphQL schema with the different properties we want on Shop and Product. Additionally we will be introduced to the faunadb `@relation` directive which is similar to a foreign key constraint. 

[Read more about the @relation directive in the docs.](https://docs.fauna.com/fauna/current/api/graphql/directives/d_relation)

```typescript
# schema.graphql
type Shop {
  name: String!
  description: String!
  coverImg: String!
  products: [Product]!
  ownerID: String!
}

type Product {
  name: String!
  description: String!
  price: Float!
  category: String!
  shop: Shop! @relation
}
```

Model our Application Data with a GraphQL Schema


Next.js is one of the most popular server-side-rendered React frameworks you can use to build production-ready serverless applications in record time. 

On the other hand, Fauna is a flexible, serverless, distributed document-relational database. Fauna has a powerful GraphQL API and custom resolver support. 

Using Next.js and Fauna, you can build robust, feature-rich, production-ready full-stack applications without the hassle of managing any servers or databases.

In this course, Shadid guides you through building your very own full-stack serverless marketplace application using Next.js, GraphQL, and Fauna. 

You will learn,

- How to work with Apollo GraphQL Client in Next.js
- How to setup Fauna GraphQL
- Data modeling in Fauna
- How to write custom Fauna GraphQL Resolvers (UDFs)
- How to authenticate with Auth0?
- Stripe payment 



Full-Stack Serverless Applications with Next.js & Fauna

In this course, Colby is going to do a deep dive into creating a full store for your products. You'll learn how to set up and use GraphCMS as your content management system. You'll learn about the Cloudinary UI extension and how to use it to host your images. You'll learn about Snipcart and using the useSnipcart hook to handle the cart state and the checkout. You'll learn how to implement Stripe as your payment gateway. And lastly, you'll learn how to deploy a Next js app to vercel from github with environment variables.

snipcart

Ecommerce Product Management & Storefront with GraphCMS, Snipcart, & Next.js

In this lesson, you'll discover how to style View Transitions using CSS pseudo-selectors to create custom animation effects. We'll transform the default cross-fade into a smooth slide transition by targeting the ::view-transition-old and ::view-transition-new pseudo-elements. You'll learn how these powerful selectors give you precise control over your transition animations, allowing you to create more engaging and personalized user experiences with just a few lines of CSS.

Customize View Transitions with CSS Using view-transition-old and view-transition-new

In this lesson, you'll learn how to implement smooth state transitions in your web applications using the browser's built-in View Transitions API. We'll create a simple example that demonstrates how to animate between different text states with just a few lines of code - no external libraries required. This powerful native API makes it easy to add professional-looking transitions to your user interface, enhancing the user experience with minimal effort.

Create Smooth UI Transitions with the Native View Transitions API

I've been using Cursor for a very long time and their "Agent" feature in Composer is fairly new, so I'm still getting used to it. But since Windsurf recently got onto the stage with their Cascade agent, they've slowly been gaining the mind share on the UX for coding agents. I decided to put them to the test by putting Windsurf and Cursor on the exact same screen side by side trying to accomplish the same task and to see which workflow I would prefer. I've been a diehard Cursor user for over a year now, so it's going to take a lot for me to switch to a different IDE. But I just have to say, even from this simple demo, Windsurf is looking pretty nice.

This lesson is just going to walk through creating a CLI using both tools to print out inspirational quotes and to explore how they approach the step-by-step of installing packages and running commands and setting up all the files we need to get this running.

Windsurf Cascade vs. Cursor Composer Agent Side-by-Side Comparison

This TypeScript tutorial explains how to use generics, allowing for different types to be passed as arguments. It discusses the use of shorthand syntax in generics and illustrates with examples. This method is useful for library creation, providing type safety and control to the user.

```typescript
interface PhotoMetadata<T> {
  title: string;
  takenAt: Date;
  customData: T;
}

// Function that processes a photo with custom metadata
function processPhoto<T>(photo: PhotoMetadata<T>): {
  processedTitle: string;
  daysSinceCapture: number;
  customDataSummary: T;
} {
  const today = new Date();
  const daysSinceCapture = Math.floor(
    (today.getTime() - photo.takenAt.getTime()) / (1000 * 60 * 60 * 24)
  );

  return {
    processedTitle: photo.title.toUpperCase(),
    daysSinceCapture,
    customDataSummary: photo.customData
  };
}

// Example usage with different custom data shapes
type CameraSettings = {
  iso: number;
  aperture: string;
  shutterSpeed: string;
}

type LocationData = {
  latitude: number;
  longitude: number;
  locationName: string;
}

// Using with camera settings
const photoWithCamera: PhotoMetadata<CameraSettings> = {
  title: "Sunset at beach",
  takenAt: new Date('2024-01-15'),
  customData: {
    iso: 100,
    aperture: "f/2.8",
    shutterSpeed: "1/1000"
  }
};

// Using with location data
const photoWithLocation: PhotoMetadata<LocationData> = {
  title: "Mountain vista",
  takenAt: new Date('2024-02-01'),
  customData: {
    latitude: 45.5231,
    longitude: -122.6765,
    locationName: "Mount Hood"
  }
};

const processedCameraPhoto = processPhoto(photoWithCamera);
const processedLocationPhoto = processPhoto(photoWithLocation);

processedCameraPhoto.customDataSummary.iso
processedLocationPhoto.customDataSummary.longitude

```

Basic Explanation of Typescript Generics

A very basic explanation of generic function arguments

I've been using Cursor as my primary editor for over a year now, but recently I've heard wonderful things about Windsurf AI Agent features. I decided to record myself building out something I've always wanted to make, but never made the time for.

In this lesson, I demonstrate how to leverage Windsurf's powerful agent process to create a fun word-guessing game inspired by Heads Up. Watch as I build an interactive application featuring category selection and word navigation, complete with data hosting on GitHub Gists and deployment to GitHub Pages - all in under 30 minutes (before editing the lesson down to 12 minutes)!

What makes this project particularly exciting is how Windsurf eliminates the typical friction points of development. While this game was always on my project wishlist, the overhead of setup, configuration, and deployment made it hard to justify the time investment. Windsurf's agent process handles all these pain points seamlessly, from managing URLs to orchestrating deployment.

This lesson perfectly showcases how AI agents can help developers bring their backlog of project ideas to life, transforming what would typically be time-consuming tasks into efficient, enjoyable development experiences.

Build a Word Game with Windsurf's Cascade AI Agent



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