Embedding the MongoDB Connector into the server

This tutorial describes how to embed Flexmonster MongoDB Connector into a Node.js server.

Alternatively, you can run our ready-to-use sample project.

Prerequisites

• Node.js
• An application with Flexmonster embedded into it.
  You can integrate Flexmonster with JavaScript or with a framework of your choice.

Step 1. (optional) Create a simple server

If you already have a server, skip this step.

Follow the steps below to create a server application using Express.js:

Step 1.1. Create a folder, navigate to it, and run the following command in the console to generate the package.json file:

npm init

Step 1.2. Install the express, cors, and body-parser packages from npm:

npm install express cors body-parser

Step 1.3. Then, create a simple server in a .js file (e.g., server.js). Your code should look similar to the following:

const express = require("express");
const cors = require("cors");
const bodyParser = require("body-parser");

const app = express();

// Enable CORS if Flexmonster Pivot is running on a different server
app.use(cors());
app.use(bodyParser.json());

let port = 9204;
app.listen(port, () => {
  console.log(`The server is listening at http://localhost:${port}`)
});

Step 2. Install packages for working with MongoDB

Install Flexmonster MongoDB Connector and the MongoDB driver:

npm install flexmonster-mongo-connector mongodb@4.17.2

Note Ensure you have installed MongoDB version 4.17.2 or earlier, as our Connector is not compatible with the later MongoDB versions.

Step 3. Create and configure a module for the Flexmonster’s requests

Step 3.1. Create a module that will handle the Flexmonster’s requests. In this tutorial, we will create the module in a mongo.js file.

Step 3.2. Include the following libraries in mongo.js:

const { MongoClient } = require("mongodb");
const fm_mongo_connector = require("flexmonster-mongo-connector");

Step 3.3. Set up a connection with your MongoDB database:

// Connection string to the Flexmonster’s cluster
const uri = "mongodb://read:only@olap.flexmonster.com:27017"
const client = new MongoClient(uri);
let database = null; // The database instance

async function connectDB() {
  try {
    await client.connect();
    // Flexmonster’s sample database
    database = client.db("flexmonster");
    } catch (err) {
    // Your error handler
  }
}

connectDB();

Step 3.4. Create the MongoDB Connector instance:

let mongoConnector= null; // The Connector instance

// The Connector’s configurations
const config = {
  cacheEnabled: true,
  cacheMemoryLimit: 100,
  cacheTimeToLive: 120,
  logsEnabled: true
};

async function connectDB() {
  try {
    await client.connect();
    // Flexmonster’s sample database
    database = client.db("flexmonster");
    mongoConnector = new fm_mongo_connector.MongoDataAPI(config);
  } catch (err) {
    // Your error handler
  }
}

connectDB();

To learn more about the Connector’s config, see the Configuring the Connector guide.

Step 3.5. Export the mongo module so the server can use it:

module.exports = mongo;

Step 3.6. Include the mongo.js module into your server (e.g., server.js):

app.use('/mongo', require('./mongo.js'));

Now, when Flexmonster starts sending requests to <server_url/mongo>, they will be processed by mongo.js.

In the next steps, we will handle all Flexmonster requests.

Step 4. Create endpoints

The mongo module must provide the endpoints that handle POST requests from Flexmonster.

Flexmonster sends 4 types of requests:

• /handshake request
• /fields request
• /members request
• /select request for the pivot table, the flat table, and the drill-through view

In the mongo.js file, create the endpoints for the requests using Express.js:

const mongo = require('express').Router();
// Other code

mongo.post("/handshake", async (req, res) => {});
mongo.post("/fields", async (req, res) => {});
mongo.post("/members", async (req, res) => {});
mongo.post("/select", async (req, res) => {});

As you can see, the request's name corresponds to its endpoint. For example, all /select requests are sent to the /select endpoint.

In the next steps, you will learn how to handle each request.

Step 5. Handle the /handshake request

First, Flexmonster sends the /handshake request to establish communication with the server. The component includes its version in the request and expects a response with the custom data source API version implemented by the server.

In mongo.js, handle the /handshake request. Your code should look similar to the following:

mongo.post("/handshake", async (req, res) => {
  try {
    res.json({ version: mongoConnector.API_VERSION });
  } catch (err) {
    // Your error handler
  }
});

mongoConnector.API_VERSION contains the custom data source API version implemented by the MongoDB Connector.

Step 6. Handle the /fields request

Now you need to handle a /fields request. It is sent to <url>/fields. 

To handle this request, use the getSchema method:

mongo.post("/fields", async (req, res) => {
  try {
    const result = await mongoConnector.getSchema(database, req.body.index);
    res.json(result);
  } catch (err) {
    // Your error handler
  }
});

When Flexmonster Pivot successfully receives a response to the /fields request, it shows the Field List with all of the available fields.

Step 7. Handle the /members request

The next request to handle is the request for the field’s members that is sent to <url>/members.

Ways to handle the /members request depend on whether multilevel hierarchies are configured on the client or not.

mongo.post("/members", async (req, res) => {
  try {
    const result = await mongoConnector.getMembers(
      database,
      req.body.index, 
      { field: req.body.field }, 
      { page: req.body.page, pageToken: req.body.pageToken }
    );
    res.json(result);
  } catch (err) {
    // Your error handler
  }
});

mongo.post("/members", async (req, res) => {
  try {
    const result = await mongoConnector.getMembers(
      database,
      req.body.index, 
      { field: req.body.field, filter: req.body.filter },
      { page: req.body.page, pageToken: req.body.pageToken }
    );
    res.json(result);
  } catch (err) {
    // Your error handler
  }
});

{ field: req.body.field, filter: req.body.filter },

When Flexmonster Pivot successfully receives the response to this request, you will be able to select a string field for rows or columns and retrieve its members.

Step 8. Handle the /select request

When a field is selected for rows or columns and a numeric field is selected for measures in the Field List, the /select request for the pivot table is sent to the endpoint <url>/select. It can be handled using the getSelectResult method:

mongo.post("/select", async (req, res) => {
  try {
    const result = await mongoConnector.getSelectResult(
      database, req.body.index, req.body.query,
      { page: req.body.page, pageToken: req.body.pageToken });
    res.json(result);
  } catch (err) {
     // Your error handler
  }
});

When Flexmonster successfully receives the response to this kind of /select request, a pivot table with the received data is shown.

Note The /select requests for the flat table and the drill-through view can also be handled using the getSelectResult method.

Step 9. Run the server

Run your server with the following command:

node server.js

Step 10. Configure the report

In Flexmonster, the report should be configured as follows:

const pivot = new Flexmonster({
  container: "pivotContainer",
  toolbar: true,
  report: {
    dataSource: {
      type: "api",
      url: "http://localhost:9204/mongo"), // A path to API endpoints
      index: "fm-product-sales" // Flexmonster’s collection name
    }
  }
});

Check out the full list of Flexmonster properties used to connect to MongoDB.

To see Flexmonster with the data from your MongoDB database, open a page with Flexmonster in the browser.

List of supported configuration parameters

When connecting to data from the MongoDB, you can use the following properties to configure the DataSourceObject:

See also

• Configure the MongoDB Connector
• Configure which data subset is shown
• Specify functionality available to users
• Define number formatting
• Define a format for date and time