Build a Node.js App with CockroachDB

This tutorial shows you how build a simple Node.js application with CockroachDB using a PostgreSQL-compatible driver or ORM.

We have tested the Node.js pg driver and the Sequelize ORM enough to claim beta-level support, so those are featured here. If you encounter problems, please open an issue with details to help us make progress toward full support.

Before you begin

Step 1. Install Node.js packages

To let your application communicate with CockroachDB, install the Node.js pg driver:

  1. $ npm install pg

The example app on this page also requires async:

  1. $ npm install async

Step 2. Create the maxroach user and bank database

Start the built-in SQL client:

  1. $ cockroach sql --certs-dir=certs

In the SQL shell, issue the following statements to create the maxroach user and bank database:

  1. > CREATE USER IF NOT EXISTS maxroach;
  1. > CREATE DATABASE bank;

Give the maxroach user the necessary permissions:

  1. > GRANT ALL ON DATABASE bank TO maxroach;

Exit the SQL shell:

  1. > \q

Step 3. Generate a certificate for the maxroach user

Create a certificate and key for the maxroach user by running the following command. The code samples will run as this user.

  1. $ cockroach cert create-client maxroach --certs-dir=certs --ca-key=my-safe-directory/ca.key

Step 4. Run the Node.js code

Now that you have a database and a user, you'll run code to create a table and insert some rows, and then you'll run code to read and update values as an atomic transaction.

Basic statements

First, use the following code to connect as the maxroach user and execute some basic SQL statements, creating a table, inserting rows, and reading and printing the rows.

Download the basic-sample.js file, or create the file yourself and copy the code into it.

  1. var async = require('async');
  2. var fs = require('fs');
  3. var pg = require('pg');
  5. // Connect to the "bank" database.
  6. var config = {
  7.     user: 'maxroach',
  8.     host: 'localhost',
  9.     database: 'bank',
  10.     port: 26257,
  11.     ssl: {
  12.         ca: fs.readFileSync('certs/ca.crt')
  13.             .toString(),
  14.         key: fs.readFileSync('certs/client.maxroach.key')
  15.             .toString(),
  16.         cert: fs.readFileSync('certs/client.maxroach.crt')
  17.             .toString()
  18.     }
  19. };
  21. // Create a pool.
  22. var pool = new pg.Pool(config);
  24. pool.connect(function (err, client, done) {
  26.     // Close communication with the database and exit.
  27.     var finish = function () {
  28.         done();
  29.         process.exit();
  30.     };
  32.     if (err) {
  33.         console.error('could not connect to cockroachdb', err);
  34.         finish();
  35.     }
  36.     async.waterfall([
  37.             function (next) {
  38.                 // Create the 'accounts' table.
  39.                 client.query('CREATE TABLE IF NOT EXISTS accounts (id INT PRIMARY KEY, balance INT);', next);
  40.             },
  41.             function (results, next) {
  42.                 // Insert two rows into the 'accounts' table.
  43.                 client.query('INSERT INTO accounts (id, balance) VALUES (1, 1000), (2, 250);', next);
  44.             },
  45.             function (results, next) {
  46.                 // Print out account balances.
  47.                 client.query('SELECT id, balance FROM accounts;', next);
  48.             },
  49.         ],
  50.         function (err, results) {
  51.             if (err) {
  52.                 console.error('Error inserting into and selecting from accounts: ', err);
  53.                 finish();
  54.             }
  56.             console.log('Initial balances:');
  57.             results.rows.forEach(function (row) {
  58.                 console.log(row);
  59.             });
  61.             finish();
  62.         });
  63. });

Then run the code:

  1. $ node basic-sample.js

The output should be:

  1. Initial balances:
  2. { id: '1', balance: '1000' }
  3. { id: '2', balance: '250' }

Transaction (with retry logic)

Next, use the following code to again connect as the maxroach user but this time execute a batch of statements as an atomic transaction to transfer funds from one account to another and then read the updated values, where all included statements are either committed or aborted.

Download the txn-sample.js file, or create the file yourself and copy the code into it.

Note:

With the default SERIALIZABLE isolation level, CockroachDB may require the client to retry a transaction in case of read/write contention. CockroachDB provides a generic retry function that runs inside a transaction and retries it as needed. The code sample below shows how it is used.

  1. var async = require('async');
  2. var fs = require('fs');
  3. var pg = require('pg');
  5. // Connect to the bank database.
  7. var config = {
  8.     user: 'maxroach',
  9.     host: 'localhost',
  10.     database: 'bank',
  11.     port: 26257,
  12.     ssl: {
  13.         ca: fs.readFileSync('certs/ca.crt')
  14.             .toString(),
  15.         key: fs.readFileSync('certs/client.maxroach.key')
  16.             .toString(),
  17.         cert: fs.readFileSync('certs/client.maxroach.crt')
  18.             .toString()
  19.     }
  20. };
  22. // Wrapper for a transaction.  This automatically re-calls "op" with
  23. // the client as an argument as long as the database server asks for
  24. // the transaction to be retried.
  26. function txnWrapper(client, op, next) {
  27.     client.query('BEGIN; SAVEPOINT cockroach_restart', function (err) {
  28.         if (err) {
  29.             return next(err);
  30.         }
  32.         var released = false;
  33.         async.doWhilst(function (done) {
  34.                 var handleError = function (err) {
  35.                     // If we got an error, see if it's a retryable one
  36.                     // and, if so, restart.
  37.                     if (err.code === '40001') {
  38.                         // Signal the database that we'll retry.
  39.                         return client.query('ROLLBACK TO SAVEPOINT cockroach_restart', done);
  40.                     }
  41.                     // A non-retryable error; break out of the
  42.                     // doWhilst with an error.
  43.                     return done(err);
  44.                 };
  46.                 // Attempt the work.
  47.                 op(client, function (err) {
  48.                     if (err) {
  49.                         return handleError(err);
  50.                     }
  51.                     var opResults = arguments;
  53.                     // If we reach this point, release and commit.
  54.                     client.query('RELEASE SAVEPOINT cockroach_restart', function (err) {
  55.                         if (err) {
  56.                             return handleError(err);
  57.                         }
  58.                         released = true;
  59.                         return done.apply(null, opResults);
  60.                     });
  61.                 });
  62.             },
  63.             function () {
  64.                 return !released;
  65.             },
  66.             function (err) {
  67.                 if (err) {
  68.                     client.query('ROLLBACK', function () {
  69.                         next(err);
  70.                     });
  71.                 } else {
  72.                     var txnResults = arguments;
  73.                     client.query('COMMIT', function (err) {
  74.                         if (err) {
  75.                             return next(err);
  76.                         } else {
  77.                             return next.apply(null, txnResults);
  78.                         }
  79.                     });
  80.                 }
  81.             });
  82.     });
  83. }
  85. // The transaction we want to run.
  87. function transferFunds(client, from, to, amount, next) {
  88.     // Check the current balance.
  89.     client.query('SELECT balance FROM accounts WHERE id = $1', [from], function (err, results) {
  90.         if (err) {
  91.             return next(err);
  92.         } else if (results.rows.length === 0) {
  93.             return next(new Error('account not found in table'));
  94.         }
  96.         var acctBal = results.rows[0].balance;
  97.         if (acctBal >= amount) {
  98.             // Perform the transfer.
  99.             async.waterfall([
  100.                 function (next) {
  101.                     // Subtract amount from account 1.
  102.                     client.query('UPDATE accounts SET balance = balance - $1 WHERE id = $2', [amount, from], next);
  103.                 },
  104.                 function (updateResult, next) {
  105.                     // Add amount to account 2.
  106.                     client.query('UPDATE accounts SET balance = balance + $1 WHERE id = $2', [amount, to], next);
  107.                 },
  108.                 function (updateResult, next) {
  109.                     // Fetch account balances after updates.
  110.                     client.query('SELECT id, balance FROM accounts', function (err, selectResult) {
  111.                         next(err, selectResult ? selectResult.rows : null);
  112.                     });
  113.                 }
  114.             ], next);
  115.         } else {
  116.             next(new Error('insufficient funds'));
  117.         }
  118.     });
  119. }
  121. // Create a pool.
  122. var pool = new pg.Pool(config);
  124. pool.connect(function (err, client, done) {
  125.     // Closes communication with the database and exits.
  126.     var finish = function () {
  127.         done();
  128.         process.exit();
  129.     };
  131.     if (err) {
  132.         console.error('could not connect to cockroachdb', err);
  133.         finish();
  134.     }
  136.     // Execute the transaction.
  137.     txnWrapper(client,
  138.         function (client, next) {
  139.             transferFunds(client, 1, 2, 100, next);
  140.         },
  141.         function (err, results) {
  142.             if (err) {
  143.                 console.error('error performing transaction', err);
  144.                 finish();
  145.             }
  147.             console.log('Balances after transfer:');
  148.             results.forEach(function (result) {
  149.                 console.log(result);
  150.             });
  152.             finish();
  153.         });
  154. });

Then run the code:

  1. $ node txn-sample.js

The output should be:

  1. Balances after transfer:
  2. { id: '1', balance: '900' }
  3. { id: '2', balance: '350' }

To verify that funds were transferred from one account to another, start the built-in SQL client:

  1. $ cockroach sql --certs-dir=certs --database=bank

To check the account balances, issue the following statement:

  1. > SELECT id, balance FROM accounts;
  1. +----+---------+
  2. | id | balance |
  3. +----+---------+
  4. |  1 |     900 |
  5. |  2 |     350 |
  6. +----+---------+
  7. (2 rows)

Step 2. Create the maxroach user and bank database

Start the built-in SQL client:

  1. $ cockroach sql --insecure

In the SQL shell, issue the following statements to create the maxroach user and bank database:

  1. > CREATE USER IF NOT EXISTS maxroach;
  1. > CREATE DATABASE bank;

Give the maxroach user the necessary permissions:

  1. > GRANT ALL ON DATABASE bank TO maxroach;

Exit the SQL shell:

  1. > \q

Step 3. Run the Node.js code

Now that you have a database and a user, you'll run code to create a table and insert some rows, and then you'll run code to read and update values as an atomic transaction.

Basic statements

First, use the following code to connect as the maxroach user and execute some basic SQL statements, creating a table, inserting rows, and reading and printing the rows.

Download the basic-sample.js file, or create the file yourself and copy the code into it.

  1. var async = require('async');
  2. var fs = require('fs');
  3. var pg = require('pg');
  5. // Connect to the "bank" database.
  6. var config = {
  7.     user: 'maxroach',
  8.     host: 'localhost',
  9.     database: 'bank',
  10.     port: 26257
  11. };
  13. // Create a pool.
  14. var pool = new pg.Pool(config);
  16. pool.connect(function (err, client, done) {
  18.     // Close communication with the database and exit.
  19.     var finish = function () {
  20.         done();
  21.         process.exit();
  22.     };
  24.     if (err) {
  25.         console.error('could not connect to cockroachdb', err);
  26.         finish();
  27.     }
  28.     async.waterfall([
  29.             function (next) {
  30.                 // Create the 'accounts' table.
  31.                 client.query('CREATE TABLE IF NOT EXISTS accounts (id INT PRIMARY KEY, balance INT);', next);
  32.             },
  33.             function (results, next) {
  34.                 // Insert two rows into the 'accounts' table.
  35.                 client.query('INSERT INTO accounts (id, balance) VALUES (1, 1000), (2, 250);', next);
  36.             },
  37.             function (results, next) {
  38.                 // Print out account balances.
  39.                 client.query('SELECT id, balance FROM accounts;', next);
  40.             },
  41.         ],
  42.         function (err, results) {
  43.             if (err) {
  44.                 console.error('Error inserting into and selecting from accounts: ', err);
  45.                 finish();
  46.             }
  48.             console.log('Initial balances:');
  49.             results.rows.forEach(function (row) {
  50.                 console.log(row);
  51.             });
  53.             finish();
  54.         });
  55. });

Then run the code:

  1. $ node basic-sample.js

The output should be:

  1. Initial balances:
  2. { id: '1', balance: '1000' }
  3. { id: '2', balance: '250' }

Transaction (with retry logic)

Next, use the following code to again connect as the maxroach user but this time execute a batch of statements as an atomic transaction to transfer funds from one account to another and then read the updated values, where all included statements are either committed or aborted.

Download the txn-sample.js file, or create the file yourself and copy the code into it.

Note:

With the default SERIALIZABLE isolation level, CockroachDB may require the client to retry a transaction in case of read/write contention. CockroachDB provides a generic retry function that runs inside a transaction and retries it as needed. The code sample below shows how it is used.

  1. var async = require('async');
  2. var fs = require('fs');
  3. var pg = require('pg');
  5. // Connect to the bank database.
  7. var config = {
  8.     user: 'maxroach',
  9.     host: 'localhost',
  10.     database: 'bank',
  11.     port: 26257
  12. };
  14. // Wrapper for a transaction.  This automatically re-calls "op" with
  15. // the client as an argument as long as the database server asks for
  16. // the transaction to be retried.
  18. function txnWrapper(client, op, next) {
  19.     client.query('BEGIN; SAVEPOINT cockroach_restart', function (err) {
  20.         if (err) {
  21.             return next(err);
  22.         }
  24.         var released = false;
  25.         async.doWhilst(function (done) {
  26.                 var handleError = function (err) {
  27.                     // If we got an error, see if it's a retryable one
  28.                     // and, if so, restart.
  29.                     if (err.code === '40001') {
  30.                         // Signal the database that we'll retry.
  31.                         return client.query('ROLLBACK TO SAVEPOINT cockroach_restart', done);
  32.                     }
  33.                     // A non-retryable error; break out of the
  34.                     // doWhilst with an error.
  35.                     return done(err);
  36.                 };
  38.                 // Attempt the work.
  39.                 op(client, function (err) {
  40.                     if (err) {
  41.                         return handleError(err);
  42.                     }
  43.                     var opResults = arguments;
  45.                     // If we reach this point, release and commit.
  46.                     client.query('RELEASE SAVEPOINT cockroach_restart', function (err) {
  47.                         if (err) {
  48.                             return handleError(err);
  49.                         }
  50.                         released = true;
  51.                         return done.apply(null, opResults);
  52.                     });
  53.                 });
  54.             },
  55.             function () {
  56.                 return !released;
  57.             },
  58.             function (err) {
  59.                 if (err) {
  60.                     client.query('ROLLBACK', function () {
  61.                         next(err);
  62.                     });
  63.                 } else {
  64.                     var txnResults = arguments;
  65.                     client.query('COMMIT', function (err) {
  66.                         if (err) {
  67.                             return next(err);
  68.                         } else {
  69.                             return next.apply(null, txnResults);
  70.                         }
  71.                     });
  72.                 }
  73.             });
  74.     });
  75. }
  77. // The transaction we want to run.
  79. function transferFunds(client, from, to, amount, next) {
  80.     // Check the current balance.
  81.     client.query('SELECT balance FROM accounts WHERE id = $1', [from], function (err, results) {
  82.         if (err) {
  83.             return next(err);
  84.         } else if (results.rows.length === 0) {
  85.             return next(new Error('account not found in table'));
  86.         }
  88.         var acctBal = results.rows[0].balance;
  89.         if (acctBal >= amount) {
  90.             // Perform the transfer.
  91.             async.waterfall([
  92.                 function (next) {
  93.                     // Subtract amount from account 1.
  94.                     client.query('UPDATE accounts SET balance = balance - $1 WHERE id = $2', [amount, from], next);
  95.                 },
  96.                 function (updateResult, next) {
  97.                     // Add amount to account 2.
  98.                     client.query('UPDATE accounts SET balance = balance + $1 WHERE id = $2', [amount, to], next);
  99.                 },
  100.                 function (updateResult, next) {
  101.                     // Fetch account balances after updates.
  102.                     client.query('SELECT id, balance FROM accounts', function (err, selectResult) {
  103.                         next(err, selectResult ? selectResult.rows : null);
  104.                     });
  105.                 }
  106.             ], next);
  107.         } else {
  108.             next(new Error('insufficient funds'));
  109.         }
  110.     });
  111. }
  113. // Create a pool.
  114. var pool = new pg.Pool(config);
  116. pool.connect(function (err, client, done) {
  117.     // Closes communication with the database and exits.
  118.     var finish = function () {
  119.         done();
  120.         process.exit();
  121.     };
  123.     if (err) {
  124.         console.error('could not connect to cockroachdb', err);
  125.         finish();
  126.     }
  128.     // Execute the transaction.
  129.     txnWrapper(client,
  130.         function (client, next) {
  131.             transferFunds(client, 1, 2, 100, next);
  132.         },
  133.         function (err, results) {
  134.             if (err) {
  135.                 console.error('error performing transaction', err);
  136.                 finish();
  137.             }
  139.             console.log('Balances after transfer:');
  140.             results.forEach(function (result) {
  141.                 console.log(result);
  142.             });
  144.             finish();
  145.         });
  146. });

Then run the code:

  1. $ node txn-sample.js

The output should be:

  1. Balances after transfer:
  2. { id: '1', balance: '900' }
  3. { id: '2', balance: '350' }

To verify that funds were transferred from one account to another, start the built-in SQL client:

  1. $ cockroach sql --insecure --database=bank

To check the account balances, issue the following statement:

  1. > SELECT id, balance FROM accounts;
  1. +----+---------+
  2. | id | balance |
  3. +----+---------+
  4. |  1 |     900 |
  5. |  2 |     350 |
  6. +----+---------+
  7. (2 rows)

What's next?

Read more about using the Node.js pg driver.

You might also be interested in using a local cluster to explore the following CockroachDB benefits:

Was this page helpful?
YesNo