You will be pleased to hear that the Domino 10 module for Node.js is now in beta (you can request early access here) and in this article I would like to show you how easy it will be to use.
Before we get started using the Domino module in Node, we do need to do some admin stuff on our Domino server. It has to be running Domino 10 and we have to install the Proton add-in, and we also have to create the Design Catalog including at least one database. (The Proton add-in listens on its own port, by default 3002, and is separate from HTTP.)
More detail on these admin tasks will be covered in a companion blog, but here I would like to focus on the app-dev side.
Lets build a simple Node.js system that will read some Domino documents and get field values, and also create some new documents. In my next post we can integrate this into the basic Node stack we developed in my previous post to create an actual API.
Assuming our Domino server is all set up, the first thing we do is install the new dominodb module. When this goes live later in the year, we will do this with the usual ‘npm install dominodb’, but while we are still in beta we install it from the downloaded beta package:
npm install ../packages/domino-domino-db-1.0.0.tgz --save
Once we have the dominodb connector installed, we can use it in our Node server.js code. The sequence is almost exactly the same as in LotusScript. First, we connect to Domino and open the Server (sort of equivalent to a NotesSession), then from this we open our Database, and then using the Database we can access and update Documents.
We start the same way as with all other Node.js modules, with a ‘require’:
const { useServer } = require('@domino/domino-db');
This ‘useServer’ is a function and is going to create our server connection. We give it the Domino server’s hostname and the Proton port, and it connects to our server like this:
serverConfig = {
hostName: 'server.mydomain.com',
connection: { port:'3002'}
};
useServer( serverConfig )
The useServer function returns a ‘server’ object. This is inside a javascript promise (I talked about promises in an earlier
post), so we can use the server object inside the promise to open our database like this:
useServer( serverConfig ).then( async server => {
const database = await server.useDatabase( databaseConfig );
The databaseConfig contains the filepath of our database on the server:
const databaseConfig = {
filePath: 'orders.nsf'
};
Notice how we are using ‘async await’ to simplify the asynchronous nature of getting the database. This code looks very similar to the LotusScript equivalent.
So we have created a server connection and opened a database. Now we want to get some documents.
The domino-db module uses the new Domino Query Language (DQL) which comes with Domino 10. This can perform very efficient high-performance queries on Domino databases.
It is very much like getting a document collection with a db.search( ) in LotusScript, and the query syntax is similar to selection formulas, for example:
const coll = await database.bulkReadDocuments({
query: "Form = 'Order' and Customer = 'ACME'"
});
This returns a collection of documents in a JSON array. These documents do not automatically contain all the items from the Notes documents. By default they only have some basic metadata, i.e. unid, created date, and modified date:
{
"documents":[
{
"@unid":"A2504056F3AF6EFE8025833100549873",
"@created": {"type":"datetime","data":"2018-10-25T15:24:00.51Z"},
"@modified": {"type":"datetime","data":"2018-10-25T15:24:00.52Z"}
}
],
"errors":0,
"documentRange":{"total":1,"start":0,"count":1}
}
To get field data from the documents, you need to specify which fields you want returned, and this is done with an array of itemNames:
const coll = await database.bulkReadDocuments({
query: "Form = 'Order' and Customer = 'ACME'",
itemNames: ['OrderNo', 'Qty', 'Price']
});
Then you get the field data included in your query results:
{
"documents":[
{
"@unid":"A2504056F3AF6EFE8025833100549873",
"@created":{"type":"datetime","data":"2018-10-25T15:24:00.51Z"},
"@modified":{"type":"datetime","data":"2018-10-25T15:24:00.52Z"},
"OrderNo":"001234",
"Qty":2,
"Price":25.49
}
],
"errors":0,
"documentRange":{"total":1,"start":0,"count":1}
}
We can output the document field data with JSON dot notation in a console.log (with the JSON.stringify method to format it properly):
console.log( "Order No: " + JSON.stringify( coll.documents[0].OrderNo ) );
So this is how to read a collection of documents. Now lets look at creating a new document, which is even easier.
First we build our document data in an ‘options’ object, including the Form name and all our other item values:
const newDocOptions = {
document: {
Form: 'Order',
Customer: 'ACME',
OrderNo: '000343',
Qty: 10,
Price: 49.99
}
};
Then we simply call the ‘createDocument’ method, like this:
const unid = await database.createDocument( newDocOptions );
We don’t need to call a ‘save’ on the document, it is all handled in one operation. The return value is the unid of the newly-created document, so we can act on it again to update it if we want to.
To update a document, we get it by its unid with the ‘useDocument’ method, and then we can call ‘replaceItems’ on it.
This takes the new values in a ‘replaceItems’ parameter, but it only needs to contain the fields to update:
const document = await database.useDocument({
unid: coll.documents[0]['@unid']
});
await document.replaceItems({
replaceItems: { Qty: 11 }
});
Here we are using the ‘@unid’ value from the collection we got earlier. This is a bit fiddly because ‘@’ is a reserved symbol in JSON, but we can use the JSON square bracket notation to get around this.
We have got documents and created and updated documents. In addition to all these, the domino-db module provides a variety of methods for reading, creating and updating documents, allowing you to do anything you would need.
Also, the DQL syntax has sophisticated search facilities that can return large numbers of documents and can even search in views and columns.
There are couple of things to be aware of:
The first is that by default the connection to Domino is unsecured, but you can easily make it use TLS/SSL. You may need help from your Domino admin to provide you with the certificate and key files, but this is all explained in the documentation.
The second thing is that currently this access is either Anonymous or can be set to a single Domino user account in TLS/SSL by the client certificate (which maps to a Domino person document). So in the beta there is no user authentication per se, but this will be coming later with OAuth support.
I hope you found this both useful and exciting. In my next article I plan to show how to build these domino-db methods into a Node HTTP server and create an API gateway.
The Turtle Partnership Blog 