enigma-bbs/core/database.js

/* jslint node: true */
'use strict';

//	ENiGMA½
const conf			= require('./config.js');

//	deps
const sqlite3		= require('sqlite3');
const sqlite3Trans	= require('sqlite3-trans');
const paths			= require('path');
const async			= require('async');
const _				= require('lodash');
const assert		= require('assert');
const moment		= require('moment');

//	database handles
const dbs = {};

exports.getTransactionDatabase		= getTransactionDatabase;
exports.getModDatabasePath			= getModDatabasePath;
exports.getISOTimestampString		= getISOTimestampString;
exports.sanatizeString				= sanatizeString;
exports.initializeDatabases			= initializeDatabases;

exports.dbs							= dbs;

function getTransactionDatabase(db) {
	return sqlite3Trans.wrap(db);
}

function getDatabasePath(name) {
	return paths.join(conf.config.paths.db, `${name}.sqlite3`);
}

function getModDatabasePath(moduleInfo, suffix) {
	//
	//	Mods that use a database are stored in Config.paths.modsDb (e.g. enigma-bbs/db/mods)
	//	We expect that moduleInfo defines packageName which will be the base of the modules
	//	filename. An optional suffix may be supplied as well.
	//
	const HOST_RE = /^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9-]*[A-Za-z0-9])$/;

	assert(_.isObject(moduleInfo));
	assert(_.isString(moduleInfo.packageName), 'moduleInfo must define "packageName"!');

	let full = moduleInfo.packageName;
	if(suffix) {
		full += `.${suffix}`;
	}

	assert(
		(full.split('.').length > 1 && HOST_RE.test(full)),
		'packageName must follow Reverse Domain Name Notation - https://en.wikipedia.org/wiki/Reverse_domain_name_notation');

	return paths.join(conf.config.paths.modsDb, `${full}.sqlite3`);
}

function getISOTimestampString(ts) {
	ts = ts || moment();
	return ts.format('YYYY-MM-DDTHH:mm:ss.SSSZ');
}

function sanatizeString(s) {
	return s.replace(/[\0\x08\x09\x1a\n\r"'\\%]/g, c => {	//	eslint-disable-line no-control-regex
		switch (c) {
			case '\0'	: return '\\0';
			case '\x08'	: return '\\b';
			case '\x09'	: return '\\t';
			case '\x1a'	: return '\\z';
			case '\n'	: return '\\n';
			case '\r'	: return '\\r';

			case '"' :
			case '\'' :
			case '\\' :
			case '%' :
				return `\\${c}`;
		}
	});
}

function initializeDatabases(cb) {
	async.eachSeries( [ 'system', 'user', 'message', 'file' ], (dbName, next) => {
		dbs[dbName] = sqlite3Trans.wrap(new sqlite3.Database(getDatabasePath(dbName), err => {
			if(err) {
				return cb(err);
			}

			dbs[dbName].serialize( () => {
				DB_INIT_TABLE[dbName]( () => {
					return next(null);
				});
			});
		}));
	}, err => {
		return cb(err);
	});
}

function enableForeignKeys(db) {
	db.run('PRAGMA foreign_keys = ON;');
}

const DB_INIT_TABLE = {
	system : (cb) => {
		enableForeignKeys(dbs.system);

		//	Various stat/event logging - see stat_log.js
		dbs.system.run(
			`CREATE TABLE IF NOT EXISTS system_stat (
				stat_name		VARCHAR PRIMARY KEY NOT NULL,
				stat_value		VARCHAR NOT NULL
			);`
		);

		dbs.system.run(
			`CREATE TABLE IF NOT EXISTS system_event_log (
				id				INTEGER PRIMARY KEY,
				timestamp		DATETIME NOT NULL,
				log_name		VARCHAR NOT NULL,
				log_value		VARCHAR NOT NULL,

				UNIQUE(timestamp, log_name)
			);`
		);

		dbs.system.run(
			`CREATE TABLE IF NOT EXISTS user_event_log (
				id				INTEGER PRIMARY KEY,
				timestamp		DATETIME NOT NULL,
				user_id			INTEGER NOT NULL,
				log_name		VARCHAR NOT NULL,
				log_value		VARCHAR NOT NULL,

				UNIQUE(timestamp, user_id, log_name)
			);`
		);

		return cb(null);
	},

	user : (cb) => {
		enableForeignKeys(dbs.user);

		dbs.user.run(
			`CREATE TABLE IF NOT EXISTS user ( 
				id			INTEGER PRIMARY KEY,
				user_name	VARCHAR NOT NULL, 
				UNIQUE(user_name)
			);`
		);

		//	:TODO: create FK on delete/etc.

		dbs.user.run(
			`CREATE TABLE IF NOT EXISTS user_property (
				user_id		INTEGER NOT NULL,
				prop_name	VARCHAR NOT NULL,
				prop_value	VARCHAR,
				UNIQUE(user_id, prop_name),
				FOREIGN KEY(user_id) REFERENCES user(id) ON DELETE CASCADE 
			);`
		);

		dbs.user.run(
			`CREATE TABLE IF NOT EXISTS user_group_member ( 
				group_name	VARCHAR NOT NULL, 
				user_id		INTEGER NOT NULL,
				UNIQUE(group_name, user_id)
			);`
		);

		dbs.user.run(
			`CREATE TABLE IF NOT EXISTS user_login_history (	
				user_id		INTEGER NOT NULL,
				user_name	VARCHAR NOT NULL,
				timestamp	DATETIME NOT NULL
			);`
		);

		return cb(null);
	},

	message : (cb) => {
		enableForeignKeys(dbs.message);

		dbs.message.run(
			`CREATE TABLE IF NOT EXISTS message (
				message_id				INTEGER PRIMARY KEY, 
				area_tag				VARCHAR NOT NULL,
				message_uuid			VARCHAR(36) NOT NULL, 
				reply_to_message_id		INTEGER,
				to_user_name			VARCHAR NOT NULL,
				from_user_name			VARCHAR NOT NULL,
				subject, /* FTS @ message_fts */
				message, /* FTS @ message_fts */
				modified_timestamp		DATETIME NOT NULL,
				view_count				INTEGER NOT NULL DEFAULT 0,
				UNIQUE(message_uuid) 
			);`
		);

		dbs.message.run(
			`CREATE INDEX IF NOT EXISTS message_by_area_tag_index
			ON message (area_tag);`
		);

		dbs.message.run(
			`CREATE VIRTUAL TABLE IF NOT EXISTS message_fts USING fts4 (
				content="message",
				subject,
				message
			);`
		);

		dbs.message.run(
			`CREATE TRIGGER IF NOT EXISTS message_before_update BEFORE UPDATE ON message BEGIN
				DELETE FROM message_fts WHERE docid=old.rowid;
			END;`
		);

		dbs.message.run(
			`CREATE TRIGGER IF NOT EXISTS message_before_delete BEFORE DELETE ON message BEGIN
				DELETE FROM message_fts WHERE docid=old.rowid;
			END;`
		);

		dbs.message.run(
			`CREATE TRIGGER IF NOT EXISTS message_after_update AFTER UPDATE ON message BEGIN
				INSERT INTO message_fts(docid, subject, message) VALUES(new.rowid, new.subject, new.message);
			END;`
		);

		dbs.message.run(
			`CREATE TRIGGER IF NOT EXISTS message_after_insert AFTER INSERT ON message BEGIN
				INSERT INTO message_fts(docid, subject, message) VALUES(new.rowid, new.subject, new.message);
			END;`
		);

		dbs.message.run(
			`CREATE TABLE IF NOT EXISTS message_meta (
				message_id		INTEGER NOT NULL,
				meta_category	INTEGER NOT NULL,
				meta_name		VARCHAR NOT NULL,
				meta_value		VARCHAR NOT NULL,
				UNIQUE(message_id, meta_category, meta_name, meta_value), 
				FOREIGN KEY(message_id) REFERENCES message(message_id) ON DELETE CASCADE
			);`
		);


		//	:TODO: need SQL to ensure cleaned up if delete from message?
		/*
		dbs.message.run(
			`CREATE TABLE IF NOT EXISTS hash_tag (
				hash_tag_id		INTEGER PRIMARY KEY,
				hash_tag_name	VARCHAR NOT NULL,
				UNIQUE(hash_tag_name)
			);`
		);

		//	:TODO: need SQL to ensure cleaned up if delete from message?
		dbs.message.run(
			`CREATE TABLE IF NOT EXISTS message_hash_tag (
				hash_tag_id	INTEGER NOT NULL,
				message_id	INTEGER NOT NULL,
			);`
		);
		*/

		dbs.message.run(
			`CREATE TABLE IF NOT EXISTS user_message_area_last_read (
				user_id		INTEGER NOT NULL,
				area_tag	VARCHAR NOT NULL,
				message_id	INTEGER NOT NULL,
				UNIQUE(user_id, area_tag)
			);`
		);

		dbs.message.run(
			`CREATE TABLE IF NOT EXISTS message_area_last_scan (
				scan_toss		VARCHAR NOT NULL,
				area_tag		VARCHAR NOT NULL,
				message_id		INTEGER NOT NULL,
				UNIQUE(scan_toss, area_tag)
			);`
		);

		return cb(null);
	},

	file : (cb) => {
		enableForeignKeys(dbs.file);

		dbs.file.run(
			//	:TODO: should any of this be unique -- file_sha256 unless dupes are allowed on the system
			`CREATE TABLE IF NOT EXISTS file (
				file_id				INTEGER PRIMARY KEY,
				area_tag			VARCHAR NOT NULL,
				file_sha256			VARCHAR NOT NULL,
				file_name,			/* FTS @ file_fts */
				storage_tag			VARCHAR NOT NULL,
				desc,				/* FTS @ file_fts */
				desc_long,			/* FTS @ file_fts */				
				upload_timestamp	DATETIME NOT NULL
			);`
		);

		dbs.file.run(
			`CREATE INDEX IF NOT EXISTS file_by_area_tag_index
			ON file (area_tag);`
		);

		dbs.file.run(
			`CREATE INDEX IF NOT EXISTS file_by_sha256_index
			ON file (file_sha256);`
		);

		dbs.file.run(
			`CREATE VIRTUAL TABLE IF NOT EXISTS file_fts USING fts4 (
				content="file",
				file_name,
				desc,
				desc_long
			);`
		);

		dbs.file.run(
			`CREATE TRIGGER IF NOT EXISTS file_before_update BEFORE UPDATE ON file BEGIN
				DELETE FROM file_fts WHERE docid=old.rowid;
			END;`
		);

		dbs.file.run(
			`CREATE TRIGGER IF NOT EXISTS file_before_delete BEFORE DELETE ON file BEGIN
				DELETE FROM file_fts WHERE docid=old.rowid;
			END;`
		);

		dbs.file.run(
			`CREATE TRIGGER IF NOT EXISTS file_after_update AFTER UPDATE ON file BEGIN
				INSERT INTO file_fts(docid, file_name, desc, desc_long) VALUES(new.rowid, new.file_name, new.desc, new.desc_long);
			END;`
		);

		dbs.file.run(
			`CREATE TRIGGER IF NOT EXISTS file_after_insert AFTER INSERT ON file BEGIN
				INSERT INTO file_fts(docid, file_name, desc, desc_long) VALUES(new.rowid, new.file_name, new.desc, new.desc_long);
			END;`
		);

		dbs.file.run(
			`CREATE TABLE IF NOT EXISTS file_meta (
				file_id			INTEGER NOT NULL,
				meta_name		VARCHAR NOT NULL,
				meta_value		VARCHAR NOT NULL,
				UNIQUE(file_id, meta_name, meta_value), 
				FOREIGN KEY(file_id) REFERENCES file(file_id) ON DELETE CASCADE
			);`
		);

		dbs.file.run(
			`CREATE TABLE IF NOT EXISTS hash_tag (
				hash_tag_id		INTEGER PRIMARY KEY,
				hash_tag		VARCHAR NOT NULL,
			
				UNIQUE(hash_tag)
			);`
		);

		dbs.file.run(
			`CREATE TABLE IF NOT EXISTS file_hash_tag (
				hash_tag_id		INTEGER NOT NULL,
				file_id			INTEGER NOT NULL,
			
				UNIQUE(hash_tag_id, file_id)
			);`
		);

		dbs.file.run(
			`CREATE TABLE IF NOT EXISTS file_user_rating (
				file_id			INTEGER NOT NULL,
				user_id			INTEGER NOT NULL,
				rating			INTEGER NOT NULL,

				UNIQUE(file_id, user_id)
			);`
		);

		dbs.file.run(
			`CREATE TABLE IF NOT EXISTS file_web_serve (
				hash_id				VARCHAR NOT NULL PRIMARY KEY,
				expire_timestamp	DATETIME NOT NULL
			);`
		);

		dbs.file.run(
			`CREATE TABLE IF NOT EXISTS file_web_serve_batch (
				hash_id		VARCHAR NOT NULL,
				file_id		INTEGER NOT NULL,

				UNIQUE(hash_id, file_id)
			);`
		);

		return cb(null);
	}
};