Heads up! To view this whole video, sign in with your Courses account or enroll in your free 7-day trial. Sign In Enroll
Well done!
You have completed Create a No-Code REST API Using Xano!
You have completed Create a No-Code REST API Using Xano!
Preview
In this video, you'll learn how to populate your database with dummy data and test API endpoints. After that you'll implement authentication, and create custom endpoints for your digital marketplace using Xano's powerful API builder.
Related Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign upRelated Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign up
Before we dive into the API endpoints,
0:00
let's populate our database
with some test data.
0:03
Xano makes this really easy
with its data generation feature.
0:06
Click on any of our tables
to see its contents.
0:11
Let's start with the users table.
0:14
While we could manually add
0:18
data, Xano offers
convenient generation buttons
0:21
that can create
realistic test data for us.
0:25
When we click Generate,
we get a modal where we can specify
0:29
exactly
what kind of data we want for each column.
0:33
For users, Xano already
suggests sensible defaults,
0:37
full names
for the name field, valid email addresses,
0:41
and secure random passwords.
0:46
Let's generate three users to work with.
0:49
Great.
0:56
Next up, for our products table,
0:58
we can customize the generation
a bit more.
1:00
Instead of full names, let's set
1:04
the product name to be two random words.
1:06
This makes it a bit more realistic.
1:10
We'll set the
1:15
description
to generate a single paragraph,
1:15
and for the price,
we'll use random numbers
1:19
between 99 cents and $100.
1:22
For the order generation,
1:39
Zeno already knows to use
random IDs from the related tables,
1:41
so we'll just confirm that
to generate our orders.
1:45
For the reviews,
we'll make sure that the rating is
1:50
a number between 1 and 5.
1:53
And for the comment,
I'll set it to a paragraph,
2:01
but have half of the values
be null, as users
2:05
could only leave a rating 2.
2:08
Now that we have some data to work with,
2:17
let's explore the API endpoints.
2:19
Navigate
to the API section in the sidebar.
2:22
You'll notice we have two API groups.
2:26
Authentication,
which was set up automatically
2:30
when we enabled user authentication.
2:33
And Marketplace,
which contains all the CRUD
2:36
endpoints Xano generated
based on our database tables.
2:40
The authentication group has three key
2:45
endpoints, login and signup,
which are post requests,
2:47
and a me endpoint,
which uses the get method.
2:52
Let's look at the login endpoint first.
2:57
Xano breaks down each endpoint into clear
sections.
3:00
The input section shows what data
the endpoint
3:04
expects, in this case,
an email and password.
3:08
The function stack shows the logic.
3:12
It looks up
the user, validates the password,
3:15
and if everything matches, generates
an authentication token.
3:18
Finally, the response section shows
what gets sent
3:22
back to the client.
3:25
The me endpoint is interesting
because it requires authentication
3:33
indicated
by the auth requirement at the top
3:38
This means that there has to be
an auth token provided when the request
3:41
is being made With it being a get request,
it doesn't need any input data.
3:46
It simply fetches the current user's
information from the database
3:52
based on the provided auth token
and then returns it in the response.
3:56
The signup endpoint
4:03
handles new user registration,
4:05
taking in a name, email, and password.
4:08
It checks if the email is already in use,
4:11
creates the new user if it isn't,
4:15
and returns an auth token
4:18
just the login endpoint.
4:20
Now let's explore
the marketplace endpoints
4:24
that Dano generated for our product,
order,
4:27
and review tables.
4:30
Let's look at the Marketplace group,
4:33
where Zeno has automatically created
endpoints based on our database tables.
4:35
You'll find sections for orders, products,
and reviews,
4:41
each with its own set of CRUD operations.
4:45
Let's focus on the Get Endpoint
for Products, which will be crucial
4:49
for our Marketplace's
product listing page.
4:53
This product's
endpoint is set up as a public endpoint,
4:57
meaning anyone can access it
without authentication.
5:01
Its function stack is straightforward.
5:05
It queries the database for all product
records, stores
5:08
them in a variable,
and then returns it in the response.
5:12
We can test this right away by clicking
the Run button in the top right corner.
5:16
A sidebar
opens, and if we make the request,
5:21
it'll show us the actual response,
5:25
an array of all those products
we generated earlier.
5:27
Zeno makes it easy to use these endpoints
in your frontend
5:32
by providing a ready-to-use URL.
5:35
You can find this in the top left.
5:39
Clicking
it copies the endpoint to your clipboard.
5:42
Let's paste that into a new browser tab.
5:46
And there you have it,
5:50
all our products in JSON format.
5:52
But what if we want to show
more information about each product? For
5:56
instance, it would be useful to include
review data alongside each product.
6:00
Xano makes this kind of data enrichment
6:05
really simple through its add-on system.
6:07
If we click on the query in our function
stack and go to the output tab,
6:10
we can see the current response structure.
6:16
To add reviews,
6:19
we'll click the yellow add-on
button, create a new add-on,
6:21
and select the review table.
6:25
In the add-on configuration,
we have several options
6:29
for how we want to include the review
data.
6:32
We'll choose list of items
6:35
to get all reviews for each product.
6:38
This will let us calculate things
average ratings
6:42
and showing the total number of reviews.
6:45
The next step is mapping the relationship.
6:49
We'll select
Product ID as our linking field.
6:52
And we'll name this new property
6:59
Reviews in our response.
7:01
After confirming the add configuration
7:13
you see the updated response
7:16
Let try running the request again
to see the difference
7:19
It looks the return products now
7:23
include a reviews array Perfect!
7:26
Some products have empty arrays
if they haven't received a review yet,
7:29
while others show a list
with multiple reviews.
7:34
This enriched data structure
gives our front-end
7:38
everything it needs to display products
with their ratings and reviews.
7:41
Now that we've enhanced
7:48
our product endpoint with reviews
and confirmed
7:49
that it's working as intended,
we need to publish these changes.
7:52
Notice
the indicator next to the Run button
7:57
showing we have unpublished modifications.
7:59
Clicking this gives us the option
to review our changes
8:03
or revert them if needed.
8:07
To make these changes
available in production, click
8:09
the green publish button.
8:12
For good version control practices,
8:15
let's add a message of added reviews
8:18
and click publish.
8:23
Now when we visit our endpoint URL again,
8:25
we'll see the reviews included in our JSON
8:28
response.
8:31
Now let's improve
8:36
the security of our product creation
endpoint.
8:37
By default, Xano creates public endpoints,
but we want to ensure
8:40
only authenticated users
can create new products.
8:45
Navigate to the post endpoint for products
8:49
and click where it says public endpoint.
8:52
Simply
8:57
change the authentication
setting from disabled
8:57
to user authentication.
9:01
Let's test this change.
9:05
Notice
how we now need to provide an auth token.
9:07
If we try with an invalid token ABC,
9:11
we get an error as expected.
9:15
For testing, we can use the magnifying
glass to select a test user.
9:18
Let's use Brian Thompson
with the user ID of 1.
9:23
This will populate the field
with an auth token.
9:28
If we now try to create a test product
9:31
with some dummy data,
9:34
and make the request,
9:40
it shows us it works,
creating a new product with the ID 24.
9:41
We can verify this using the get endpoint
9:48
for single products,
9:51
providing our new product
9:56
ID to see it in the database.
9:57
However, there's a security issue
we should address.
10:03
Currently, the seller ID is set to zero,
10:07
even though we're authenticated
as the user with ID 1.
10:10
If we navigate back to the post route
10:15
and try adjusting the seller's ID to be 3,
10:27
we're able to create a product
10:34
on behalf of another user.
10:35
To prevent this,
10:40
we should automatically set
the seller's ID
10:41
to match the authenticated user.
10:44
First
10:50
adjust the inputs by clicking on Seller ID
10:51
We hide this input and uncheck
the required box
10:55
so this no longer has to be provided
when making a request
11:00
Next in the function stack modify
11:05
the record creation step Where seller
11:09
ID currently defaults to zero, we can use
11:12
the authenticated user's ID instead.
11:16
Switch to the Auth tab and select ID.
11:20
This will automatically use
the authenticated user's ID
11:24
as the seller's ID.
11:28
Let's test this improvement.
11:31
Using Brian's Auth token, user number 1,
11:33
create a product
without specifying a seller ID.
11:37
Perfect.
11:46
The new product shows seller ID as 1.
11:47
To verify it's working correctly,
let's switch
11:50
to Sean's auth token, user 2,
11:53
and create another product.
11:56
As expected,
12:00
this product's seller ID is set to 2.
12:01
Now our endpoint is both secure
and automatically tracks
12:05
who's creating each product.
12:09
For our final example,
12:14
let's create a custom endpoint
that will show users their order history.
12:15
While Xano generated basic CRUD
endpoints for us,
12:21
we often need more specialized endpoints
for specific business logic.
12:24
In the Marketplace
group, click the Add API
12:29
Endpoint button in the top right.
12:33
Xano offers several types of endpoints,
but since we want to fetch data
12:36
from our database,
we'll choose CRUD database operations.
12:41
We want to retrieve all orders
belonging to the authenticated user,
12:47
so we'll select the order table
and set this up as a get method endpoint.
12:52
Let's name this endpoint my orders.
12:59
XANA will automatically convert this
13:03
to become snake-cased in the URL.
13:05
Since we'll need to know
which user is making the request,
13:09
change the authentication setting
from Disabled to User Authentication
13:13
to ensure only logged-in users
can access their order history.
13:18
By default, the endpoint
13:24
queries all records from the order table.
13:25
But we need to filter these to show
only the current user's order.
13:29
Click the query in the function stack,
13:33
and in the first tab,
we can add a custom query condition.
13:36
Click Add a conditional
and set it to match orders
13:41
where the user ID field equals
the ID of the authenticated
13:45
user.
13:49
Let's test this endpoint.
13:57
Using Brian's auth token, user number one,
we can run the request.
13:59
The response shows us
exactly what we want, a list of all orders
14:04
where the user ID is one,
which corresponds to Brian's account.
14:09
This gives users an easy way
to view their purchase history.
14:14
This custom
14:19
endpoint demonstrates how Xano lets us go
beyond basic CRUD operations
14:20
to create exactly the functionality
our application needs while maintaining
14:25
security by requiring authentication
and filtering data appropriately.
14:30
You need to sign up for Treehouse in order to download course files.
Sign upYou need to sign up for Treehouse in order to set up Workspace
Sign up