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

"use strict";

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

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

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

function logSimulated(... args) {
	console.log(... args);
}

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 function attachSimulatedBackend({ backend }) {
		return {
			defaultSettings: {},
			create: function createSimulatedBackend(_options) {
				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.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);
					}
				};
			}
		};
	};
};