Learn Chai, Cloudflare and Cloudinary

cloudinary

We'll learn how to integrate Cloudinary into our Strapi application so that we can upload image assets in our Strapi dashboard and the resulting image will be stored in Cloudinary and ready for use in our application.

We'll create a `config/plugins.js` file and paste in some config code that sets Cloudinary as the provider with `cloud_name`, `api_key`, and `api_secret`.

Then we'll install the Cloudinary provider plugin with `npm install @strapi/provider-upload-cloudinary`, add the middleware security that lets us use Cloudinary, and finally add Cloudinary credentials to our `.env` file.

Install and Add the Cloudinary Provider to a Strapi Application

Cloudflare secures and ensures the reliability of your external-facing resources such as websites, APIs, and applications. It protects your internal resources such as behind-the-firewall applications, teams, and devices. And it is your platform for developing globally-scalable applications.

cloudflare

Supabase Function Hooks allow us to subscribe to change events in the database - such as `insert`, `update` and `delete` - and make a HTTP request with the changed data.

In this lesson, we refactor our `revalidate` route to handle inserts, updates and deletes.

Additionally, we create a Function Hook to subscribe to all change events on the `articles` table, and automatically send a POST request to the `revalidate` route of our Cloudflare Worker.

This automatically refreshes the KV store anytime a value is changed in the database, and decouples the revalidation of our cache, from our user requesting data. This means, theoretically, users should never have to wait for a request to the Supabase origin server, as the cache is automatically populated, updated and cleared to remain in sync with the database.

## Code Snippets

**Update Revalidate route to handle insert, update and delete**

```javascript
router.post(
  "/revalidate",
  withContent,
  async (request, { SUPABASE_URL, SUPABASE_ANON_KEY, ARTICLES }) => {
    const { type, record, old_record } = request.content;
    const supabase = createClient(SUPABASE_URL, SUPABASE_ANON_KEY);

    if (type === "INSERT" || type === "UPDATE") {
      await writeTo(ARTICLES, `/articles/${record.id}`, record);
    }

    if (type === "DELETE") {
      await ARTICLES.delete(`/articles/${old_record.id}`);
    }

    const { data: articles } = await supabase.from("articles").select("*");
    await writeTo(ARTICLES, "/articles", articles);

    return json({ received: true });
  }
);
```

**Run wrangler development server**

```bash
npx wrangler dev
```

**Publish Cloudflare Worker with Wrangler CLI**

```bash
npx wrangler publish
```

## Resources

- [Supabase Functions blog](https://supabase.com/blog/2021/07/30/supabase-functions-updates#function-hooks-alpha)
- [Supabase.js docs](https://github.com/supabase/supabase-js)
- [Wrangler CLI docs](https://developers.cloudflare.com/workers/wrangler/commands/)
- [KV Storage docs](https://developers.cloudflare.com/workers/runtime-apis/kv/)

Automatically revalidate KV Store cache on change with Database Webhooks in Supabase

Cache Busting or Invalidation, is the process of clearing stale data from a cache. After the first request, the response data from Supabase is cached in our KV store, and never fetched again. This means if data in the database changes, our KV store will never be updated.

In this lesson, we create a `revalidate` route, which fetches fresh data from Supabase and updates the cache.

## Code Snippets

**Revalidate cache for articles route**

```javascript
router.get(
  "/revalidate",
  async (request, { SUPABASE_URL, SUPABASE_ANON_KEY, ARTICLES }) => {
    const supabase = createClient(SUPABASE_URL, SUPABASE_ANON_KEY);
    const { data: articles } = await supabase.from("articles").select("*");
    await writeTo(ARTICLES, "/articles", articles);
    return json({ received: true });
  }
);
```

**Run wrangler development server**

```bash
npx wrangler dev
```

## Resources

- [Supabase.js docs](https://github.com/supabase/supabase-js)
- [Wrangler CLI docs](https://developers.cloudflare.com/workers/wrangler/commands/)
- [KV Storage docs](https://developers.cloudflare.com/workers/runtime-apis/kv/)

Cache-busting with Cloudflare KV stores and Supabase

KV Storage is a read-optimized, eventually consistent cache that can be accessed from Cloudflare Workers. The interface for reading and writing is similar to `localStorage` in the browser.

In this lesson, we create a `read-kv` route for reading from the KV store. This automatically gets passed any KV stores that have been bound to the Cloudflare Worker. Initially, the store is empty, so returns the value `null`.

Additionally, we create a `write-kv` route to populate the store with test data.

To reduce the overhead of stringifying and parsing JSON objects, we create two helper functions to easily read and write values to any KV store.

Lastly, we publish a production version of our Cloudflare Worker, to confirm that writing these value locally - to our preview store - does not affect our production store.

## Code Snippets

**readFrom helper function**

```javascript
export const readFrom = async (cache, path) => {
  const data = await cache.get(path);
  return JSON.parse(data);
};
```

**writeTo helper function**

```javascript
export const writeTo = async (cache, path, data) => {
  await cache.put(path, JSON.stringify(data));
};
```

**Read KV route**

```javascript
router.get("/read-kv", async (request, { ARTICLES }) => {
  const articles = await readFrom(ARTICLES, "/articles");
  return json(articles);
});
```

**Write KV route**

```javascript
router.get("/write-kv", async (request, { ARTICLES }) => {
  const articles = [{ title: "test3" }, { title: "test4" }];
  await writeTo(ARTICLES, "/articles", articles);

  return json(articles);
});
```

**Publish Cloudflare Worker**

```bash
npx wrangler publish
```

**Run wrangler development server**

```bash
npx wrangler dev
```

## Resources

- [Wrangler CLI docs](https://developers.cloudflare.com/workers/wrangler/commands/)
- [KV Storage docs](https://developers.cloudflare.com/workers/runtime-apis/kv/)

Read and write KV Storage cache from Cloudflare Worker

Supabase is an open source Firebase alternative. A service to:

- Listen to database changes.
- Query your tables, including filtering, pagination, and deeply nested relationships (like GraphQL).
- Create, update, and delete rows.
- Manage your users and their permissions.
- Interact with your database using a simple UI.

Supabase is not a 1-to-1 mapping of Firebase. Most notably, Supabase uses Postgres rather than a NoSQL store. 

supabase

Itty Router is a tiny router package that has a similar API to Express. In this video, we install Itty Router and the Extras packages.

Additionally, we refactor our existing worker to use the router, and declare a dynamic route to fetch a single article.

To handle paths and articles that don't exist, we add a catch all route that returns a 404 status.

Lastly, we use the `json` helper to automatically stringify JSON objects and set the `Content-Type` header for `application/json`.

## Code Snippets

**Install Itty Router and extras**

```bash
npm i itty-router itty-router-extras
```

**Run wrangler development server**

```bash
npx wrangler dev
```

**GET route for all articles**

```javascript
router.get(
  "/articles",
  async (request, { SUPABASE_URL, SUPABASE_ANON_KEY }) => {
    const supabase = createClient(SUPABASE_URL, SUPABASE_ANON_KEY);

    const { data } = await supabase.from("articles").select("*");
    return json(data);
  }
);
```

**GET route for one article**

```javascript
router.get(
  "/articles/:id",
  async (request, { SUPABASE_URL, SUPABASE_ANON_KEY }) => {
    const supabase = createClient(SUPABASE_URL, SUPABASE_ANON_KEY);
    const { id } = request.params;

    const { data } = await supabase
      .from("articles")
      .select("*")
      .match({ id })
      .single();

    if (!data) {
      return status(404, "Not found");
    }

    return json(data);
  }
);
```

**Catch all route for 404**

```javascript
router.all("*", () => status(404, "Not found"));
```

## Resources

- [Itty Router repo](https://github.com/kwhitley/itty-router)
- [Itty Router Extras repo](https://github.com/kwhitley/itty-router-extras)

Proxy Supabase requests with Cloudflare Workers and Itty Router

Supabase JS is an NPM package which provides a simple interface from JavaScript to our Supabase project. It allows us to query and mutate data using its Object Relational Mapping (ORM) syntax, and subscribe to realtime events.

In this video, we install the Supabase JS package and create a new client using our project's URL and Anon Key. These can be found in the Supabase dashboard for our project, under `Settings > API`.

We store these values as secrets in our Cloudflare account, and use them to instantiate a new Supabase client.

Additionally, we write a query to select all of our articles from our Supabase instance, and send them back as the response from our Cloudflare Worker.

In order to send a JSON response, we first stringify the object we get back from Supabase, and then set a `Content-Type` header to notify the browser that this will be a type of `application/json`.

## Code Snippets

**Install Supabase JS**

```bash
npm i @supabase/supabase-js
```

**Create a Cloudflare secret**

```bash
npx wrangler secret put NAME
```

**Add a secret for SUPABASE_URL**

```bash
npx wrangler secret put SUPABASE_URL
```

**Run wrangler development server**

```bash
npx wrangler dev
```

**Add a secret for SUPABASE_ANON_KEY**

```bash
npx wrangler secret put SUPABASE_ANON_KEY
```

**Query data from Supabase**

```javascript
const { data } = await supabase.from("articles").select("*");
```

**Send JSON response**

```javascript
return new Response(JSON.stringify(data), {
  headers: {
    "Content-Type": "application/json",
  },
});
```

## Resources

- [Selecting data with Supabase JS](https://supabase.com/docs/reference/javascript/select)
- [Introducing Secrets and Environment Variables to Cloudflare Workers](https://blog.cloudflare.com/workers-secrets-environment/)
- [Cloudflare docs for sending JSON responses](https://developers.cloudflare.com/workers/examples/return-json/)

Query Supabase from Cloudflare Worker

Cloudflare Workers are serverless functions that run at the Edge! 🔪

The Wrangler CLI is a tool for interfacing with your Cloudflare account, and creating or publishing your Workers.

In this video, we use the Wrangler CLI to log in to our Cloudflare account and authorize the `wrangler` command to make changes on our behalf.

Additionally, we create a worker and host it locally with the `npx wrangler dev` command. We then demonstrate making a GET request to our Cloudflare Worker from the browser, and confirm it is sending the correct response.

By modifying the response locally, we can see that changes are reflected any time we refresh the browser.

## Code Snippets

**Login to Cloudflare with Wrangler CLI**

```bash
npx wrangler login
```

**Create Cloudflare Worker**

```bash
npx wrangler init supabase-at-the-edge
```

**Run wrangler development server**

```bash
npx wrangler dev
```

## Resources

- [Cloudflare Wrangler docs](https://developers.cloudflare.com/workers/wrangler/get-started/)

Create a Cloudflare Worker with the Wrangler CLI

Media is an important part in creating a good UX for potential customers of your store, but when serving large unoptimized images, you can end up giving them a poor experience with long page loads.

We can instead use Cloudinary to automatically optimize our images and resize them on the fly with Cloudinary's programmable media API to deliver a more performant online store.

* [Cloudinary URL-Gen for JS - cloudinary.com](https://cloudinary.com/documentation/sdks/js/url-gen/index.html)

Optimize Media with Cloudinary to Deliver Smaller and Performant Images

🚨The Cloudinary UIX has been deprecated. If you are using it, you need to replace it with the App. [Here](https://hygraph.com/docs/guides/integrations/connect-cloudinary#migration) is a step-by-step guide on how to do it. 🚨

We will take an existing UI extension, Cloudinary, clone it down, and create our own instance, installing it into our GraphCMS content editor. Once we add that Cloudinary asset as a field, we will select those images directly from our Cloudinary account and serve those images right inside of our app.

Add and Configure Cloudinary UI Extension to Add Images From a Cloudinary Media Library

We've seen how to return easy and a little complex data from our KV, but how about in a real-world application? We are going to remove the code we have created and set up a simple HTML application that will return our data based on an API which we will create. 

Update Cloudflare Workers KVs Data from an API Route

Behind the scenes, I've updated the HTML UI and added in some helper JS functions to allow us to render new to-do's. We are going to start off by adding in the UI for a user to be able to input their own to-dos. Then we are going to work on creating a backend to store that data and retrieve it using our KV key of `"data"`. 

Filter Data with Cloudflare Workers KV Keys

Our application works but there is one major flaw. Everyone sees the same to-do's. To make to-do's user-specific, we are going to link users' data to their IP addresses so people only see to-dos based on their IP address. 

Identify Users in a Cloudflare Worker by IP to Serve User-specific Data

Now that we have our Workers project up and running, we need to create a KV namespace. A KV namespace is a key-value database that is replicated to Cloudflare's edge. Using the terminal, we will create our namespace and add it to our wrangler.toml file. 

Create a Cloudflare Workers KV Namespace

Creating a new workers project using Wrangler is pretty easy. We first will install and double-check that we have Wrangler installed. Then we will connect Wrangler to our cloudflare project. Lastly, using the terminal, we can easily create our new Wrangler project. 

Create a New Cloudflare Workers Project with Wrangler

We can store and retrieve our data from our KV but not the status of whether or not it's checked off. To do that, we create a function called `completeTodo` that will target the checkbox, find the todo based on its id, flips the boolean from false to true and saves that data, and then updates our to-dos. 

Edit Stored Data using the Cloudflare KV Key

We've learned how to write and receive data from our database, but we've only done it with fairly simple values. Now we are going to see how to do the same thing but with complex key values. There are two ways of doing this. One is the default route where we just return the value back from our KV. The second is where one route takes in a name parameter and sets it as the value for a key. The second path is the one we are going to look at in this lesson. 

Set Complex Key Values in a Cloudflare Workers KV Namespace

To access that data that we stored in our database, we use the .`get()` function. `.get()` is also an async function and we will need to `await` it. 

Read Data from Cloudflare Workers KV with BINDING.get 

Now that we have our database setup, we need to be able to write data to that database. Firstly, we need to understand the binding concept. Secondly, we are going to use `.put()` to write that data to our database. Remember that `.put()` is an async function so we need to `await` it for it to work in the way that we want it to. 

Write Data to Cloudflare Workers KV Store with BINDING.put

We recently made more specific location personalization features available to all users on Cloudflare Workers. Previously only available to Enterprise users, these new features will allow us to give more detailed information in our example project, such as the city the user is visiting from.

Use Location Personalization Features in Cloudflare Workers

In this course, Kristian Freeman will teach you how to build and deploy a Serverless API with Cloudflare Workers. By learning how to build your own serverless JSON APIs, you can effectively manage a highly-available backend for your projects, without needing to learn DevOps or manage services.

Introduction to Build a Serverless API with Cloudflare Workers

Cloudflare Workers let you write JavaScript Service Workers that run directly in Cloudflare's 200+ edge locations around the world.

With a Cloudflare Worker, you can modify your site's HTTP requests and responses, make parallel requests, and even reply directly from the edge.

Cloudflare Workers are written against a similar API to the W3C Service Workers standard. However, while Service Workers run inside the end user's browser, Cloudflare Workers run on Cloudflare's servers. This means that Cloudflare Workers can implement trusted code (which the client cannot tamper with), and will work no matter what browser the user is running.

In this course, Kristian Freeman will teach you how to build and deploy a Serverless API with Cloudflare Workers. By learning how to build your own serverless JSON APIs, you can effectively manage a highly-available backend for your projects, without needing to learn DevOps or manage services.

Build a Serverless API with Cloudflare Workers

Gemini 2.0 has a context window of a million tokens, and this means that you can upload hundreds of files and allow it to inspect and analyze massive refactors across entire code bases. 

This lesson demonstrates concatenating an entire code base into a single file and then uploading it to AI Studio. Once within AI Studio, we ask it to find the types of tasks that it can evaluate for us. Then we select one of the tasks and ask it to generate instructions for that task. Once those instructions are complete, we then turn them over to Windsurf's Cascade agent, and we allow Windsurf's Cascade to do all of the work for us as we sit back, relax, and let the AI do our jobs.

Use Gemini 2.0 to Create Agent Instructions to Refactor an Entire Codebase

Learn how to display custom components in a [Tanstack Table cell](https://tanstack.com/table/latest/docs/guide/cells), including how to render capitalized text, apply conditional styling with class helper functions, and format dates using the `Intl` API for readable display. 

`flexRender` allows you to utilize the `cell` callback method in your column definitions. Tanstack table will call this function to render the custom component you defined.

Render Custom JSX in a Tanstack Table cell

Use tanstack table flexRender method to render custom components in a table component. Capitalize letters, apply conditional styling, and render dates with Intl

I'm extremely excited for the potential of AI watching your screen while you work. I decided to take Google's AI Studio for a spin, which just introduced a feature called "Stream Realtime", which allows AI Studio to observe your screen and listen to your microphone while you work.

This video is my initial attempt to try and coach AI Studio through the process of building a site from a reference site, essentially trying to build egghead.io from a Next.js starter template. And we'll explore the various attempts we make and what works and what doesn't.

Let AI Watch Your Screen: Build Next.js Pages with AIStudio's Stream Realtime


[Shadcn](https://ui.shadcn.com/docs) is a popular component library that allows you to install components into your codebase.

Learn how to install the [Table component](https://ui.shadcn.com/docs/components/table) and use that presentational component with [Tanstack table](https://tanstack.com/table/latest).


Display Tabular Data in React with Tanstack Table

Build a dynamic table component in React using shadcn component library and tanstack react table.

TypeScript's satisfies operator finally clicked for me when I realized it's almost always used for specific implementations of configuration objects. So this lesson walks you through the naive approaches I've taken before and how to solve them using the satisfies operator. After this, satisfies will be another tool in your belt in TypeScript. To clean up all the TypeScript code you have around configuration.

TypeScript's "satisfies" for Configuration

Windsurf and Cursor are both able to take an image and then use an agent to build out what it sees in that image. This lesson is going to compare Windsurf and Cursor by uploading the same image to both and giving them the same prompt. Comparing not only the results, but also the steps that they take to get there. We'll also try uploading additional images throughout the process to see what they do as far as revising along the way and improving the site as they go along. 

Windsurf Cascade vs. Cursor Composer Agent: Build a Site from an Image

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

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.

Search

Search Results