lib/persistence.js

  1. /**
  2.  * @file Persistence layer
  3.  * @author Antonio Olmo Titos <a@olmo-titos.info>
  4.  * @exports lib/persistence
  5.  */
  7. // Configuration:
  8. const CONFIG = require('../config');
  10. // External packages:
  11. const PROCESS = require('process'),
  12.     SQLITE = require('sqlite3');
  14. // Internal packages:
  15. const LOGGING = require('./logging'),
  16.     UTIL = require('./util');
  18. // Variables:
  19. var connection;
  21. /**
  22.  * Terminate the DB connection (gracefully)
  23.  */
  25. const wrapUp = function() {
  26.     connection.close();
  27.     LOGGING.info(`connection to DB file closed`);
  28.     PROCESS.exit();
  29. };
  31. /**
  32.  * Run a query and retrieve a set of rows from the DB
  33.  * @param {String} query - the SQL query
  34.  * @param {String} params - (optional; variable length) values to interpolate in the query
  35.  * @returns {Array} the resulting rows
  36.  */
  38. const retrieveRows = function(query, ...params) {
  39.     return new Promise(function(resolve, reject) {
  40.         connection.all(query, params, function(err, rows) {
  41.             if (err)
  42.                 reject(err);
  43.             else
  44.                 resolve(rows);
  45.         });
  46.     });
  47. };
  49. /**
  50.  * Set up persistence
  51.  */
  53. const setUp = function() {
  54.     if (connection)
  55.         LOGGING.warn(`“persistence.setUp()” called more than once`);
  56.     else {
  57.         if (CONFIG.debug)
  58.             SQLITE.verbose();
  59.         // @TODO: handle issues.
  60.         connection = new SQLITE.Database(CONFIG.db, SQLITE.OPEN_READWRITE);
  61.         connection.exec('PRAGMA foreign_keys = ON;');
  62.         LOGGING.info(`persistence linked to file “${CONFIG.db}”`);
  63.         PROCESS.on('SIGINT', wrapUp);
  64.         // Export more stuff:
  65.         exports.TYPE_PERSON = 'people';
  66.         exports.TYPE_MEETING = 'meetings';
  67.         exports.TYPE_LOCATION = 'locations';
  68.         // exports.createEntity = createEntity;
  69.         exports.listEntities = listEntities;
  70.         exports.findEntity = findEntity;
  71.     }
  72. };
  74. // const createEntity = function(type) {
  75. //     return new Promise(function(resolve, reject) {
  76. //         if (exports.TYPE_PERSON === type)
  77. //             retrieveRows(`INSERT INTO ${type} VALUES;`).then(function(rows) {
  78. //                 resolve(rows);
  79. //             }).catch(function(err) {
  80. //                 LOGGING.debug(`“persistence.listEntities()” error: ${err}`);
  81. //                 reject(err);
  82. //             });
  83. //         else if (exports.TYPE_MEETING === type)
  84. //             ;
  85. //         else if (exports.TYPE_LOCATION === type)
  86. //             ;
  87. //         else
  88. //             reject();
  89. //     });
  90. // };
  92. /**
  93.  * Return all entities of a given type
  94.  * @param {String} type - type; use constants of the form <code>persistence.TYPE_*</code>
  95.  * @returns {Array} all entities of that type
  96.  */
  98. const listEntities = function(type) {
  99.     return new Promise(function(resolve, reject) {
  100.         if (exports.TYPE_PERSON === type || exports.TYPE_MEETING === type || exports.TYPE_LOCATION === type) {
  101.             retrieveRows(`SELECT * FROM ${type} ORDER BY name;`).then(function(rows) {
  102.                 UTIL.processData(rows);
  103.                 resolve(rows);
  104.             }).catch(function(err) {
  105.                 LOGGING.warn(`“persistence.listEntities()” error: ${err}`);
  106.                 reject(err);
  107.             });
  108.         } else
  109.             reject();
  110.     });
  111. };
  113. /**
  114.  * Return all entities with a given ID (should be unique)
  115.  * @param {String} id - name of the desired ID
  116.  * @returns {Promise} found entities
  117.  */
  119. const findEntity = function(id) {
  120.     LOGGING.dir(id);
  121.     return new Promise(function(resolve, reject) {
  122.         const normalisedID = UTIL.normaliseID(id);
  123.         if (normalisedID) {
  124.             const queries = [
  125.                 retrieveRows(`SELECT * FROM people WHERE name LIKE ?;`, id),
  126.                 retrieveRows(`SELECT * FROM meetings WHERE name LIKE ?;`, id),
  127.                 retrieveRows(`SELECT * FROM locations WHERE name LIKE ?;`, id)
  128.             ];
  129.             const result = Promise.all(queries);
  130.             result.then(function(rows) {
  131.                 const people = rows[0],
  132.                     meetings = rows[1],
  133.                     locations = rows[2];
  134.                 if (1 === people.length && 0 === meetings.length && 0 === locations.length)
  135.                     resolve({type: exports.TYPE_PERSON, data: people[0]});
  136.                 else if (0 === people.length && 1 === meetings.length && 0 === locations.length)
  137.                     resolve({type: exports.TYPE_MEETING, data: meetings[0]});
  138.                 else if (0 === people.length && 0 === meetings.length && 1 === locations.length)
  139.                     resolve({type: exports.TYPE_LOCATION, data: locations[0]});
  140.                 else if (people.length + meetings.length + locations.length > 1)
  141.                     reject('more than one entity');
  142.                 else
  143.                     reject('foo');
  144.             });
  145.             result.catch(function(err) {
  146.                 reject(`“persistence.findEntity()” error: ${err}`);
  147.             });
  148.         } else
  149.             reject('wrong');
  150.     });
  151. };
  153. // Export stuff:
  154. exports.setUp = setUp;