How to Build a Job Application Tracking System with Notion API, Node.js, and Fas...
source link: https://hackernoon.com/automating-job-applications-tracking-with-notion-api-nodejs-and-fastifyjs-112735dv
Go to the source link to view the article. You can view the picture content, updated content and better typesetting reading experience. If the link is broken, please click the button below to view the snapshot at that time.
How to Build a Job Application Tracking System with Notion API, Node.js, and FastifyJS
@catalinmpitCatalin's Tech
Writing about Vue, Node.Js, AWS, JavaScript, Cloud Computing and Software Development
Learn how to use the new Notion API with Node.js and FastifyJS
Notion is productivity software that allows you to create systems for knowledge management, project management, and note-taking.
They recently released their API to the public. You can use the API to integrate your Notion data to any application you want.
Thus, this article shows you to:
- build a Node.js API with Notion
- use FastifyJS to create the API
Without further ado, let's start configuring your Notion workspace.
Create integrations in Notion
Go to your Notion integrations and create a new integration by clicking on the "+ New Integration" button. After that, you will be prompted to fill three fields:
- the name of your project
- a logo for the project
- choose an associated workspace
Figure 1 above illustrates the setup process. After filling all the fields, click on the "Submit" button to create the integration.
Once you click the submit button, your integration should be created. You will be redirected to another page, from where you can grab your "Internal Integration Token ". Figure 2 shows that.
Before going further, it's important to note that you need to leave "Internal integration" checked, as you can see in figure 2.
For a more in-depth tutorial about creating Notion integrations, I recommend checking their official documentation.
Share your Notion pages
The last step is to share whatever page you wish with the newly-created integration. Go to your Notion account, and choose any page you want.
After the page opens, click on the "Share" button, and then click on the field saying "Add people, emails, groups, or integrations".
Figure 3, below, illustrates that.
After clicking on that field, you are prompted to choose with whom you want to share the page. Choose your integration. In my case, I share the "My space" page with my integration called "My notion space".
That's all you need to do when it comes to configuring Notion, so well done! You are done with the Notion configuration, and you are ready to use the Notion API.
Note: If you want to use the same document as me, you can duplicate this job applications template. After you duplicate it, share it with your integration (see the process above) and use your database ID (you'll see how to get the database ID later).
Configure the Node.js project
You need to use the Notion SDK for JavaScript to interact with the Notion API in your Node.js application. The Notion SDK is a client for the Notion API, and you can find more about it on its GitHub repository.
The first step is to create the application structure. Create a new folder and initialize the application as follows:
mkdir notion-api-app
cd notion-api-app
npm init -yThe command npm
init -yThe next step is to install the packages required to create the application. You'll use the following packages:
- Notion SDK - to interact with the Notion API.
- FastifyJS - to build the Node.js API.
- dotenv - to manage environment variables.
Thus, you can install the packages as follows:
npm install @notionhq/client fastify dotenvOnce the packages are installed, you need to create a file to store the environmental variables. You will store the Notion secret token and the database ID in the
.env.envtouch .envNow go to your Notion integrations and click on your integration. You should see a field called Internal Integration Token (see figure 2 for reference). Click on the "Show" button and copy the token.
The next step is to go to your .env file and add the token:
NOTION_TOKEN=<your_token>Note: Replace
<your_token>Before going further, you also need to create the folder structure for the application. You need to create the following folders:
- app.js - the home for your server configuration
- src - it hosts all the other folders.
- routes - the home folder for your routes.
- notion - the Notion client resides here.
- controllers - the home folder for your business logic.
You can create all the folders and files from the command line as follows:
touch app.js
mkdir src
mkdir src/routes src/notion src/controllers
touch src/routes/routes.js
touch src/notion/client.js
touch src/controllers/controllers.jsThis is how the structure of your application should look like until this point:
Now you are ready to build the application!
Configure Notion in the application
It's time to configure the Notion client so you can use it to manipulate data. Go into the following file
src/notion/client.jsconst { Client } = require('@notionhq/client');
require('dotenv').config();With the first line, you import the Notion client, and with the second one, you import the
dotenvThe next step is to create a new Notion client. In the same file, after the imports, write the following code:
const notion = new Client({
auth: process.env.NOTION_TOKEN
});With the above code, you create a new instance of the Notion client and pass your secret token. Lastly, you store it in the
notionBefore going further, you need to export the notion constant so you can use it when you write the business logic. In the same file -
src/notion/client.jsmodule.exports = {
notion
};Now you are ready to use the Notion client.
Check this gist to see how your file client.js file should look up to this point.
How to get the database ID
There is one more step before building the routes. You need the database ID so you can perform operations such as:
- creating, reading and modifying data
You can get the database ID in two ways. You can either do it from the browser or programmatically.
If you prefer to do it from the browser, open the Notion document in your browser and copy the ID as shown in figure 5.
Alternatively, you can get the database ID programmatically, as shown in the snippet below:
const getDatabases = async () => {
const databases = await notion.databases.list();
console.log(databases);
};The above code snippet lists all your databases and the information about them. For a visual representation, see figure 6 below.
Whatever option you end up using, copy the database ID and add it to your
.env.envNOTION_TOKEN=<your_token>
DB_ID=<your_DB_ID>You finished configuring the Notion client in your project. The next step is to create the routes and business logic.
Add FastifyJS
Open the file
app.jsconst app = require('fastify')({ logger: true });After that, import the "dotenv" package again so you can use the port, which is defined in the
.envrequire('dotenv').config();The next step is to register the routes, even though you did not write them yet. After the imports, add the following line:
app.register(require('./src/routes/routes'));With the above line, you register all the routes. That is, you make the routes available so users can access them.
Lastly, listen to a port so you can run the application. Add the following code at the bottom of the file:
app.listen(process.env.PORT, (err, addr) => {
if (err) {
app.log.error(err);
process.exit(1);
}
app.log.info(`Your server is listening on port ${process.env.PORT} 🧨`);
});The application listens to a port you define in the
.envThus, add the port number - 3333 - in your
.env.envNOTION_TOKEN=<your_token>
DB_ID=<your_DB_ID>
PORT=3333Check this gist to see how your file app.js file should look up to this point.
Build the routes
The next step is to create the routes. Their purpose is to allow people to perform CRUD operations (except deleting data in this tutorial).
For the beginning, go to
src/routes/routes.jsconst controller = require('../controllers/controllers');Even though you did not write the business logic yet, you will need it. After that, create the
routesasync function routes(app, opts) {
// the code for routes go here
};
module.exports = routes;In the routes method, you configure your application's endpoints. For each route, you specify, at minimum, the:
- HTTP method - for instance, you use the GET HTTP verb to return all items in your database.
- URL - for example, you might use the endpoint
to return all the job applications./job/applications - handler - this represents the business logic. For example, what happens when people access the endpoint
./job/applications
Now that you understand how routes work in FastifyJS, let's build the first route.
Show all job applications
The first route shows all job applications when a user makes a
GET/job/applicationsapp.route({
method: 'GET',
url: '/job/applications',
handler: controller.getAllApplications
});Get a specific job application
The second route shows only one job application. When the user makes a
GET/job/applications/:idWrite the following code after the first route:
app.route({
method: 'GET',
url: '/job/applications/:id',
handler: controller.getApplication
});Filter job applications
The third route allows the users to filter the job applications by the company name. The user can use a query parameter called
companyAn example of a URL would be
/job/applications/filter?company="CatalinSoft"GETWrite the following code in
routes.jsapp.route({
method: 'GET',
url: '/job/applications/filter',
handler: controller.filterApplications
});Add a new job application
The fourth route allows people to make a
POST/job/applicationsWrite the following code:
app.route({
method: 'POST',
url: '/job/applications',
handler: controller.addApplication
});Update existing application
Lastly, you have the route which allows people to update an existing job application. Make a
PATCH/job/applications/:idapp.route({
method: 'PATCH',
url: '/job/applications/:id',
handler: controller.updateApplication
});Those are all the routes. As you can see, they follow the same pattern:
- You specify the HTTP method.
- You add the URL where people can make the request.
- You provide the handler which is triggered when a request is made to that route.
Also, you might've noticed that there is no "delete" route. That is because the Notion API does not allow you to delete resources at the moment.
Check this gist to see the complete routes.js file.
Add the business logic
The last step of the tutorial is to build the business logic. The business logic specifies what happens when a certain HTTP request is made to a specific endpoint.
Let's start by importing the Notion client in the
controllers.jsconst { notion } = require('../notion/client');Now, you can use the client to manipulate data.
Retrieve all job applications
The first method you write is the one that returns all the job applications. Write the following code in
controllers.jsconst getAllApplications = async (req, res) => {
const data = await notion.databases.query({
database_id: process.env.DB_ID
});
};Up to this point, you use the Notion client to query your database. The above piece of code returns an object, which in turn contains an array with all the pages from your database.
This is the result you get if you run the above code:
{
object: 'list',
results: [
{
object: 'page',
id: '8e8e8f35-09ac-40fd-92a2-a3743b271e2e',
created_time: '2021-05-26T05:45:00.000Z',
last_edited_time: '2021-05-26T05:45:00.000Z',
parent: [Object],
archived: false,
properties: [Object]
},
{
object: 'page',
id: '03a7aea1-c58b-49ce-9843-87131c37192a',
created_time: '2021-05-25T06:10:08.816Z',
last_edited_time: '2021-05-25T06:10:08.816Z',
parent: [Object],
archived: false,
properties: [Object]
}
],
next_cursor: null,
has_more: false
}From this response, the field
resultsSince you have an array, you need to loop over it and return only the pages. Go back to the method
getAllApplicationsconst getAllApplications = async (req, res) => {
const data = await notion.databases.query({
database_id: process.env.DB_ID
});
const pages = data.results.map(page => {
return {
id: page.id,
created: page.created_time,
updated: page.last_edited_time,
company: page.properties.Company.title[0].plain_text,
position: page.properties.Position.select.name,
status: page.properties.Status.select.name,
deadline: page.properties['Next Deadline'].date.start,
jobDescription: page.properties['Job Description'].url,
comments: page.properties.Comments.rich_text[0].plain_text
}
});
return pages;
};In the second part of the code, you map over the
results- the ID
- when it was created
- when it was last updated
- the company name
- the position you applied for
- the status of the application
- the application deadline
- the job description
- additional comments
Let's make a GET request to
localhost:3333/job/applicationsFigure 7 illustrates what happens after making the request. You can see it returns an array of objects, exactly how you structured them in the method
getAllApplicationsGet a specific application
The next step is to add the business logic for retrieving only a specific job application. This time, you use different methods. Rather than querying a database, you retrieve a specific page.
Write the following method in your file
controller.jsconst getApplication = async (req, res) => {
const page = await notion.pages.retrieve({
page_id: req.params.id
});
return {
id: page.id,
created: page.created_time,
updated: page.last_edited_time,
company: page.properties.Company.title[0].plain_text,
position: page.properties.Position.select.name,
status: page.properties.Status.select.name,
deadline: page.properties['Next Deadline'].date.start,
jobDescription: page.properties['Job Description'].url,
comments: page.properties.Comments.rich_text[0].plain_text
};
};The method takes the ID of the page from the URL. Thus, if you make a
GEThttp://localhost:3333/job/applications/8e8e8f35-09ac-40fd-92a2-a3743b271e2eAfter that, it returns the page whose ID matches the ID provided in the URL. Let's make a request and see what happens.
Figure 8 illustrates that it returns the custom page object you defined in the method
getApplicationFilter applications
The Notion client allows you to filter the data as well. For example, you might want to filter the results by the company name. Thus, you can pass the company name in the URL, and it will only return the job applications for that company.
Write the following code in
controllers.jsconst filterApplications = async (req, res) => {
const data = await notion.databases.query({
database_id: process.env.DB_ID,
filter: {
property: 'Company',
text: {
contains: req.query.company || ''
}
}
});
const pages = data.results.map(page => {
return {
id: page.id,
created: page.created_time,
updated: page.last_edited_time,
company: page.properties.Company.title[0].plain_text,
position: page.properties.Position.select.name,
status: page.properties.Status.select.name,
deadline: page.properties['Next Deadline'].date.start,
jobDescription: page.properties['Job Description'].url,
comments: page.properties.Comments.rich_text[0].plain_text
}
});
return pages;
};This method is similar to the first method -
getAllApplicationsfilterQuerying the database returns a list object that also contains an array called
resultsresultsresultsAs mentioned previously, you filter the results by the company name. If you make a
GEThttp://localhost:3333/job/applications/filter?company=NotionFigure 9 illustrates a
GEThttp://localhost:3333/job/applications/filter?company=Notion?company=NotionAdd a new application
So far, you can:
- retrieve and display all the job applications
- access a specific job application
- filter data by the company name
But you also need to add new job applications, right? Thus, in this step, you build the route for adding new job applications.
First of all, write the following code in
controllers.jsconst addApplication = async (req, res) => {
const newPage = await notion.pages.create({
parent: {
database_id: process.env.DB_ID
},
properties: {
Company: {
title: [
{
text: {
content: req.body.company
}
}
]
},
Position: {
select: {
name: status
}
},
Status: {
select: {
name: req.body.status
}
},
'Next Deadline': {
date: {
start: req.body.deadline
}
},
'Job Description': {
url: req.body.url
},
Comments: {
rich_text: [
{
text: {
content: req.body.comments
}
}
]
}
}
});
return newPage;
};In the above code snippet, you call the
create- database parent - you pass the database parent. You do so by using the database ID from the .env file.
- properties - these properties represent the Notion document fields.
After that, for each property, you add the properties passed in the body of the request. Making a
POST{
"company": "CatalinsTech",
"position": "Technical Writer",
"status": "Applied",
"deadline": "2021-12-12",
"url": "https://catalins.tech",
"comments": "I hope to get the job"
}Adds a new job application to the Notion document. You can see that the job application was added by checking this link.
Figure 10 illustrates the
POSThttp://localhost:3333/job/applicationUpdate existing application
Updating an existing job application is very similar to adding a new one. There are two main differences:
- you use the update method
- you pass the page ID rather than the database ID
You pass the page ID in the URL. For instance, you will make a
PATCH/job/applications/:id:idreq.params.idWrite the following code in the
controllers.jsconst updateApplication = async (req, res) => {
const updatedPage = await notion.pages.update({
page_id: req.params.id,
properties: {
Company: {
title: [
{
text: {
content: req.body.company
}
}
]
},
Position: {
select: {
name: req.body.position
}
},
Status: {
select: {
name: req.body.status
}
},
'Next Deadline': {
date: {
start: req.body.deadline
}
},
'Job Description': {
url: req.body.url
},
Comments: {
rich_text: [
{
text: {
content: req.body.comments
}
}
]
}
}
});
return updatedPage;
};Let's modify the last job application added - to the company
CatalinsTech- status - update it to Signed
- deadline - update it to 2021-05-27
- comments - update it to I got the job
Thus, make a
PATCHhttp://localhost:3333/job/applications/32f1f59b-9176-4b4b-ab52-1ce66a77df25{
"company": "CatalinsTech",
"position": "Technical Writer",
"status": "Signed",
"deadline": "2021-05-27",
"url": "https://catalins.tech",
"comments": "I got the job"
}Figure 11 illustrates the request being successful. The job application was updated, and you can check it here.
Thus, this is how you can update your existing job applications programmatically.
Export the controllers
Before you can use the controllers, you need to export them. The reason why you need to export them is that you use them in the
routes.jsThus, add the end of the file called
controllers.jsmodule.exports = {
getAllApplications,
getApplication,
addApplication,
updateApplication,
filterApplications
};Now you can run the application and play with it!
Check this gist to see the complete controllers.js file.
How to run the application
You can start the application by running
node app.jsOnce you run that, the application should start and you can make HTTP requests.
However, if you clone the application from GitHub, you need to install the dependencies first. You can do so by running:
npm install
node app.jsConclusion
This the end of the tutorial! You build a Node.js API that allows you to:
- Create and update job applications
- Retrieve all job applications
- Access only a specific job application
- Filter the job applications by the company name
Unfortunately, the Notion API does not allow us to delete resources. That is why there is no
DELETECheck the full application code on the GitHub repository.
Previously published at https://catalins.tech/track-job-applications-with-notion-api-nodejs-and-fastifyjs
Create your free account to unlock your custom reading experience.
Recommend
About Joyk
Aggregate valuable and interesting links.
Joyk means Joy of geeK