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

Get started with Supabase on your machine

Creeland Provinsal

Create a Supabase account and database quickly by going to https://database.new

Create a Supabase Account and Database

Create an application and install packages 

Generate a New NextJS with Supabase App

With our project setup we will use our supabase dev dependency to run the supabase cli. We will login to our supabase account and then init the project locally. 

To run supabase locally you need to have Docker installed and running on your computer. To install Docker and get it setup visit this link - https://docs.docker.com/desktop/

Use Supabase CLI to Login and Init Project

With the project setup, we can now start our local instance of supabase. This gives us a local running version of the supabase studio that we can interact with. 

We will create a table in called todos in the studio

Start Supabase Locally and Create a Table

With Supabase Link we can link our local project to a remote database. Then we can use the command `npx supabase db diff -f <fileName>` to create a local migration file. 

Then we use `npx supabase db push` to apply our local changes to the remote database.

Link Local Database to Remote and Run a Migration with Supabase

When `npx supabase init`, `npx supabase start`, or `npx supabase db reset` is run, supabase will look for our `seed.sql` file and seed our local database.

Since we have already created the project and we want to add seed data, we can run `npx supabase db reset`. 

Add Seed Data to Local Database with Supabase

It is common, when working on a team, for changes to have been applied to a remote database and for your local instance to be out of sync.

By running `npx supabase db pull` we can pull any changes to our remote database schema to keep our local database in sync.

Pull Remote Database Changes with Supabase

In common workflows we do not want to push directly to the remote database from our machine. We will setup a github action that will run whenever we push to our main branch of our github repo. 



Deploy Local Database Changes to Supabase Remote Through Github Actions

Build a blazing fast chat app with Remix and Supabase! This course covers everything you need, from database hosting to authentication and authorization, all with real-time updates

Build a Realtime Chat App with Remix and Supabase

Combining Supabase, Cloudflare Workers and KV Storage give you the benefits of reduced lag in a smooth and streamlined process.

Cache Supabase data at the Edge with Cloudflare Workers and KV Storage

You'll build a static app with authentication that is backed by a database, change the structure of that database without compromising data, and take payments for subscriptions.

Build a SaaS product with Next.js, Supabase and Stripe

Getting Started with Supabase Local Dev

https://app.egghead.io/api/v1/lessons/supabase-create-a-supabase-account-and-database/subtitles

[00:00] Get started, we can come to database dot new, and we can log in with GitHub, authorize. This will create our account. Okay. Now we can just give it an organization name. Let's just call this personal super base. K. We'll create our first project. We'll just call this to dos, generate strong password.
[00:21] And with that, we have our Supabase account set up as well as a database.

https://app.egghead.io/api/v1/lessons/supabase-create-a-supabase-account-and-database/transcript

https://app.egghead.io/api/v1/lessons/next-js-generate-a-new-nextjs-with-supabase-app/subtitles

[00:00] With our database set up, we can go ahead and create our application. So let's run MPX create next app. Let's call this to dos with Supabase CLI. Yes. Yes. Yes. No. Yes. And the last thing we need to install are our Supabase packages. So we'll install these for our dependencies, and then we'll install a
[00:19] dev dependency, which is just Supabase. And we'll just install. Okay. Now we can open our application. Okay. And then we can check our package JSON to make sure everything is installed directly. So in this lesson, we just created a new project by running the CLI command to create a new Next
[00:39] JS project. We're using the app directory, and then we installed our super base packages.

https://app.egghead.io/api/v1/lessons/next-js-generate-a-new-nextjs-with-supabase-app/transcript

https://app.egghead.io/api/v1/lessons/supabase-use-supabase-cli-to-login-and-init-project/subtitles

[00:00] We can run MPX super base login. And so it needs our access token. So we can find our access token if we come back to our organization. And under account, you'll see access tokens. And we'll need to generate a new token, and we'll call it to do's app access token.
[00:19] And then we can copy that and back in our and paste your access token here. And so it won't show it, but the value is there. Then click enter, and then we are now logged in. And before we start local development, you need to make sure that Docker is running. So if you have Docker already installed, then you just need to go and start up Docker. If not, then you can come to their website, and
[00:39] it'll give you the correct package that you need for installation here. So then just grab the one that's appropriate for your machine and install it, and you can go ahead and run npx Supabase init. Yes. So now we have our Supabase folder and it has all of the config information here.

https://app.egghead.io/api/v1/lessons/supabase-use-supabase-cli-to-login-and-init-project/transcript

https://app.egghead.io/api/v1/lessons/supabase-start-supabase-locally-and-create-a-table/subtitles

[00:00] Now we can run MPX Supabase start. And this is where if you don't have Docker running, it will not work. So it's gonna pull all these images. Okay. Now that everything is set up, we can come to our browser and go to this URL for the studio URL. We can come to our table editor. Let's create a new table, and we'll call it to dos. It'll be an ID. We can remove the
[00:19] created app, make this a UUID. Give it a text, be of type text. It should not be nullable. What good is it to do? It's nullable. And then if we add another column, we'll just call this one completed. And this will be a Boolean, and the default value will be false. Save. And with
[00:39] that, we now have our local database running, and we've created a tape.

https://app.egghead.io/api/v1/lessons/supabase-start-supabase-locally-and-create-a-table/transcript

https://app.egghead.io/api/v1/lessons/supabase-link-local-database-to-remote-and-run-a-migration-with-supabase/subtitles

[00:00] We need to link this project with our remote project, so we can say mpx supabase link. And you see it asked for the project ref, and so we need to run that command again. We'll say project ref, and then we'll give it the project ID. So if we come back into our remote database to our settings,
[00:19] so we can get our reference ID. So we can copy that and come back to our terminal and paste that ID. And now when we run this, we need to give it that password that we generated. So grab your password, and then you can paste your password there. It won't show it. Now when you click enter, it links to your remote project. So now we can create our first migration. So we can
[00:39] run npx Supabase db diff. And then we wanna create a new file by diffing the local database. So we can just say local. So it's gonna look at our local database, create the shadow database, diff the 2, and then create a migration file. Okay. Now if we look in our
[00:59] migrations folder, we'll see we have a migration. And this is just the SQL for creating our to dos table. So now we can run npx Supabase db push, and this will push our migrations to our remote database. Okay. And then if we come back into
[01:19] our project, and we can come to our tables, and refresh. And now in our remote project, we have the to dos table.

https://app.egghead.io/api/v1/lessons/supabase-link-local-database-to-remote-and-run-a-migration-with-supabase/transcript

https://app.egghead.io/api/v1/lessons/supabase-add-seed-data-to-local-database-with-supabase/subtitles

[00:00] Whenever you start your local instance of Supabase, you'll notice you have the c dot SQL file. Starting off, it'll be empty, but as your project grows, you probably want to have some seed data in this file. So we're just gonna paste some to dos here, and we're gonna save it. Now if you were starting up super bass and ran
[00:20] super bass in it, then this would run. If you had already initted super bass and you ran start, then this would run. But since our local instance has already started, we can just say super bass, DB reset. And when we run this, it's gonna reset everything. And then it's gonna run our seed command. And
[00:39] then we'll see our data populated over here on the right. Okay. The command has finished running. Now if we come back to our project, we see our to dos.

https://app.egghead.io/api/v1/lessons/supabase-add-seed-data-to-local-database-with-supabase/transcript

https://app.egghead.io/api/v1/lessons/supabase-pull-remote-database-changes-with-supabase/subtitles

[00:00] In a typical workflow, you might have more than one developer working on any given project. So say in your main remote branch, another developer has made changes, and those have been picked up either through CICD. And now let's say you have a another column. So let's insert a column. We're just gonna call this user ID
[00:19] and we're just going to give it a type of u u ID and then we can just go ahead and save that. And so now we have a user ID column, but on our local database, we do not. So the way that we can do this is just running, MPX SuperBase DB pull. This will grab our remote instance
[00:39] and pull down changes in our schema. Okay. If we pull up our terminal, we can see that it applied our local, migration file, and then it went ahead and created another migration for us from the remote database to apply to our local database. We can just say yes. So now we need to run the reset
[00:59] command again. Okay. Now if we come back to our project, make sure you refresh and we look at our table, we see we now have our user ID column here that we created on our remote branch. So as a recap, when changes are made to the remote database and you want them locally, you can run super base DB pool, create a migration file,
[01:19] and then run super base DB reset and you will have the updated schema on your local database.

https://app.egghead.io/api/v1/lessons/supabase-pull-remote-database-changes-with-supabase/transcript

https://app.egghead.io/api/v1/lessons/supabase-deploy-local-database-changes-to-supabase-remote-through-github-actions/subtitles

[00:00] If you remember back to a previous lesson, we used Supabase db push to push our changes in our local database to our remote database. Now, when you're working on a team, you most likely don't want to have that workflow. You probably want to have some sort of CICD set up so that when you push to your GitHub repository,
[00:20] it picks up those changes as a part of c I and then deploys them. So first, I have a GitHub repository set up. And then you'll notice I have this GitHub workflows set up. So you want to create a GitHub folder with a workflows folder in it. And then I've just called this prod to dos dot YAML. And this error here is because I have an extension. It's a YAML extension. If
[00:40] you want to install it, you can just install it from the v s code. Marketplace is the first one in the list. And it just helps with formatting because you may get syntax errors otherwise when your action gets pushed to GitHub and it tries to run it. So I'm gonna go ahead and paste our code here, and we're gonna save that. And we're gonna leave this alone for a second. Let's go ahead and come back into our project that's running locally and
[01:00] let's just create a new table and we'll call this users. We'll just add a user name column and this will be of type text. Save. Okay. So now we have a user's table in our local database. So back in our terminal, we need to run m p x x super base d b diff. And then we want to create a file and we'll just name this users table created. And this time instead of
[01:19] pushing with super base d b push, we're gonna use our newly created action here that references our project to push as part of the GitHub action. So if we wanna just run through this GitHub action file real quick, we're just saying every time we push to the main branch, we want to run this action. And we have some environment variables set in our GitHub secrets.
[01:39] And then we're gonna run this super base link to our project and then we're gonna push any changes that picked up it picks up in our super base file to our remote database. So now if we come back to GitHub and let's look at our settings, we can come to secrets and variables, actions. You'll see I've already created my secrets. So what you wanna do
[01:59] here is just grab the names over here. You'll create a new repository secret. This will be the name. And then whatever your access token is in your project, you'll give that as the value. Same thing with your password when you created your database and then the project ID. And if you need help finding those values, you can come into settings, go to usage, and then you can find your access token here. Or you can
[02:19] generate a new one if you don't remember it. And then to find your project ID, you come into project settings and it's this reference ID value. And then the password is the password you created whenever you created the database. And if you need to create a new password, you can come here and you'll see we open this a little bit more. We can reset the database password. Let's close that. We can come
[02:39] back to our project and let's come back to the code. And so now that we have dipped our database and we have the migration file, we get this message here that says, you should run through base DB reset. And this is just to test that everything is working properly locally before we push to GitHub and try to merge it into our remote database. So we can run p x
[02:59] super base d b reset. Okay. That's finished running and everything is working fine. So now we can run git add. We'll give it a commit message. Created GitHub action and then we'll push. Okay. And then we want to come into our actions and you'll see this action is running. Ignore all of these. This was for testing. And so we can come in here now and we can look at
[03:19] our deploy. So Super base DB push has ran and it applied the migration. So now if we come into our actual project and let's come back to our table editor, we now have our users table.

https://app.egghead.io/api/v1/lessons/supabase-deploy-local-database-changes-to-supabase-remote-through-github-actions/transcript

Getting Started with Supabase Local Dev

Ben Patton

Free Community Resource

You might also like these resources:

Build a Realtime Chat App with Remix and Supabase

Cache Supabase data at the Edge with Cloudflare Workers and KV Storage

Build a SaaS product with Next.js, Supabase and Stripe

Credits

Free Community Resource

Course Content

You might also like these resources:

Build a Realtime Chat App with Remix and Supabase

Cache Supabase data at the Edge with Cloudflare Workers and KV Storage

Build a SaaS product with Next.js, Supabase and Stripe