srap/src/database-backends/simulated/index.js

"use strict";

const Promise = require("bluebird");
const chalk = require("chalk");

const mergeItems = require("../../semantics/merge-items");

function printTX(tx) {
	// TODO: Print entire chain?
	return chalk.bold.yellow(`[tx ${tx.__txID ?? "?"}]`);
}

function printItem(id, task) {
	if (task != null) {
		return chalk.bold.white(`[${id}][${task.name}]`);
	} else {
		return chalk.bold.white(`[${id}]`);
	}
}

// FIXME: Move logs to logging hook
function logSimulated(... args) {
	console.log(chalk.gray(args[0]), ... args.slice(1));
}

module.exports = function (state) {
	
	// NOTE: The simulated backend needs access to the 'real' backend; a task may eg. mutate an item based on its current data, and we'd need to read that from the real data source. The only constraint is that the simulated backend cannot *mutate* anything in the real backend, but reading is fine!
	return {
		defaultSettings: {},
		create: function createSimulatedBackend({ backend }) {
			let txCounter = 0;
			let locks = new Map(); // Map<task, Set<id>>

			return {
				shutdown: function () {
					return backend.shutdown();
				},
				
				getDefaultTransaction: function () {
					return { __txID: null };
				},

				isTransaction: function (value) {
					return ("__txID" in value);
				},

				runInTransaction: function (tx, callback) {
					let newTransaction = { __txID: txCounter++, __parentTX: tx };

					return callback(newTransaction);
				},

				lock: function (tx, { id, task }) {
					if (!locks.has(task)) {
						locks.set(task, new Set());
					}

					let taskLocks = locks.get(task);

					if (taskLocks.has(id)) {
						logSimulated(`${printTX(tx)} Already locked: ${printItem(id, task)}`);
						return false;
					} else {
						logSimulated(`${printTX(tx)} Locking ${printItem(id, task)}`);
						taskLocks.add(id);
						return true;
					}
				},
				
				unlock: function (tx, { id, task }) {
					logSimulated(`${printTX(tx)} Unlocking ${printItem(id, task)}`);
					locks.get(task).delete(id);
				},

				getItem: function (tx, options) {
					return backend.getItem(backend.getDefaultTransaction(), options);
				},

				storeItem: function (tx, { id, parentID, update, tags, aliases, allowUpsert }) {
					return Promise.try(() => {
						return this.getItem(tx, { id: id, optional: true });
					}).then((currentItem) => {
						let actualID = (currentItem != null)
							? currentItem.id
							: id;

						let newItem = {
							id: actualID,
							data: (currentItem != null)
								? update(currentItem.data)
								: update({}),
							createdBy: parentID,
							tags: tags,
							aliases: aliases.concat([ actualID ]),
							updatedAt: new Date()
						};
						
						logSimulated(`${printTX(tx)} ${printItem(id)} Storing item (upsert=${allowUpsert})`, newItem);
					});
				},

				moveItem: function (tx, { from, into, merge, mergeMetadata, allowMerge }) {
					return Promise.all([
						this.getItem(tx, { id: from, optional: true }),
						this.getItem(tx, { id: into, optional: true }),
					]).then(([ fromObj, maybeIntoObj ]) => {
						if (fromObj != null) {
							let intoObj = maybeIntoObj ?? {
								id: into,
								data: {},
								taskResults: []
							};

							if (allowMerge) {
								let newItem = mergeItems({ fromObj, intoObj, merge, mergeMetadata });
								logSimulated(`${printTX(tx)} ${printItem(from)} Moving item to ${printItem[into]} (merge=true)`, newItem);
							} else {
								logSimulated(`${printTX(tx)} ${printItem(from)} Moving item to ${printItem[into]} (merge=false)`);
							}
						}
					});
				},

				deleteItem: function (tx, { id }) {
					logSimulated(`${printTX(tx)} ${printItem(id)} Deleting item`);
				},

				createAlias: function (tx, { from, to }) {
					logSimulated(`${printTX(tx)} ${printItem(to)} Creating alias ${from}`);
				},

				deleteAlias: function (tx, { from }) {
					logSimulated(`${printTX(tx)} ${printItem(from)} Deleting alias`);
				},

				updateMetadata: function (tx, { id, task, update }) {
					return Promise.try(() => {
						return this.getItem(tx, { id, optional: true });
					}).then((item) => {
						let taskResult = (item != null)
							? item.taskResults.find((result) => result.task === task)
							: undefined;
						
						let existingData = (taskResult != null)
							? taskResult.metadata
							: {};

						let newData = update(existingData);

						logSimulated(`${printTX(tx)} ${printItem(id, task)} Storing metadata`, newData);
					});
				},

				expire: function (tx, { id, task }) {
					logSimulated(`${printTX(tx)} ${printItem(id, task)} Expiring task result`);
				},

				markTaskStatus: function (tx, { id, task, isSuccessful }) {
					if (isSuccessful) {
						logSimulated(`${printTX(tx)} ${printItem(id, task)} Marking task as completed`);
					} else {
						logSimulated(`${printTX(tx)} ${printItem(id, task)} Marking task as failed`);
					}
				},

				countLockedTasks: function (tx) {
					return Array.from(locks).reduce((total, [ task, taskLocks ]) => {
						return total + taskLocks.size;
					}, 0);
				},

				getUpdateStream: function (... args) {
					return backend.getUpdateStream(... args);
				},

				getTaskStream: function (... args) {
					return backend.getTaskStream(... args);
				}
			};
		}
	};
};