DB Write-Back Part 4: Build a Standalone JavaScript Program to Query SQL Azure

Querying a database from JavaScript requires us to employ a few new concepts and a library or two. JavaScript was initially designed to render HTML in browsers, but the language has been augmented over time to be capable of doing work on servers as well. Connectivity to a database server is asynchronous and must be executed on the server side.

Before we build a write-back extension, we will build a stand-alone JavaScript web app that queries a SQL Server. This should provide the reader with a simplified code base to build understanding. Once we have that nailed down, we will bring it into our extension.

Configuring Local Machine Infrastructure

To set up the infrastructure specific to this article on your local machine, take the following steps:

  • Create a new part4 directory under the project directory from part1-3.
  • Open a command prompt (terminal) in the new directory.
  • From the command prompt runnpm install express-generator -g

    The -g flag means to do a global rather than local installation. Express generator will quickly create an application skeleton for us, saving a lot of time building files and directories from scratch.

  • Type “express –no-view dbjs” (those are two dashes preceding no-view) … at the command prompt. Express will create a directory called dbjs and a skeleton project within the new directory.

  • Stop the node.js server process that you were running for part 3. We will start a new web server below, and it will source its web content from a different directory structure.

  • Follow the instructions that Express provides (this is for Windows; other platforms will be slightly different):

    change directory:

    > cd dbjs

    install dependencies:

    > npm install

    run the app:

    > npm start

  • Now open a browser to http://localhost:3000 . You should see a simple “Welcome to Express” page.

  • Close the browser page and CTRL+C in the command line to stop the node web server you’ve just tested.

  • We’ll run our node server with nodemon so that we don’t have to restart it manually every time we make a change to our server side code, so in the command line, run:

    npm install nodemon -g

  • We’ll need it in a minute, so install the Microsoft SQL Server client for Node.js by runningnpm install mssql” from the command prompt. NPM (node package manager) is the “world’s largest software library” and this command line utility will install or update whatever libraries you need to use for your project.

We will use SQL Azure as our database. If you do not already have one, follow these instructions to set up a sample database. Don’t forget to create a firewall rule to enable connectivity to the Azure SQL instance from your current network. Also, don’t forget to save that firewall rule once you have it configured. Of course you can use a local or on-premise instance of SQL Server if you would prefer.

Adding Database Query Code

The necessary files can be copied from github to the directory we created in the infrastructure steps above. Place db.js and appDB.js in the javascripts subfolder of the public folder.

Edit the index.html file adding the following appDB.js script source line to the head and adding the following new div to the body.

<!--add this to the head section of index.html-->
<script src="./javascripts/appDB.js"></script> 
<!-- Add this to the bottom of the body of the index.html file-->
<div>
  <span id="result">This text should be replaced with data.</span>
</div>

So index.html will look like this:

<html>

<head>
  <title>Express</title>
  <link rel="stylesheet" href="/stylesheets/style.css">

  <!-- jQuery -->                                                    
  <script src="https://code.jquery.com/jquery-3.3.1.min.js"></script>
  
  <script src="./javascripts/appDB.js"></script>  <!-- NEW  -->
</head>

<body>
  <h1>Express</h1>
  <p>Welcome to Express</p>

  <!-- NEW  -->
  <div>
    <span id="result">This text should be replaced with data.</span>
  </div>

</body>

</html>

Either replace app.js with the one from github or add these lines of JavaScript above the export (last) line:

const db = require("./public/javascripts/db");
app.post("/getData", db.query);

App.js will look like this. All but two lines were automatically created by Express Generator:

var express = require('express');
var path = require('path');
var cookieParser = require('cookie-parser');
var logger = require('morgan');

var indexRouter = require('./routes/index');
var usersRouter = require('./routes/users');

var app = express();

app.use(logger('dev'));
app.use(express.json());
app.use(express.urlencoded({ extended: false }));
app.use(cookieParser());
app.use(express.static(path.join(__dirname, 'public')));

app.use('/', indexRouter);
app.use('/users', usersRouter);

const db = require("./public/javascripts/db");
app.post("/getData", db.query);

module.exports = app;

Rename the credentialsExample.js file to credentials.js, and edit the file to add your credentials and Azure SQL database name.

Now start the app with “nodemon app.js at your command line in the directory of our new web app.

Browse to http://localhost:3000, and if all is configured correctly you should see this:

What have we done here?

The app.js file is used to configure our little web app. A route is used by Express to direct requests. App.js already had routes configured for the root (‘/’, when you browse to localhost:3000) and /users (as in localhost:3000/users) from our initial setup. We don’t have any code implemented to handle a request to /users, so nothing will happen at that url. We added a route for /getData, specifying that when it is called, the code in our db.js file is to be run.

When we browse to http://localhost:3000, our Node server responds by looking up the route for ‘/’, the root of our site, and passing that request to ./routes/index as configured in app.js. This causes the server to load and run ./routes/index.js, which renders index.html to the browser.

The browser receives the index.html document from the server and parses it. From the head section, it invokes appDB.js. The browser retrieves that file from the server and executes it. In the fetchData function of appDB.js, we see fetch(“/getData”… which tells the browser to call back (using a POST request as opposed to a GET request) to the server at the localhost:3000/getData path.

Back on the server line 21 of app.js declares what to do when a POST to /getData is received. It calls the query function in the db.js file. Our connection to the database is from code running on the web server, not from our browser. As you are getting used to this “running on the server” vs “running on the browser” idea, you might insert some console.log(“I’m doing this now”) statements throughout these javascript files. If the code is running on the server, the text will appear on the command line where you started the web server with nodemon app.js. If it is running on the browser, it will appear in the browser’s debug console (CTRL+SHIFT+I on Chrome in Windows), or in the extension debugger if you’re working with an extension.

The db.js file contains our database vendor specific functionality. The code comes from a sample on the mssql npm page. This is where you would swap out the SQL Server specific code for AWS, Google, Oracle, MySQL or other database connectivity code. In this file we are using the mssql package to create a connection pool, send a query, receive the result, and close the connection.

The query result from SQL Server is sent from our Node web server to the appDB.js code still running in our browser. The “.then” syntax below the fetch clause is a way JavaScript works with asynchronous processes like querying a database. The fetchData function parses the result set from JSON into text and updates the value of the “result” HTML tag. On my machine, I can watch the page render and a second later see the “This text should be replaced with data” replaced with our data. We are not worrying about formatting this data at this point, because lazy.

Summary

Writing to a database requires a JavaScript developer to learn a new set of server side skills. In this article we created a connection to and queried a SQL Azure table, outputting the results to a web page.

In part 5, we will take these concepts and add them to the extension concepts from part 3 to make extension that writes back to a database.

DB Write-Back Part 3: Add Tableau Dashboard and Workbook Name List to Extension UI

Let’s show the name of the dashboard and the names of the workbooks within the dashboard in our extension’s page.

Output the Dashboard Name

Create a part3 directory, and create part3a.html and part3.js files within it.

part3a.html:

<!DOCTYPE html>
<html lang="en">
  <head>
    <script src="../lib/tableau.extensions.1.latest.js" defer></script>
        
    <!-- jQuery -->                                                    
    <script src="https://code.jquery.com/jquery-3.2.1.min.js"></script>
    
    <!-- Reference our JavaScript file -->
    <script src="./part3a.js" defer></script>  
    
    <title>TabBlogs.com DB Write-Back Tableau Extension: Soup To Nuts</title>
  </head>
  <body>
    <p id="dashboardName"></p>
  </body>
</html>

In part3a.html, we’ve changed the body of the html page to contain just one element, an empty paragraph with the element id “dashboardName”. If we were to just run this html page without calling part3a.js, it would give us a blank page. We’ll use jQuery in our js file to assign a value to the dashboardName html element.

part3a.js:

tableau.extensions.initializeAsync().then(() => {
    const dashboard = tableau.extensions.dashboardContent.dashboard;
    
    //Use jQuery to select the html element #dashboardName and assign it the name of the Tableau dashboard.
    $('#dashboardName').text('Dashboard name: '+dashboard.name);
});

The constant declaration is simply creating a shorthand variable for the Tableau extension dashboard object.

The “$(‘#dashboardName’)…” line calls the jQuery function (abbreviated “$”) in order to get access to the “dashboardName’ html element in the part3a.html document object. Once we have access to the element, we assign it a string value by concatenating ‘Dashboard name: ‘ and the value of the name property of the dashboard.

Edit your trex file to refer to part3a.html file.

<source-location>
  <url>http:localhost:3000/part3/part3a.html</url>
</source-location> 

Re-load the extension, and you should see this:


Output the Workbook Names in an HTML Table

part3b.html:

<!DOCTYPE html>
<html lang="en">
  <head>
    <script src="../lib/tableau.extensions.1.latest.js" defer></script>
        
    <!-- jQuery -->                                                    
    <script src="https://code.jquery.com/jquery-3.2.1.min.js"></script>
    
    <!-- Reference our JavaScript file -->
    <script src="/part3/part3b.js" defer></script>  
    
    <title>TabBlogs.com DB Write-Back Tableau Extension: Soup To Nuts</title>
  </head>
  <body>
    <p id="dashboardName"></p>
    <table id="worksheets">
      <tbody></tbody>
    </table>
  </body>
</html>

In part3b.html, we’ve added a table with an element id of #worksheets and an empty body.

part3b.js:

tableau.extensions.initializeAsync().then(() => {
    const dashboard = tableau.extensions.dashboardContent.dashboard;
    
    //Use jQuery to select the html element #dashboardName and assign it the name of the Tableau dashboard.
    $('#dashboardName').text('Dashboard name: '+dashboard.name);
    
    dashboard.worksheets.forEach( worksheet => {
      $('#worksheets > tbody').append(`<tr><td>Worksheet: ${worksheet.name}<td><tr>`);
    });
    
});

In part3b.js, we have removed the “I am initialized” line and added a forEach loop that iterates through each worksheet in the dashboard. For each of the worksheets, we call the jQuery function to get access to the #worksheets table’s body. To that we append a new row containing the worksheet name. It’s tough to notice, but in order to use JavaScript ES6 standard template literals (that ${worksheet.name} placeholder in the string we’re appending), we need to wrap the string with backticks rather than single quotes. Absolutely maddening to replicate / debug if you don’t know that.

Edit your trex file to refer to part3b.html file.

<source-location>
  <url>http://localhost:3000/part3/part3b.html</url>
</source-location> 

Re-load the extension, and you should see this:

Formatting

Since the 20th century if not before, web developers have been using cascading style sheets (CSS) to format web pages. The 21st century has brought us Bootstrap, an open source toolkit that shortcuts many CSS formatting tasks.

part3c.html:

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <script src="../lib/tableau.extensions.1.latest.js" defer></script>
        
    <!-- jQuery -->                                                    
    <script src="https://code.jquery.com/jquery-3.3.1.min.js"></script>
    
    <!-- Bootstrap -->
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.4.0/css/bootstrap.min.css" >
    <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.4.0/js/bootstrap.min.js" ></script>
    
    <!-- Reference our JavaScript file -->
    <script src="./part3c.js" defer></script>  
    
    <title>TabBlogs.com DB Write-Back Tableau Extension: Soup To Nuts</title>
  </head>
  <body>
    <p id="dashboardName" class="lead"></p>
    <table id="worksheets" class="table-bordered">
      <tbody></tbody>
    </table>
  </body>
</html>

Part3c.html includes two additional references, a bootstrap css file and a bootstrap JavaScript file. Within the body of part3c.html, we have added class=”lead” to the dashboardName paragraph tag in order to have bootstrap format it for us. We have also added the Bootstrap class table-bordered to the worksheets table.

There are no changes in part3c.js from part3b.js.

Edit your trex file to point to part3c and reload the extension to see the subtle effect that bootstrap has on the format of the extension.

Summary

The Tableau extensions dashboard object gives us programmatic access to the dashboard, worksheets and other aspects of the Tableau environment. This article has walked through the process of accessing some of those attributes and writing them to a web page.

In Part 4, we will step back from extension development and explore SQL Server connectivity from a JavaScript app.

DB Write-Back Part 2: Tableau Debug Mode & Debugger Command Line

Debugging is an essential part of writing any program. Tableau Desktop has a debug mode to enable us to understand what is happening with our extension code. To debug a Tableau extension, the first step is to start Tableau Desktop (first close it if you still have it open from Part 1) in debug mode. It is practical to create a desktop shortcut with this target (if you are using Windows):

“C:\Program Files\Tableau\Tableau 2019.2\bin\tableau.exe” –remote-debugging-port=8696

Obviously, you should replace my path with the path to your current version of Tableau desktop. You can also replace the port (8696) with any other unused port number on your machine.

Now, use your new shortcut to open Tableau Desktop in debug mode. Open the Superstore sample and the overview dashboard again, then open the extension from part 1. Now, open Chrome (or Chromium if you’re not yet using at least Tableau 2019.1, details here) and browse to http://localhost:8696.

Click on the inspectable page you see to start the debugger. Click into the “Console” tab. Any errors that have been raised from your extension will show up here. This console is also interactive. Type

console.log(“Hi!”)

… and the debugger will respond with an enthusiastic greeting. Now let’s try to explore the tableau API. To get a list of the worksheets in this dashboard, type:

tableau.extensions.dashboardContent.dashboard.worksheets

… and the response will be “tableau is not defined”. Woops. We haven’t yet created and initialized a reference to the Tableau Extensions library in our extension web app, so our web app can not yet use the Tableau Extensions API. Tableau doesn’t know what we’re talking about.

Let’s fix that.

Environment Setup

Example Code

The example code for this whole series of articles is posted to github at https://github.com/tabblogs/TableauDBWBExtensionsStN. Feel free to pull that whole thing down to your machine or just look there occasionally for clarity.

Code Editing

You will need an editor. I use Microsoft Visual Studio Code and recommend it. You can add extensions to customize and enhance your experience. You can open a terminal window to run your web server right there in the editor. Great stuff.

Setup Steps

In order to further explore Tableau extensions, you will need to set up a developer environment on your machine.

  • Either create a new directory on your machine, or use the directory you created for part 1. I put mine (on Windows) in …/documents/dev/extensions/.
  • Open a command prompt (terminal) in the new directory.
  • Install NodeJS and NPM. (Windows, Mac, Linux).
  • To verify your installation, type node -v and then npm -v at the command prompt. Node and npm should respond with their respective versions.
  • Install the express JavaScript library: type npm install express at the command prompt.

Create a file called app.js in the same directory. Paste the following JavaScript into app.js:

const express = require("express");
const app = express();
const port = 3000;

app.use(express.static('.'));

//start the server
app.listen(port, function() {
    console.log("Our server is running on " + port);
});

Express ” is a minimal and flexible Node.js web application framework that provides a robust set of features for web and mobile applications. ” We are using it now to configure a simple web server for our local use, and we will use Express in future articles to route requests within our web app.

Node.js is a Javascript run-time environment built on Chrome’s V8 Javascript engine. This article is a great introduction, and throws in some Express intro content as well.

The code in app.js creates an instance of Express, then configures a static route at the root directory of our project (the app.use… line). This means that it will serve anything that we ask for in a browser in the directory structure under our project root directory. The app.listen line starts our web server listening on the port we specified.

  • Start the web server by typing “node app.js” at the command prompt. It should respond with “Our server is running on 3000”
  • If you would like to test your configuration, copy part1.html into the root directory (or in a part1 directory if you would like). Browse to http://localhost:3000/part1.html, and you should see the web page from part 1.
  • Create a directory under the project root directory called part2.
  • Create a file in the part2 directory called part2.html.
<!— Part2.html -->
<!DOCTYPE html>
<html lang="en">
  <head>
    <!-- Tableau API library -->
    <script src="../lib/tableau-extensions-1.latest.js" defer></script>
    
    <!-- jQuery -->                                                    
    <script src="https://code.jquery.com/jquery-3.2.1.min.js"></script>

    <!-- reference our Javascript functions -->
    <script src="/part2/Part2.js" defer></script>  
        
    <title>Extension Quark</title>
  </head>
  <body>
    <p>Referencing the Tableau Extension JavaScript library.</p>
  </body>
</html>

The Part2.html file includes a reference to the Tableau extensions JavaScript library (the first script src=… line). The two periods in ../lib.. indicate that the directory is under the root directory. Download the Tableau Extension library files from https://github.com/tableau/extensions-api/tree/master/lib and place them in a new directory called lib under your root directory. (I have had better luck downloading the whole 337Mb zip file and pulling the libraries from there than downloading them individually.)

The “defer” attribute in the script source tag specifies that the script is executed when the page has finished parsing. Without that attribute, our script will run before the objects it needs to refer to are ready in the html document object model (DOM), and nothing will happen. Frustrating.

Our latest html file also contains a reference to jQuery, “jQuery is a fast, small, and feature-rich JavaScript library. It makes things like HTML document traversal and manipulation, event handling, animation, and Ajax much simpler with an easy-to-use API that works across a multitude of browsers.” Part2.html also contains a reference to part2.js, our first JavaScript file.

Create part2.js in the part2 directory. Part2.js contains just a few lines of code:

tableau.extensions.initializeAsync().then(
  () => {
    $('body').append('<p>Extension library initialized!</p>');
  }
);

Okay, buckle up. The first line initializes the Tableau Extensions API. We need to do that before we can interact with it in the debugger console or anywhere else. It calls the initializeAsync function on the extensions API to load and initialize. The “then” function uses the JavaScript Promises API to enable our code to wait until the Extension library is initialized, then perform an action. Everything we do in JavaScript having to do with extensions will happen within the set of curly braces {} after this “then” function. Also, any Extension API function with a name ending in “Async” must be called with a “then” function. The ()=> is a JavaScript shortcut for function(). The line of code with the {} calls the jQuery function (the $ is an abbreviation for jQuery) to get access to the ‘body’ element of our html page and append an html text paragraph announcing our success.

In order to use part2.html, change your trex file to point to part2.html rather than part1.html.

<source-location>
  <url>http://localhost:3000/part2/part2.html</url>
</source-location>

Here’s a tip to avoid some frustration. Anytime you make a change in a trex file, you need to close and reopen the extension in Tableau Desktop. If you find yourself making changes to your code that aren’t appearing in your extension, you might have changed your trex file and forgotten to close and reopen the extension. In cases where you’ve made code changes, but haven’t needed to change your trex, simply select “reload” from the “more options” down arrow in the controls of your extension window.

Choose reload to check on changes in code within your extension. If you have changed the manifest file (.trex), you will have to close (with the X) and reopen the extension.

Interacting with the Tableau Debug Console

Now, reload the tablogs_writeback.trex extension. Back in Chrome, you’ll need to re-open localhost:8696 because the extension we were debugging was closed.

Let’s ask the API how many worksheets are in the dashboard. Go back to the console at localhost:8696 in your browser and type:

tableau.extensions.dashboardContent.dashboard.worksheets.length

The Tableau extension API will reply (if you’re on the SuperStore Overview dashboard) with “4” because there are four worksheets in that dashboard.

Let’s find out the name of the first worksheet. Type:

tableau.extensions.dashboardContent.dashboard.worksheets[0].name

The Tableau extension API will reply (if you’re on the SuperStore Overview dashboard) with “Sale Map”.

Let’s find out how many individual objects Tableau counts in the dashboard. In the console, type:

tableau.extensions.dashboardContent.dashboard.objects.length

The Tableau extension API will reply (if you’re on the SuperStore Overview dashboard) with “16”.

What size is this dashboard? In the console, type:

tableau.extensions.dashboardContent.dashboard.size

What size is the “Sale Map” worksheet? In the console, type:

tableau.extensions.dashboardContent.dashboard.worksheets[0].size

This is just a peak into the information the Tableau extensions API can provide. Of course it also provides a set of functions (documented here) that enable us to manipulate the objects in the Tableau dashboard.

In part 3 we’ll start looking at the JavaScript that will make our extension a web app.

DB Write-Back Part 1: The Minimal Extension & Manifest File

Let’s start by building the minimal extension – the least possible code that we can call a Tableau extension.

Glitch.com is a site that enables JavaScript development with automated hosting of web pages and JavaScript apps. By using glitch to host part1.html, we’ll avoid setting up a desktop environment for this first baby step. Unfortunately, because the Tableau Extensions JavaScript library has grown past a key file size threshold, and because there is no official CDN for the Tableau extensions library at this point, this is as far as we can go with glitch.

Here’s part1.html:

<!DOCTYPE html>
<html lang="en">
  <head>
    <title>TabBlogs.com DB Write-Back Tableau Extension: How to Write the Code</title>
  </head>
  <body>
    <p>
      <b>Contratulations! </b>
      You've loaded your first extension!
    </p>
    <p>    </p>
    <p>The minimal extension is just a simple html page like this, but we are going well beyond this.</p>
    <p>This extension window is just a web browser using chromium version 61 (as of Tableau Desktop 2019.1).</p>
  </body>
</html> 

The Manifest

To instruct Tableau to open this extension, we will need a manifest file. This is a text file with a specific XML format and a “trex” filename extension. The required element details are:

  • For <dashboard-extension id=” “> use reverse domain name notation to uniquely identify the extension (com.example.extension.hello.demo)
  • For <source-location> make sure that this specifies the URL of your web application. You must use the HTTPS protocol. The exception to this requirement is localhost, where you can use HTTP. For example, if you created a HelloDemo folder and want to host the file locally on your computer using port 8765, you might use: http://localhost:8765/HelloDemo/HelloExtension.html
  • The <min-api-version> element that specifies the minimum version of the Extensions API library that is required to run the extension.
  • For <icon> you must use a Base64-encoded icon. To use the default icon, copy and paste the <icon> example here, or copy one of the manifest files (.trex) from the samples.
  • Provide the name for your extension (Hello Extensions!). The manifest file can be localized, so provide the name (or names) in the appropriate <text> elements in the <resources> section.

Given those details, create a directory in your local machine, and within that directory create an empty file called tabblogs_writeback.trex. Paste the following XML into that file. The file is also available at https://tabblogs-dbwriteback.glitch.me.

<?xml version="1.0" encoding="utf-8"?> 
<manifest manifest-version="0.1" xmlns="http://www.tableau.com/xml/extension_manifest">
  <dashboard-extension id="com.example.extensions.name" extension-version="0.1.0">
    <default-locale>en_US</default-locale>
    <name resource-id="name"/>
    <description>TabBlogs.com extension article series.</description>
    <author name="USERNAME" email="USER@example.com" organization="My Company" website="https://www.example.com"/>
    <min-api-version>1.0</min-api-version>
    <source-location>
      <url>https://tabblogs-dbext-part1.glitch.me/</url> 
    </source-location>
    <icon></icon>
    <permissions>
      <permission>full data</permission>
    </permissions>
  </dashboard-extension>
  <resources>
    <resource id="name">
      <text locale="en_US">name in English</text>
      <text locale="fr_BE">name in French</text>
      <text locale="de_DE">name in German</text>
    </resource>
  </resources>
</manifest>

Now to implement our first extension.

  1. Open Tableau desktop; open the superstore sample to the overview dashboard.
  2. Left click and drag the extension icon from the “Objects” area onto the dashboard. Notice that you can place it on any border between dashboard tiles, under, over or to the side of the whole dashboard, or in a floating tile.
  3. In the “choose an extension” dialog, choose “My Extensions”, navigate to your project directory and choose the tabblogs_writeback.trex file that you created above.
  4. The “Allow Extension” dialog is the only place where you have a chance to (or not to) grant execution permissions to an extension. Notice the four fields from the trex file that are shown here. Technically, our trex file doesn’t need the “permissions” tag, because we’re not accessing any of the APIs that require that tag… yet.
  5. If all has gone right, your extension will load, and you’ll see a simple html page within the extension tile:

Summary

The simplest possible extension is just a plain html web page. The manifest file containing the URL to that page is how Tableau knows what to load. In the next article we will look at the Tableau extension debugging environment and the API that we will use.