How to use the azure-storage.createTableService function in azure-storage

var iotHubClient = ServiceClient.fromConnectionString(iotHubConnString);

// event hub alerts
var alerts = [];
var ehclient = EventHubClient.fromConnectionString(ehConnString, eventHubName)
ehclient.createReceiver('$Default', '0', { startAfterTime: Date.now() })
    .then(function(rx) {
        rx.on('errorReceived', function(err) { console.log(err); });
        rx.on('message', function(message) {
            alerts.push(message.body);
            alerts = alerts.slice(-5); // keep last 5
        });
    });

// table storage
var tableSvc = azure.createTableService(storageAcountName, storageAccountKey);
tableSvc.createTableIfNotExists(storageTable, function(err, result, response) {
    if (err) {
        console.log('error looking up table');
        console.log(err)
    }
});

// website setup
var app = express();
var port = nconf.get('port');
app.use(express.static('public'));
app.use(express.static('bower_components'));
app.use(bodyParser.json());

// app api
app.get('/api/alerts', function(req, res) {

InsertOrReplaceSiteDefinition(siteDefintion, callback){
    let tableService = azureStorage.createTableService();
    const tableEnity = Object.assign({}, siteDefintion, {
      defaultLocation: JSON.stringify(siteDefintion.defaultLocation),
      targetBbox: JSON.stringify(siteDefintion.targetBbox),
      supportedLanguages: JSON.stringify(siteDefintion.supportedLanguages),
      PartitionKey: AZURE_TBL_SITES_PARTITION_KEY,
      RowKey: siteDefintion.name
    });

    tableService.createTableIfNotExists(AZURE_TBL_SITES, (error, result, response) => { // eslint-disable-line no-unused-vars
      if(!error){
        tableService.insertOrReplaceEntity(AZURE_TBL_SITES, tableEnity, (error2, result, response) => { // eslint-disable-line no-unused-vars
          if(!error2){
            FetchSiteDefinitions(siteDefintion.name, tableService, callback);
          }else{
            callback(`There was an error writing to table [${AZURE_TBL_SITES}] with definition[${JSON.stringify(tableEnity)}]`);
          }

'use strict'
var azure = require('azure-storage');
var tableSvc = azure.createTableService();

var vehicle = {
  vehicleDetails: function(agency, id) {
    let offset = 0
    // id's don't map one to one, so we have to transform
    if (agency === 'nzbgw' || agency === 'nzbwp' || agency === 'nzbml' || agency === 'nzbns') {
      agency = 'nzb'
      offset = 10000
    } else if (agency === 'rth') {
      offset = 21000
    } else if (agency === 'btl') {
      offset = 21000
    } else if (agency === 'ue') {
      offset = 23000
    } else if (agency === 'he') {
      offset = 24000

private createTableService(storageAccountOrConnectionString: string, storageAccessKey: string, host: any): TableServiceAsync {
        const tableService = storageAccountOrConnectionString ? azure.createTableService(storageAccountOrConnectionString, storageAccessKey, host) : azure.createTableService();

        // create TableServiceAsync by using denodeify to create promise wrappers around cb functions
        return {
            createTableIfNotExistsAsync: this.denodeify(tableService, tableService.createTableIfNotExists),
            deleteTableIfExistsAsync: this.denodeify(tableService, tableService.deleteTableIfExists),
            retrieveEntityAsync: this.denodeify(tableService, tableService.retrieveEntity),
            insertOrReplaceEntityAsync: this.denodeify(tableService, tableService.insertOrReplaceEntity),
            replaceEntityAsync: this.denodeify(tableService, tableService.replaceEntity),
            deleteEntityAsync: this.denodeify(tableService, tableService.deleteEntity)
        } as any;
    }

it("should retrieve all Entities", (done) => {
      const query = new azureStorage.TableQuery();
      const retrievalTableService = azureStorage.createTableService(
        "UseDevelopmentStorage=true"
      );
      retrievalTableService.queryEntities(tableName, query, null, function(
        error,
        results,
        response
      ) {
        expect(error).to.equal(null);
        expect(results.entries.length).to.equal(2);
        const sortedResults = results.entries.sort();
        expect(sortedResults[0].description._).to.equal(
          tableEntity1.description._
        );
        expect(sortedResults[1].description._).to.equal(
          tableEntity2.description._
        );

function missingEntityFindTest(cb) {
      const query = new azureStorage.TableQuery()
        .top(5)
        .where("RowKey eq ?", "unknownRowKeyForFindError");
      const faillingFindTableService = azureStorage.createTableService(
        "UseDevelopmentStorage=true"
      );
      faillingFindTableService.queryEntities(tableName, query, null, function(
        error,
        result,
        response
      ) {
        expect(error.message).to.equal(EntityNotFoundErrorMessage);
        expect(response.statusCode).to.equal(404);
        cb();
      });
    }
  });

let azure = require('azure-storage')
let uuid = require('uuid/v4')
let readline = require('readline')
let util = require('util')
let async = require('async')

const answersTable = 'answersQueryPerfTest'
let tableSvc = azure.createTableService()

function insertData(done) {

  tableSvc.createTableIfNotExists(answersTable, function (error, result, response) {
    if (error) {
      done(error)
    } else {
      var batches = createBatches()
      async.eachOf(batches, function (batch, index, callback) {
        tableSvc.executeBatch(answersTable, batch, function (error, result, response) {
          if (error) {
            return callback(error)
          }
          else {
            console.log('batch %s inserted successfully', index)
            callback()

const bodyParser = require('body-parser');
const connect_ensure_login = require('connect-ensure-login');
const cookieParser = require('cookie-parser');
const express = require('express');
const expressSession = require('express-session');
const passport = require('passport');
const passportGithub = require('passport-github');
const path = require('path');
const NodeCache = require('node-cache');
const model = require('./src/model');

const blobServiceConnectionString = process.env.BLOB_SERVICE_CONNECTION_STRING;
const blobService = azureStorage.createBlobService(blobServiceConnectionString);

const tableServiceConnectionString = process.env.TABLE_SERVICE_CONNECTION_STRING;
const tableService = azureStorage.createTableService(tableServiceConnectionString);

const queueServiceConnectionString = process.env.QUEUE_SERVICE_CONNECTION_STRING;
const queueService = azureStorage.createQueueService(queueServiceConnectionString);

const accessRightsCache = new NodeCache({ stdTTL: 100, checkperiod: 120 });
const accessRightsService = new model.AccessRightsService(tableService, accessRightsCache);

passport.use(new passportGithub.Strategy(
  {
    clientID: process.env.GITHUB_CLIENT,
    clientSecret: process.env.GITHUB_SECRET,
    callbackURL: `${process.env.VOTT_HOSTNAME}/auth/github/callback`
  },
  (accessToken, refreshToken, profile, cb) => {
    return cb(null, profile);
  }

function createTableService(account, key) {
  factoryLogger.info(`creating table service`);
  const retryOperations = new AzureStorage.ExponentialRetryPolicyFilter();
  return AzureStorage.createTableService(account, key).withFilter(retryOperations);
}

constructor() {
    this._storageService = azureStorageService.createTableService();
  }