total5 0.0.1 → 0.0.2

package/nosql-querybuilder.js

@@ -0,0 +1,320 @@
+// Total.js NoSQL QueryBuilder
+// The MIT License
+// Copyright 2020-2023 (c) Peter Širka <petersirka@gmail.com>
+
+const REG_NULLABLE = /\./g;
+const REG_LANGUAGE = /[a-z0-9]+§/gi;
+const REG_ABSOLUTE = /\/|\\/;
+const LOGGER = '-- NoSQL -->';
+const FILTER = { find: 1, read: 1, count: 1, scalar: 1, check: 1, list: 1, update: 1, remove: 1, query: 1 };
+const Open = {};
+
+function db_where(where, opt, filter, operator, args) {
+
+	var tmp;
+
+	for (var item of filter) {
+
+		if (item.comparer) {
+			switch (item.comparer) {
+				case '=':
+					item.comparer = '==';
+					break;
+				case '<>':
+					item.comparer = '!=';
+					break;
+			}
+		}
+
+		if (opt.language != null && item.name && item.name[item.name.length - 1] === '§')
+			item.name = item.name.substring(0, item.name.length - 1) + opt.language;
+
+		switch (item.type) {
+			case 'or':
+				tmp = [];
+				db_where(tmp, opt, item.value, '||', args);
+				where.length && where.push(operator);
+				where.push('(' + tmp.join(' ') + ')');
+				break;
+			case 'in':
+			case 'notin':
+				where.length && where.push(operator);
+				where.push((item.type === 'notin' ? '!' : '') + 'func.in(doc.' + item.name.replace(REG_NULLABLE, '?.') + ',arg.params[' + args(item.value) + '])');
+				break;
+			case 'query':
+				where.length && where.push(operator);
+				where.push('(' + item.value + ')');
+				break;
+			case 'where':
+				where.length && where.push(operator);
+				where.push('doc.' + item.name.replace(REG_NULLABLE, '?.') + item.comparer + 'arg.params[' + args(item.value) + ']');
+				break;
+			case 'contains':
+				where.length && where.push(operator);
+				where.push('(doc.{0} instanceof Array?!!doc.{0}.length:!!doc.{0})'.format(item.name.replace(REG_NULLABLE, '?.')));
+				break;
+			case 'search':
+				var paramindex = args(item.value.replace(/%/g, ''));
+				where.length && where.push(operator);
+				where.push('func.search(doc.' + item.name.replace(REG_NULLABLE, '?.') + ',arg.params[' + paramindex + ']' + (item.comparer == 'beg' ? ',1' : item.comparer == 'end' ? ',2' : '') + ')');
+				break;
+			case 'month':
+			case 'year':
+			case 'day':
+			case 'hour':
+			case 'minute':
+				where.length && where.push(operator);
+				where.push(compare_datetype(item.type, item.name, args(item.value), item.comparer));
+				break;
+			case 'empty':
+				where.length && where.push(operator);
+				where.push('(doc.{0} instanceof Array?!doc.{0}.length:!doc.{0})'.format(item.name.replace(REG_NULLABLE, '?.')));
+				break;
+			case 'between':
+				var ia = args(item.a);
+				var ib = args(item.b);
+				where.length && where.push(operator);
+				where.push('(doc.' + item.name.replace(REG_NULLABLE, '?.') + '>=arg.params[' + ia + ']&&doc.' + item.name + '<=arg.params[' + ib + '])');
+				break;
+		}
+	}
+}
+
+function db_insertupdate(filter, insert) {
+
+	var query = insert ? null : [];
+	var params = {};
+
+	for (var key in filter.payload) {
+		var val = filter.payload[key];
+		var c = key[0];
+
+		switch (c) {
+			case '-':
+			case '+':
+			case '*':
+			case '/':
+				key = key.substring(1);
+				params[key] = val ? val : 0;
+				if (!insert)
+					query.push('doc.{0}=(doc.{0}==null?0:doc.{0})+arg.{0}'.format(key));
+				break;
+			case '>':
+			case '<':
+				key = key.substring(1);
+				params[key] = val ? val : 0;
+				if (!insert)
+					query.push('doc.{0}=(doc.{0}==null?arg.{0}:doc.{0}' + (c === '>' ? '<' : '>') + 'arg.{0}?arg.{0}:doc.{0})'.format(key));
+				break;
+			case '!':
+				// toggle
+				key = key.substring(1);
+				if (insert)
+					params[key] = true;
+				else
+					query.push('doc.{0}=!doc.{0}'.format(key));
+				break;
+			case '=':
+			case '#':
+				// raw
+				key = key.substring(1);
+				if (insert)
+					params[key] = val;
+				else
+					query.push('doc.' + key + '=' + val);
+				break;
+			default:
+				params[key] = val;
+				if (!insert)
+					query.push('doc.{0}=arg.{0}'.format(key));
+				break;
+		}
+	}
+
+	return { query, params };
+}
+
+function makefilter(db, opt, callback) {
+
+	var where = [];
+	var model = {};
+	var isread = false;
+	var args = [];
+	var exec = opt.exec;
+
+	db_where(where, opt, opt.filter, '&&', val => args.push(val) - 1);
+
+	var builder = {};
+	var insert = exec === 'insert';
+
+	if (insert || exec === 'update') {
+		var iu = db_insertupdate(opt, insert);
+		if (iu) {
+			if (insert) {
+				builder.payload = iu.params;
+			} else {
+				builder.modify = iu.query ? iu.query.join(';') : null;
+				builder.modifyarg = iu.params;
+			}
+		}
+	}
+
+	if (FILTER[exec]) {
+		builder.filter = where.join('') || 'true';
+		builder.filterarg = { params: args };
+		builder.take = opt.take;
+		builder.skip = opt.skip;
+		builder.first = opt.first;
+		if (opt.sort && opt.sort.length) {
+			builder.sort = opt.sort.join(',');
+			if (opt.language != null)
+				builder.sort = builder.sort.replace(REG_LANGUAGE, val => (val.substring(0, val.length - 1) + opt.language));
+		}
+	}
+
+	if (opt.fields) {
+		builder.fields = opt.fields.join(',');
+		if (opt.language != null && builder.fields) {
+			builder.fields = builder.fields.replace(REG_LANGUAGE, function(val) {
+				val = val.substring(0, val.length - 1);
+				return val + (opt.language ? (opt.language + ' as ' + val) : '');
+			});
+		}
+	}
+
+	switch (exec) {
+		case 'find':
+			isread = true;
+			db.find2().assign(builder).$callback = callback;
+			break;
+		case 'count':
+			isread = true;
+			builder.scalar = 'arg.count+=1';
+			builder.scalararg = { count: 0 };
+			db.find().assign(builder).$callback = callback;
+			break;
+		case 'check':
+			builder.first = true;
+			isread = true;
+			db.find().assign(builder).$callback = (err, response) => callback(err, !!response);
+			break;
+		case 'list':
+			db.find().assign(builder).$callback = (err, response, meta) => callback(err, err ? null : { items: response, count: meta.count });
+			isread = true;
+			break;
+		case 'read':
+			db.find2().assign(builder).$callback = callback;
+			isread = true;
+			break;
+		case 'insert':
+			db.insert().assign(builder).$callback = callback;
+			break;
+		case 'update':
+			db.update().assign(builder).$callback = callback;
+			break;
+		case 'remove':
+			db.remove().assign(builder).$callback = callback;
+			break;
+		case 'truncate':
+			db.clear(callback);
+			break;
+		case 'drop':
+			db.drop(callback);
+			delete Open[db.$qbkey];
+			break;
+		case 'scalar':
+			switch (opt.scalar.type) {
+				case 'avg':
+				case 'min':
+				case 'sum':
+				case 'max':
+				case 'count':
+					if (opt.scalar.key2) {
+						builder.scalar = 'var k=doc.' + opt.scalar.key + '+\'\';if (arg[k]){tmp.bk=doc.' + opt.scalar.key2 + '||0;' + (opt.scalar.type === 'max' ? 'if(tmp.bk>arg[k])arg[k]=tmp.bk' : opt.scalar.type === 'min' ? 'if(tmp.bk<arg[k])arg[k]=tmp.bk' : 'arg[k]+=tmp.bk') + '}else{arg[k]=doc.' + opt.scalar.key2 + '||0}';
+					} else {
+						builder.scalar = 'if (doc.{0}!=null){tmp.val=doc.{0};arg.count+=1;arg.min=arg.min==null?tmp.val:arg.min>tmp.val?tmp.val:arg.min;arg.max=arg.max==null?tmp.val:arg.max<tmp.val?tmp.val:arg.max;if(!(tmp.val instanceof Date))arg.sum+=tmp.val}'.format(opt.scalar.key);
+						builder.scalararg = { count: 0, sum: 0 };
+					}
+					db.find().assign(builder).$callback = function(err, response) {
+						var output = {};
+						if (response)
+							output.value = opt.scalar.type === 'avg' ? ((response.min + response.max) / 2) : response[opt.scalar.type];
+						callback(err, output);
+					};
+					break;
+				case 'group':
+					builder.scalar = opt.scalar.key2 ? 'if (doc.{0}!=null){tmp.val=doc.{0};arg[tmp.val]=(arg[tmp.val]||0)+(doc.{1}||0)}'.format(opt.scalar.key, opt.scalar.key2) : 'if (doc.{0}!=null){tmp.val=doc.{0};arg[tmp.val]=(arg[tmp.val]||0)+1}'.format(opt.scalar.key);
+					builder.scalararg = {};
+					db.find().assign(builder).$callback = function(err, response) {
+						var output = [];
+						for (var key in response) {
+							var val = response[key];
+							var mod = {};
+							mod[opt.scalar.key] = key;
+							mod.value = val;
+							output.push(mod);
+						}
+						callback(err, output);
+					};
+					break;
+			}
+			isread = true;
+			break;
+		case 'command':
+			if (opt.command === 'clean')
+				db.clean(callback);
+			break;
+	}
+
+	if (opt.debug)
+		console.log(LOGGER, db.filename, exec, builder);
+
+	if (isread)
+		F.stats.performance.dbrm++;
+	else
+		F.stats.performance.dbwm++;
+
+	return model;
+}
+
+function compare_datetype(type, key, paramindex, operator) {
+	switch (operator) {
+		case '=':
+			operator = '==';
+			break;
+		case '<>':
+			operator = '!=';
+			break;
+	}
+	switch (type) {
+		case 'day':
+			type = 'getDate()';
+			break;
+		case 'month':
+			type = 'getMonth()+1';
+			break;
+		case 'year':
+			type = 'getFullYear()';
+			break;
+		case 'hour':
+			type = 'getHour()';
+			break;
+		case 'minute':
+			type = 'getMinute()';
+			break;
+	}
+	return 'doc.{0}&&doc.{0}.getTime?doc.{0}.{3}{2}arg.params[{1}]:false'.format(key.replace(REG_NULLABLE, '?.'), paramindex, operator, type);
+}
+
+F.TQueryBuilder.create('nosql', function($, next) {
+
+	let key = 'nosql_' + $.table;
+
+	if (!Open[key]) {
+		let filename = REG_ABSOLUTE.test($.table) ? $.table : F.path.databases($.table + '.nosql');
+		Open[key] = F.TNoSQL.create(filename);
+		Open[key].$qbkey = key;
+	}
+
+	makefilter(Open[key], $, next);
+});

package/nosql-reader.js

@@ -0,0 +1,353 @@
+// Total.js NoSQL Data reader
+// The MIT License
+// Copyright 2020-2023 (c) Peter Širka <petersirka@gmail.com>
+
+function NoSQLReader(builder) {
+	var self = this;
+	self.ts = Date.now();
+	self.cancelable = true;
+	self.builders = [];
+	self.canceled = 0;
+	self.total = 0;
+
+	if (builder) {
+		self.add(builder);
+		self.prepare();
+	}
+}
+
+NoSQLReader.prototype.add = function(builder) {
+	var self = this;
+	if (builder instanceof Array) {
+		for (var i = 0; i < builder.length; i++)
+			self.add(builder[i]);
+	} else {
+		builder.$NoSQLReader = self;
+		if (builder.$sort)
+			self.cancelable = false;
+		self.builders.push(builder);
+	}
+	return self;
+};
+
+NoSQLReader.prototype.compare2 = function(docs, custom, done) {
+
+	var self = this;
+
+	for (var i = 0; i < docs.length; i++) {
+
+		var doc = docs[i];
+		if (doc === EMPTYOBJECT)
+			continue;
+
+		if (self.builders.length === self.canceled) {
+			self.total = 0;
+			return false;
+		}
+
+		self.total++;
+		var is = false;
+
+		for (var j = 0; j < self.builders.length; j++) {
+
+			var builder = self.builders[j];
+			if (builder.canceled)
+				continue;
+
+			builder.scanned++;
+
+			var can = false;
+
+			try {
+				can = builder.filterrule(doc, builder.filterarg, builder.tmp, builder.func);
+			} catch (e) {
+				can = false;
+				builder.canceled = true;
+				builder.error = e + '';
+			}
+
+			if (can) {
+
+				builder.count++;
+
+				if (!builder.$sort && ((builder.$skip && builder.$skip >= builder.count) || (builder.$take && builder.$take <= builder.counter)))
+					continue;
+
+				if (!is)
+					is = true;
+
+				builder.counter++;
+
+				var canceled = builder.canceled;
+				var c = custom(docs, doc, i, builder, j);
+
+				if (builder.$take === 1) {
+					builder.canceled = true;
+					self.canceled++;
+				} else if (!canceled && builder.canceled)
+					self.canceled++;
+
+				if (c === 1)
+					break;
+				else
+					continue;
+			}
+		}
+
+		is && done && done(docs, doc, i, self.builders);
+	}
+};
+
+// For FILEDB
+NoSQLReader.prototype.compare3 = function(docs, custom) {
+
+	var self = this;
+	var changed = false;
+
+	for (var i = 0; i < docs.length; i++) {
+
+		var doc = docs[i];
+		if (doc === EMPTYOBJECT)
+			continue;
+
+		if (self.builders.length === self.canceled) {
+			self.total = 0;
+			return 0;
+		}
+
+		self.total++;
+
+		for (var j = 0; j < self.builders.length; j++) {
+
+			var builder = self.builders[j];
+			if (builder.canceled)
+				continue;
+
+			builder.scanned++;
+
+			var can = false;
+
+			try {
+				can = builder.filterrule(doc, builder.filterarg, builder.tmp, builder.func);
+			} catch (e) {
+				can = false;
+				builder.canceled = true;
+				builder.error = e + '';
+			}
+
+			if (can) {
+
+				builder.count++;
+
+				if (!builder.$sort && ((builder.$skip && builder.$skip >= builder.count) || (builder.$take && builder.$take <= builder.counter)))
+					continue;
+
+				if (!changed)
+					changed = true;
+
+				builder.counter++;
+
+				var canceled = builder.canceled;
+				var c = custom(docs, doc, i, builder, j);
+
+				if (builder.$take === 1) {
+					builder.canceled = true;
+					self.canceled++;
+				} else if (!canceled && builder.canceled)
+					self.canceled++;
+
+				if (c === 1)
+					break;
+				else
+					continue;
+			}
+		}
+	}
+
+	return changed ? 2 : 1;
+};
+
+NoSQLReader.prototype.compare = function(docs) {
+
+	var self = this;
+	self.total += docs.length;
+
+	for (var i = 0; i < docs.length; i++) {
+		var doc = docs[i];
+
+		if (self.builders.length === self.canceled) {
+			self.total = 0;
+			return false;
+		}
+
+		for (var j = 0; j < self.builders.length; j++) {
+
+			var builder = self.builders[j];
+			if (builder.canceled)
+				continue;
+
+			builder.scanned++;
+
+			var is = false;
+
+			try {
+				is = builder.filterrule(doc, builder.filterarg, builder.tmp, builder.func);
+			} catch (e) {
+				is = false;
+				builder.canceled = true;
+				builder.error = e + '';
+			}
+
+			if (is) {
+
+				builder.count++;
+
+				if (builder.scalarrule) {
+					builder.counter++;
+					try {
+						builder.scalarrule(doc, builder.scalararg, builder.tmp, builder.func);
+					} catch (e) {
+						builder.canceled = true;
+						builder.error = e + '';
+					}
+					continue;
+				}
+
+				if (!builder.$sort && ((builder.$skip && builder.$skip >= builder.count) || (builder.$take && builder.$take <= builder.counter)))
+					continue;
+
+				builder.counter++;
+				builder.push(doc);
+
+				if (self.cancelable && !builder.$sort && !builder.$paginate && builder.response.length === builder.$take) {
+					builder.canceled = true;
+					self.canceled++;
+				}
+			}
+		}
+	}
+};
+
+NoSQLReader.prototype.comparereverse = function(docs) {
+
+	var self = this;
+
+	self.total += docs.length;
+
+	for (var i = docs.length - 1; i > -1; i--) {
+
+		var doc = docs[i];
+
+		if (self.builders.length === self.canceled) {
+			self.total = 0;
+			return false;
+		}
+
+		for (var j = 0; j < self.builders.length; j++) {
+
+			var builder = self.builders[j];
+			if (builder.canceled)
+				continue;
+
+			builder.scanned++;
+
+			var is = false;
+
+			try {
+				is = builder.filterrule(doc, builder.filterarg, builder.tmp, builder.func);
+			} catch (e) {
+				is = false;
+				builder.canceled = true;
+				builder.error = e + '';
+			}
+
+			if (is) {
+
+				builder.count++;
+
+				if (builder.scalarrule) {
+					builder.counter++;
+					try {
+						builder.scalarrule(doc, builder.scalararg, builder.tmp, builder.func);
+					} catch (e) {
+						builder.canceled = true;
+						builder.error = e + '';
+					}
+					continue;
+				}
+
+				if (!builder.$sort && ((builder.$skip && builder.$skip >= builder.count) || (builder.$take && builder.$take <= builder.counter)))
+					continue;
+
+				builder.counter++;
+				builder.push(doc);
+
+				if (self.cancelable && !builder.$sort && builder.response.length === builder.$take) {
+					builder.canceled = true;
+					self.canceled++;
+				}
+			}
+		}
+	}
+};
+
+NoSQLReader.prototype.callback = function(builder) {
+	var self = this;
+
+	if (builder.$sort && !builder.$sorted)
+		sortfinal(builder);
+
+	if (builder.$sort && builder.$take2 && builder.response.length >= builder.$take)
+		builder.response = builder.$skip ? builder.response.splice(builder.$skip, builder.$take) : builder.response.splice(0, builder.$take);
+
+	for (var i = 0; i < builder.response.length; i++)
+		builder.response[i] = builder.prepare(builder.response[i]);
+
+	builder.logrule && builder.logrule();
+	builder.done();
+	return self;
+};
+
+NoSQLReader.prototype.prepare = function() {
+	var self = this;
+	for (var i = 0; i < self.builders.length; i++) {
+		var builder = self.builders[i];
+		if (builder.$take)
+			builder.$take2 = builder.$sort ? ((builder.$skip || 1) + builder.$take) : builder.$take;
+		else
+			builder.$take2 = 0;
+	}
+	return self;
+};
+
+NoSQLReader.prototype.done = function() {
+
+	var self = this;
+	var diff = Date.now() - self.ts;
+
+	if (self.db && self.db.duration) {
+		if (self.total > 0)
+			self.db.total = self.total;
+		if (self.db.duration.push({ type: self.type, duration: diff }) > 20)
+			self.db.duration.shift();
+	}
+
+	for (var i = 0; i < self.builders.length; i++) {
+		var builder = self.builders[i];
+		builder.duration = diff;
+		builder.inmemory = self.inmemory;
+		self.callback(builder);
+	}
+
+	self.diff = diff;
+	self.canceled = 0;
+	return self;
+};
+
+function sortfinal(builder) {
+	builder.response.sort(builder.$sort);
+}
+
+exports.make = function(builder) {
+	return new NoSQLReader(builder);
+};