Node.js driver tutorial
In this tutorial, we’ll build a sample application with the Node.js driver capable of basic interaction with TypeDB:
-
Connect to a TypeDB server (Core or Cloud),
-
Manage databases, sessions, and transactions,
-
Send different types of queries.
Follow the steps below or see the full source code.
Environment setup
To run this sample application, you’ll need:
-
TypeDB: either a TypeDB Cloud deployment or a TypeDB Core server. For TypeDB Core installation instructions, see the Self-managed deployments page.
-
Node.js and TypeDB Node.js driver. For the driver installation instructions, see the Node.js driver page.
Imported modules
To be able to use the TypeDB Node.js driver API in the Sample application, use the following import statements:
const { TypeDB } = require("typedb-driver/TypeDB");
const { SessionType } = require("typedb-driver/api/connection/TypeDBSession");
const { TransactionType } = require("typedb-driver/api/connection/TypeDBTransaction");
const { TypeDBOptions } = require("typedb-driver/api/connection/TypeDBOptions");
const { readFile } = require('fs/promises')
const prompt = require('prompt-sync')();
Default values
We store default values as constants in the source code:
const DB_NAME = "sample_app_db";
const SERVER_ADDR = "127.0.0.1:1729";
let dbReset = false;
let typedbEdition = "core"; // "cloud"
const CLOUD_USERNAME = "admin";
const CLOUD_PASSWORD = "password";
where DB_NAME
— the name of the database to use;
SERVER_ADDR
— address of the TypeDB server to connect to;
TYPEDB_EDITION
— TypeDB Core or Cloud edition selector;
CLOUD_USERNAME
/CLOUD_PASSWORD
— credentials to connect to TypeDB Cloud.
Program structure
The main workflow of this sample application includes establishing a connection to TypeDB, a new database setup, and querying.
async function main() {
try {
const driver = await connectToTypeDB(typedbEdition, SERVER_ADDR);
let setup = await dbSetup(driver, DB_NAME, dbReset);
if (setup) {
await queries(driver, DB_NAME);
} else {
console.log("Terminating...");
process.exit(1);
}
} catch (error) {
console.error(error);
}
process.exit();
};
The entire main()
function code is executed in the context of the network connection,
represented by the driver
object that is returned by the function.
TypeDB connection
The connectToTypeDB()
function takes edition
and addr
as mandatory parameters.
async function connectToTypeDB(edition, addr, username = CLOUD_USERNAME, password = CLOUD_PASSWORD) {
if (edition == "core") {
return await TypeDB.coreDriver(addr);
}
if (edition == "cloud") {
return await TypeDB.cloudDriver(addr, new TypeDBCredential(username, password));
}
}
The edition
is expected to be a String value of either core
or cloud
for selecting a TypeDB edition.
Depending on the TypeDB edition selected, this function initializes either a TypeDB Core or TypeDB Cloud connection.
TypeDB Cloud connection requires an object of the TypeDBCredential
class
that is initialized with a username and password.
For our sample application, we have the default credentials for the admin
account set in the code of the
connectToTypeDB
function.
TypeDB Cloud requires the default password for the default |
Database setup
To set up a TypeDB database, we need to make sure that it exists and has the correct schema and data. First, we check whether a database with the provided name already exists on the server.
If such a database doesn’t exist, we create a new database, define its schema, and load initial data.
To prevent data loss, avoid deleting an existing database without confirmation from a user. |
If a database with the specified name already exists, we check whether we need to replace it.
To do so, we check the db_reset
parameter, and, if it’s False
, ask for an input from a user.
If any of the two suggesting replacement of the database is acceptable,
we replace the database by deleting the existing database and then creating a new one.
As the final step of the database setup, we test it.
async function dbSetup(driver, dbName, dbReset=false) {
console.log(`Setting up the database: ${dbName}`);
try {
if (await driver.databases.contains(dbName)) {
if (dbReset === true) {
if ((await replaceDatabase(driver, dbName)) === false) {
return false;
}
} else { // dbReset = false
const input = prompt("Found a pre-existing database. Do you want to replace it? (Y/N) ");
if (input.toLowerCase() == "y") {
if ((await replaceDatabase(driver, dbName)) === false) {
return false;
}
} else {
console.log("Reusing an existing database.");
}
}
} else { // No such database on the server
if ((await createDatabase(driver, dbName)) === false) {
console.log("Failed to create a database. Terminating...");
return false;
}
}
if (await driver.databases.contains(dbName)) {
try {
let session = await driver.session(dbName, SessionType.DATA);
let result = await dbCheck(session);
await session.close();
return result;
} catch (error) { console.error(error); };
} else {
console.log("Database not found. Terminating...");
return false;
}
} catch (error) { console.error(error); };
}
Creating a database
We create a new database with the specified name (sample_app_db
by default)
and call functions to define its schema and load initial data.
async function createDatabase(driver, dbName) {
process.stdout.write("Creating a new database...");
await driver.databases.create(dbName);
console.log("OK");
try {
{
let session = await driver.session(dbName, SessionType.SCHEMA);
await dbSchemaSetup(session);
await session.close();
}
{
let session = await driver.session(dbName, SessionType.DATA);
await dbDatasetSetup(session);
await session.close();
}
} catch (error) { console.error(error); };
return true;
}
Replacing a database
We delete a database with the specified name (sample_app_db
by default)
and call a function to create a new one instead:
async function replaceDatabase(driver, dbName) {
process.stdout.write("Deleting an existing database...");
await (await driver.databases.get(dbName)).delete();
console.log("OK");
if ((await createDatabase(driver, dbName)) === true) {
return true;
} else {
console.log("Failed to create a database. Terminating...");
return false;
}
}
Defining a schema
We use a Define query to define a schema for the newly created database:
async function dbSchemaSetup(schemaSession) {
process.stdout.write("Defining schema...");
try {
let tx = await schemaSession.transaction(TransactionType.WRITE);
try {
const define_query = await readFile("iam-schema.tql", 'utf8');
await tx.query.define(define_query);
await tx.commit();
console.log("OK");
return true;
}
catch (e) {
callback(e);
return false;
}
}
catch (e) {
callback(e);
return false;
}
}
The schema for the sample application is stored in the iam-schema.tql file.
See the full schema
define
credential sub attribute, value string;
full-name sub attribute, value string;
id sub attribute, abstract, value string;
email sub id, value string;
name sub id, value string;
number sub id, value string;
path sub id, value string;
object-type sub attribute, value string;
ownership-type sub attribute, value string;
review-date sub attribute, value datetime;
size-kb sub attribute, value long;
validity sub attribute, value boolean;
access sub relation,
relates action,
relates object,
plays change-request:change,
plays permission:access;
change-request sub relation,
relates change,
relates requestee,
relates requester;
membership sub relation,
relates member,
relates parent;
collection-membership sub membership,
relates collection as parent;
group-membership sub membership,
relates group as parent;
set-membership sub membership,
relates set as parent;
ownership sub relation,
relates owned,
relates owner;
group-ownership sub ownership,
owns ownership-type,
relates group as owned;
object-ownership sub ownership,
owns ownership-type,
relates object as owned;
permission sub relation,
owns review-date,
owns validity,
relates access,
relates subject;
segregation-policy sub relation,
owns name,
relates action,
plays segregation-violation:policy;
violation sub relation,
abstract;
segregation-violation sub violation,
relates object,
relates policy,
relates subject;
action sub entity,
abstract,
owns name,
owns object-type,
plays access:action,
plays membership:member,
plays segregation-policy:action;
operation sub action;
operation-set sub action,
plays set-membership:set;
object sub entity,
abstract,
owns object-type,
plays access:object,
plays membership:member,
plays object-ownership:object,
plays segregation-violation:object;
resource sub object,
abstract;
file sub resource,
owns path,
owns size-kb;
record sub resource,
owns number;
resource-collection sub object,
abstract,
plays collection-membership:collection;
database sub resource-collection,
owns name;
directory sub resource-collection,
owns path,
owns size-kb;
subject sub entity,
abstract,
owns credential,
plays change-request:requestee,
plays change-request:requester,
plays membership:member,
plays ownership:owner,
plays permission:subject,
plays segregation-violation:subject;
user sub subject,
abstract;
person sub user,
owns email,
owns full-name;
user-group sub subject,
abstract,
plays group-membership:group,
plays group-ownership:group;
business-unit sub user-group,
owns name;
user-account sub user-group,
owns email;
user-role sub user-group,
owns name;
rule add-view-permission: when {
$modify isa action, has name "modify_file";
$view isa action, has name "view_file";
$ac_modify (object: $obj, action: $modify) isa access;
$ac_view (object: $obj, action: $view) isa access;
(subject: $subj, access: $ac_modify) isa permission;
} then {
(subject: $subj, access: $ac_view) isa permission;
};
We use a session object passed as a parameter to open a transaction. Then we send the contents of the file as a TypeQL Define query and commit the changes made by the transaction.
Loading initial data
With the schema defined, we can load initial data into our database with the Insert query:
async function dbDatasetSetup(dataSession) {
process.stdout.write("Loading data...");
try {
let tx = await dataSession.transaction(TransactionType.WRITE);
try {
const insert_query = await readFile("iam-data-single-query.tql", 'utf8');
await tx.query.insert(insert_query);
await tx.commit();
console.log("OK");
}
catch (e) { callback(e); }
}
catch (e) { callback(e); }
}
We read the iam-data-single-query.tql file, send its contents as a single query, and then commit the changes.
See the full TypeQL Insert query
insert
$p1 isa person,
has full-name "Masako Holley",
has email "masako.holley@typedb.com";
$p2 isa person,
has full-name "Pearle Goodman",
has email "pearle.goodman@typedb.com";
$p3 isa person,
has full-name "Kevin Morrison",
has email "kevin.morrison@typedb.com";
$f1 isa file,
has path "iopvu.java",
has size-kb 55;
$modify isa operation, has name "modify_file";
$view isa operation, has name "view_file";
$a1 (object: $f1, action: $modify) isa access;
$a11 (object: $f1, action: $view) isa access;
$permission1 (subject: $p3, access: $a1) isa permission;
$f2 isa file,
has path "zlckt.ts",
has size-kb 143;
$a2 (object: $f2, action: $modify) isa access;
$a22 (object: $f2, action: $view) isa access;
$permission2 (subject: $p3, access: $a2) isa permission;
$f3 isa file,
has path "psukg.java",
has size-kb 171;
$a3 (object: $f3, action: $modify) isa access;
$a33 (object: $f3, action: $view) isa access;
$permission3 (subject: $p3, access: $a3) isa permission;
$f4 isa file,
has path "axidw.java",
has size-kb 212;
$a4 (object: $f4, action: $modify) isa access;
$a44 (object: $f4, action: $view) isa access;
$permission4 (subject: $p3, access: $a4) isa permission;
$f5 isa file,
has path "lzfkn.java",
has size-kb 70;
$a5 (object: $f5, action: $modify) isa access;
$a55 (object: $f5, action: $view) isa access;
$permission5 (subject: $p3, access: $a5) isa permission;
$f6 isa file,
has path "budget_2022-05-01.xlsx",
has size-kb 758;
$a6 (object: $f6, action: $modify) isa access;
$a66 (object: $f6, action: $view) isa access;
$permission6 (subject: $p3, access: $a6) isa permission;
$permission66 (subject: $p2, access: $a66) isa permission;
$f7 isa file,
has path "zewhb.java";
$a7 (object: $f7, action: $modify) isa access;
$a77 (object: $f7, action: $view) isa access;
$permission7 (subject: $p3, access: $a7) isa permission;
$permission77 (subject: $p2, access: $a77) isa permission;
$f8 isa file,
has path "budget_2021-08-01.xlsx",
has size-kb 1705;
$a8 (object: $f8, action: $modify) isa access;
$a88 (object: $f8, action: $view) isa access;
$permission8 (subject: $p3, access: $a8) isa permission;
$permission88 (subject: $p2, access: $a88) isa permission;
$f9 isa file,
has path "LICENSE";
$a9 (object: $f9, action: $modify) isa access;
$a99 (object: $f9, action: $view) isa access;
$permission9 (subject: $p3, access: $a9) isa permission;
$permission99 (subject: $p2, access: $a99) isa permission;
$f10 isa file,
has path "README.md";
$a10 (object: $f10, action: $modify) isa access;
$a100 (object: $f10, action: $view) isa access;
$permission10 (subject: $p3, access: $a10) isa permission;
$permission100 (subject: $p2, access: $a100) isa permission;
Testing a database
With the schema defined and data loaded, we test our database to make sure it’s ready. To test the database, we send a query to count the number of users in the database:
async function dbCheck(dataSession) {
process.stdout.write("Testing the database...");
try {
let tx = await dataSession.transaction(TransactionType.READ);
try {
const test_query = "match $u isa user; get $u; count;";
let response = await tx.query.getAggregate(test_query);
let result = await response.asValue().asLong();
if (result == 3) {
console.log("Passed");
return true;
} else {
console.log("Failed with the result: " + result.toString() + " Expected result: 3");
return false;
}
}
catch (e) { callback(e); }
}
catch (e) { callback(e); }
}
Query examples
After database setup is complete, we proceed with querying our database with different types of queries in the
queries()
function:
async function queries(driver, dbName) {
console.log("\nRequest 1 of 6: Fetch all users as JSON objects with full names and emails");
let users = await fetchAllUsers(driver, dbName);
let new_name = "Jack Keeper";
let new_email = "jk@typedb.com";
console.log(`\nRequest 2 of 6: Add a new user with the full-name ${new_name} and email ${new_email}`);
await insertNewUser(driver, dbName, new_name, new_email);
let name = "Kevin Morrison";
console.log(`\nRequest 3 of 6: Find all files that the user ${name} has access to view (no inference)`);
let noFiles = await getFilesByUser(driver, dbName, name);
console.log(`\nRequest 4 of 6: Find all files that the user ${name} has access to view (with inference)`);
let files = await getFilesByUser(driver, dbName, name, inference=true);
old_path = "lzfkn.java";
new_path = "lzfkn2.java";
console.log(`\nRequest 5 of 6: Update the path of a file from ${old_path} to ${new_path}`);
let updated_files = await updateFilepath(driver, dbName, old_path, new_path);
path = "lzfkn2.java";
console.log(`\nRequest 6 of 6: Delete the file with path ${path}`);
let deleted = await delete_file(driver, dbName, path);
}
The queries are as follows:
-
Fetch query — to retrieve information in a JSON format
-
Insert query — to insert new data into the database
-
Get query — to retrieve data from the database as stateful objects
-
Get query with inference — to retrieve data from the database as stateful objects using inference
-
Update query — to replace data in the database
-
Delete query — to delete data from the database
Every query is implemented as a function that includes some output of the query response and returns some meaningful data.
Fetch query
The main way to retrieve data from a TypeDB database is to use fetching to get values of attributes, matched by a pattern.
Let’s use a Fetch query to fetch names and emails for all users in the database:
async function fetchAllUsers(driver, dbName) {
let dataSession = await driver.session(dbName, SessionType.DATA);
let users;
try {
let tx = await dataSession.transaction(TransactionType.READ);
try {
users = await tx.query.fetch("match $u isa user; fetch $u: full-name, email;").collect();
for (let i = 0; i < users.length; i++) {
console.log("User #" + (i + 1).toString() + ": " + users[i]["u"]["full-name"][0]["value"]);
}
}
catch (error) { console.error(error); }
finally { if (tx.isOpen()) {await tx.close()}; };
}
catch (error) { console.error(error); }
finally { await dataSession?.close(); };
return users;
}
We get the response as a stream of results, containing JSON,
collect it to the users
variable, and iterate through them to print the value of the first full-name
attribute
from each JSON.
Insert query
Let’s insert a new user with a full-name
and email
attributes to the database:
async function insertNewUser(driver, dbName, name, email) {
let result;
let dataSession = await driver.session(dbName, SessionType.DATA);
try {
let tx = await dataSession.transaction(TransactionType.WRITE);
try {
let response = await tx.query.insert(`insert $p isa person, has full-name $fn, has email $e; $fn == '${name}'; $e == '${email}';`);
let answers = await response.collect();
result = await Promise.all(
answers.map(answer =>
[answer.get("fn").value,
answer.get("e").value]
)
);
for(let i = 0; i < result.length; i++) {
console.log("User inserted: " + result[i][0] + ", has E-mail: " + result[i][1]);
};
await tx.commit();
}
catch (error) { console.error(error); }
finally { if (tx.isOpen()) {await tx.close()}; };
}
catch (error) { console.error(error); }
finally { await dataSession?.close(); };
return result;
}
The Insert query returns a stream of ConceptMaps: one for every insert
clause execution.
We collect the stream to a list of values in the result
variable.
Then we print name and email by iterating though the list, commit the changes,
and return the stored list.
Since the Insert query has no match
clause, the insert
clause is executed exactly once.
But the Insert query always returns a list of ConceptMap objects, where every ConceptMap represents an inserted result.
Get query
Let’s retrieve all files available for a user with a getFilesByUser()
function:
async function getFilesByUser(driver, dbName, name, inference=false) {
let options = new TypeDBOptions();
options.infer = inference;
let dataSession = await driver.session(dbName, SessionType.DATA);
let users;
try {
let tx = await dataSession.transaction(TransactionType.READ, options);
try {
users = await tx.query.get(`match $u isa user, has full-name '${name}'; get;`).collect();
if (users.length > 1) {
console.log("Error: Found more than one user with that name.");
await dataSession.close();
return null;
} else if (users.length == 1) {
let response = tx.query.get(`match
$fn == '${name}';
$u isa user, has full-name $fn;
$p($u, $pa) isa permission;
$o isa object, has path $fp;
$pa($o, $va) isa access;
$va isa action, has name 'view_file';
get $fp; sort $fp asc;
`);
answers = await response.collect();
result = await Promise.all(
answers.map(answer =>
[answer.get("fp").value]
)
);
for (let i = 0; i < result.length; i++) {
console.log("File #" + (i + 1).toString() + ": " + result[i]);
}
if (answers.length == 0) {
console.log("No files found. Try enabling inference.");
return answers
}
} else {
console.log("Error: No users found with that name.");
await dataSession.close();
return null;
}
}
catch (error) { console.error(error); }
finally { if (tx.isOpen()) {await tx.close()}; };
}
catch (error) { console.error(error); }
finally { await dataSession?.close(); };
return users;
}
We call the function with the inference disabled (false
) and expect it to return no results (an empty stream),
as the query pattern matches only files available for view_file
action,
and there are no such files initially in the database.
The getFilesByUser()
function checks
that there is only one user matched with the name provided by an input parameter.
It then executes the query to find the files, collect the results, and
iterates through them to print a value of every matched path
attribute.
For bigger numbers of results, it might be faster to iterate through a stream, rather than collect and store the results first. |
Get query with inference
To get query results with inferred data, let’s enable the infer
parameter of the TypeDB transaction options.
We use the same getFilesByUser()
function, but set the inference
parameter to true
when we call it again.
The add-view-permission
rule provides us with some inferred results this time.
Update query
Let’s replace a path for one of the files with a new path. We can do that by deleting ownership of the old path attribute from the file entity and assigning it with ownership of the new path attribute with the Update query:
async function updateFilepath(driver, dbName, oldPath, newPath) {
let dataSession = await driver.session(dbName, SessionType.DATA);
try {
let tx = await dataSession.transaction(TransactionType.WRITE);
try {
let response = await tx.query.update(`
match
$f isa file, has path $old_path;
$old_path = '${oldPath}';
delete
$f has $old_path;
insert
$f has path $new_path;
$new_path = '${newPath}';
`).collect();
if (response.length > 0) {
await tx.commit();
console.log(`Total number of paths updated: ${response.length}.`);
await dataSession.close();
return response;
} else {
console.log("No matched paths: nothing to update.");
await dataSession.close();
return null;
}
}
catch (error) { console.error(error); }
finally { if (tx.isOpen()) {await tx.close()}; };
}
catch (error) { console.error(error); }
finally { await dataSession?.close(); };
}
We collect the response of the Update query and check the length of it to determine
the number of times the delete
and insert
clauses are executed.
We then commit the changes only if the number meets our expectation.
Delete query
Finally, let’s delete the same file we updated the path for. First, we match the file in a Get (or Fetch) query to check how many files get matched to prevent unplanned deletes. If the number (or any other relevant parameters) of matched results is as expected, we proceed with a Delete query with the same match clause.
By using the same write
transaction we employ snapshot isolation
to prevent any other transactions from changing the expected results.
If any other transaction makes a conflicting change before we commit this transaction,
then our transaction fails upon a commit.
async function delete_file(driver, dbName, path) {
let dataSession = await driver.session(dbName, SessionType.DATA);
try {
let tx = await dataSession.transaction(TransactionType.WRITE);
try {
let response = await tx.query.get(`match
$f isa file, has path '${path}';
get;`).collect();
if (response.length == 1) {
await tx.query.delete(`
match
$f isa file, has path '${path}';
delete
$f isa file;
`);
await tx.commit();
console.log("The file has been deleted.");
await dataSession.close();
return true;
} else if (response.length > 1) {
console.log("Matched more than one file with the same path.");
console.log("No files were deleted.");
await tx.close();
await dataSession.close();
return false;
} else {
console.log(response.length)
console.log("No files matched in the database.");
console.log("No files were deleted.");
await tx.close();
await dataSession.close();
return false;
}
}
catch (error) { console.error(error); }
finally { if (tx.isOpen()) {await tx.close()}; };
}
catch (error) { console.error(error); }
finally { await dataSession?.close(); };
}