Exploring Typesense Features: Lightning-Fast Search Queries in Node.js

Discover the power of Typesense in Node.js for lightning-fast search queries. It’s a handy alternative to Elasticsearch, offering quick results even when dealing with extensive data. This exploration not only covers its key features but also provides practical examples.

You’ll learn how to use Typesense effectively, making your search operations swift and efficient in Node.js. Dive into this guide to enhance your understanding and master Typesense for speedy searches in your applications.

How Does Typesense Work?

You need to register for a Typesense Cloud account and set up a cluster. Within that cluster, create a collection containing the data you wish to query.

By using the Typesense npm package, you can seamlessly integrate TypeSense into Node.js after setting up a cluster and a collection.

Typesense Features

➡️ Search as you type and get results.
➡️ Query search.
➡️ Multiple search queries over a single HTTP call (You can perform various searches in a single HTTP call rather than querying db for every query).
➡️ Updating documents in bulk.
➡️ Pagination and offset support.
➡️ Comes with batteries included (You do not have to spend a lot of time configuring it).

Let’s try to understand Typesense with an example. Before we move forward with the example, please create an account Typesense. After signing up, you’ll see a page for forming a cluster; just click the launch button to do so.

Once the cluster is created click on Generate API keys, and save them we will need them in the future.

Typesense Example

For example, we’ll use Typesense to create the Crud Rest API. We will be using Typesense, dotenv, and express packages for this example.

✅ Open the VS Code terminal and install the following packages.

Npm install express typesense dotenv

✅ Let’s enable TypeScript for our example, for that run the following command.

tsc --init

✅ Open the tsconfig.json file and paste the following code.

{
"compilerOptions": {
"target": "ES2020",
"module": "commonjs",
"lib": ["ES2020"],
"allowJs": true,
"outDir": "dist",
"rootDir": "src",
"strict": true,
"noImplicitAny": false,
"esModuleInterop": true,
"resolveJsonModule": true,
"experimentalDecorators": true,
"emitDecoratorMetadata": true,
"strictPropertyInitialization": false,
"declaration": true
}
}

✅ Create the Typesense client function, we will use this function to communicate with the Typesense cloud. You need to add your host and API key. We generated the keys in the beginning.

import Typesense from "typesense";

export const typesenseClient = new Typesense.Client({
nodes: [
{
host: "<nodes>",
port: 443,
protocol: "https",
},
],
apiKey: "<admin key>",
connectionTimeoutSeconds: 1200,
});

✅ Create a src folder in the root and inside the src folder create an index.ts file and paste the following code.

import express from "express";
import dotenv from "dotenv";
import { typesenseClient } from "./utils/typesenseClient";

dotenv.config();
const app = express();

function startServer() {
app.use(express.urlencoded({ extended: true }));
app.use(express.json());

/** Routes */
app.post("/create-schema", async (req, res, next) => {
try {
const data = await typesenseClient.collections().create(req.body);
res.status(200).json({ message: "Schema created", data: data });
} catch (error) {
res.status(500);
}
});

app.post("/create", async (req, res, next) => {
try {
const data = await typesenseClient
.collections(req.body.collectionName)
.documents()
.import(req.body.document, { action: "emplace" });
res.status(200).json({ message: "Employee added", data: data });
} catch (error) {
res.status(500);
}
});

app.get("/get-employees", async (req, res, next) => {
try {
const data = await typesenseClient
.collections(req.query.collectionName)
.documents()
.search({ q: req.query.q, query_by: req.query.query_by });
res.status(200).json({ message: "Success", data: data?.hits });
} catch (error) {}
});

app.patch("/update-employees", async (req, res, next) => {
try {
const data = await typesenseClient
.collections(req.body.collectionName)
.documents(req.body.id)
.update(req.body.document);
res.status(200).json({ message: "Record updated", data: data });
} catch (error) {}
});

app.delete("/delete-employees", async (req, res, next) => {
try {
const data = await typesenseClient
.collections(req.body.collectionName)
.documents(req.body.id)
.delete();
res.status(200).json({ message: "Record deleted", data: data });
} catch (error) {}
});

app.listen(process.env.PORT, () => {
console.log(`Server running on port-->${process.env.PORT}`);
});
}

startServer();

We have created the following endpoints:

• /create-schema: this endpoint will create the collection on the Typesense cloud.

“Emp_v1” is the name of the collection and the fields array consists of the fields that will be created inside the “emp_v1” collection.

• /create: This endpoint will add one or multiple employees to our Typensense cloud.

• /get-employees: This endpoint will help you query the Typensense cloud and get the desired results.

This will return me the records with the name “Rohit”.

• /update-employees: This endpoint will update single employee details, you need to pass the ID of that employee and collection name.

• /delete-employees: This endpoint will delete a single employee, you need to pass the ID of that employee and collection name.

We barely touched the surface of what Typesense can accomplish when creating these basic, crude rest apis using node. I highly recommend checking out the Typesense documentation for more advanced subjects. I hope this blog was helpful.