@resolveio/server-lib 22.3.220 → 22.3.221

package/src/util/common.ts

@@ -0,0 +1,649 @@
+/* eslint-disable no-restricted-properties */
+let rusDiff = require('rus-diff');
+let deepDiff = require('deep-diff').diff;
+import { detailedDiff } from 'deep-object-diff';
+import * as moment from 'moment-timezone';
+import { ObjectId } from 'mongodb';
+import { LookupTables } from '../models/report-builder.model';
+let clone = require('clone');
+
+export function objectIdHexString() {
+	let objectId = new ObjectId();
+	return objectId.toHexString();
+}
+
+export function buildRbSchema(rbSchema: any) {
+	Object.keys(rbSchema).forEach(key => {
+		if (rbSchema[key].type === Object) {
+			rbSchema[key].type = 'Object';
+			rbSchema[key].rbType = 'Object';
+		}
+		else if (rbSchema[key].type === Array) {
+			rbSchema[key].type = 'Array';
+			rbSchema[key].rbType = 'Array';
+		}
+		else if (rbSchema[key].type === String) {
+			rbSchema[key].type = 'String';
+			rbSchema[key].rbType = 'String';
+		}
+		else if (rbSchema[key].type === Date) {
+			rbSchema[key].type = 'Date';
+			rbSchema[key].rbType = 'Date';
+		}
+		else if (rbSchema[key].type === Number) {
+			rbSchema[key].type = 'Number';
+			rbSchema[key].rbType = 'Number';
+		}
+		else if (rbSchema[key].type === Boolean) {
+			rbSchema[key].rbType = 'Boolean';
+			rbSchema[key].type = 'Boolean';
+		}
+	});
+
+	Object.keys(rbSchema).forEach(key => {
+		delete rbSchema[key].type;
+	});
+
+	return rbSchema;
+}
+
+export function buildRbLookups(rbLookups: LookupTables[], defaultSchema: object, default_checked_array: string[] = []) {
+	// Remember: lkp.local_key will be removed later on, because it has 'id_'
+	
+	rbLookups.forEach(lkp => {
+		let errString = '';
+		let localKey, newPropertyName;
+		let localKeyDir = '';
+		let localKeyDirDot = '';
+		let collectionAlias = toTitleCase(lkp.lookup.replace(/\_/g, ' ')) + ' (' + toTitleCase(lkp.local_key.replace('id_', '').replace(/\_/g, ' ').replace(/\.\$\./g, ' -> ').replace(/\./g, ' -> ')) + ') (Lookup)';
+
+		if (lkp.local_key.match(/\./)) {
+			localKey = lkp.local_key.replace(/\.\$/g, '');
+			localKeyDirDot = lkp.local_key.replace(/^(.+\.).*$/, '$1');
+			localKeyDir = localKeyDirDot.replace(/\.$/, '');
+		}
+		else {
+			// local_key is a root leaf node.
+			localKey = lkp.local_key;
+		}
+		newPropertyName = localKeyDirDot + collectionAlias;
+		
+		if (!defaultSchema[lkp.local_key]) {
+			errString += '--local_key: \'' + lkp.local_key + '\' MUST be a valid schema path! ';
+		}
+		else if (defaultSchema[lkp.local_key].type !== String) {
+			errString += '--local_key: \'' + lkp.local_key + '\' MUST be a String! ';
+		}
+		let lookupNode = {
+			lookup_collection: lkp.lookup,
+			lookup_collection_alias: collectionAlias,
+			local_key: localKey,
+			field_path: localKeyDir,
+			lookup_as: newPropertyName,
+			lookup_key: '_id',
+			type: 'Object',
+		};
+
+		defaultSchema[newPropertyName] = lookupNode;
+
+		if (errString) {
+			throwErr(errString, lkp, lookupNode, newPropertyName);
+		}
+	});
+
+	for (let ii = 0; ii < default_checked_array.length; ii++) {
+		defaultSchema[default_checked_array[ii]] = {};
+		defaultSchema[default_checked_array[ii]]['default_checked'] = true;
+		Object.assign(defaultSchema[default_checked_array[ii]], defaultSchema['tree'][default_checked_array[ii]]);
+	}
+
+	return defaultSchema;
+}
+
+export function throwErr(err: any, lkp, lookupNode, newPropertyName = '') {
+	// err could be from a try/throw/catch
+	console.log('------- ERROR thrown by rbLookups: ');
+	console.log(err);
+	console.log('---item: ');
+	console.log(lkp);
+	console.log('---Attempted to create rbSchema[\'' + newPropertyName + '\']: ');
+	console.log(lookupNode);
+	process.exit(1);
+}
+
+export function roundPrecision(value: number, precision = 0) {
+	let stringValue = value.toString();
+	
+	if (stringValue.includes('.')) {
+		if (stringValue[0] === '0') {
+			precision += 1;
+		}
+		
+		precision -= stringValue.indexOf('.');
+	}
+
+	const exponent = Math.pow(10, precision);
+	return Math.round(parseFloat(stringValue) * exponent) / exponent;
+}
+
+export function round(value, precision = 0) {
+	const power = Math.pow(10, precision);
+	const adjustment = 1e-6;
+	return Math.round( (value * power) + adjustment) / power;
+}
+
+export function floorPrecision(value: number, precision = 0) {
+	let stringValue = value.toString();
+	
+	if (stringValue.includes('.')) {
+		if (stringValue[0] === '0') {
+			precision += 1;
+		}
+		
+		precision -= stringValue.indexOf('.');
+	}
+
+	const exponent = Math.pow(10, precision);
+	return Math.floor(parseFloat(stringValue) * exponent) / exponent;
+}
+
+export function deepCopy(value) {
+	return clone(value);
+}
+
+export function dateReviver(key, value) {
+	if (typeof value === 'string') {
+		let a = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/.exec(value);
+		if (a) {
+			return new Date(Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4], +a[5], +a[6].split('.')[0], +a[6].split('.')[1]));
+		}
+	}
+	return value;
+}
+
+function buildAllowedOrigins(configOrigins): string[] {
+	let origins = [];
+
+	if (Array.isArray(configOrigins)) {
+		origins = configOrigins.map(origin => typeof origin === 'string' ? origin.trim() : origin);
+	}
+	else if (typeof configOrigins === 'string') {
+		let splitOrigins = configOrigins.split(',').map(origin => origin.trim()).filter(origin => origin);
+		origins = splitOrigins;
+	}
+
+	return origins.filter(origin => typeof origin === 'string' && origin.trim() !== '');
+}
+
+export function getAllowedOrigins(serverConfig): string[] {
+	let allowedOrigins = new Set<string>();
+	let defaultKeys = ['ROOT_URL', 'SEC_ROOT_URL', 'RESOLVEIO_URL', 'RESOLVEIO_SECONDARY_URL'];
+
+	defaultKeys.forEach(key => {
+		let value = serverConfig[key] || process.env[key];
+		if (typeof value === 'string' && value.trim()) {
+			allowedOrigins.add(value.trim());
+		}
+	});
+
+	buildAllowedOrigins(serverConfig['ALLOWED_ORIGINS']).forEach(origin => allowedOrigins.add(origin));
+	buildAllowedOrigins(serverConfig['ADDITIONAL_ALLOWED_ORIGINS']).forEach(origin => allowedOrigins.add(origin));
+	buildAllowedOrigins(process.env.ALLOWED_ORIGINS).forEach(origin => allowedOrigins.add(origin));
+	buildAllowedOrigins(process.env.ADDITIONAL_ALLOWED_ORIGINS).forEach(origin => allowedOrigins.add(origin));
+
+	return Array.from(allowedOrigins);
+}
+
+export function isAllowedOrigin(origin: string, serverConfig): boolean {
+	if (!origin) {
+		return false;
+	}
+
+	const allowedOrigins = getAllowedOrigins(serverConfig);
+	return allowedOrigins.includes(origin);
+}
+
+export function getMongoUpdates(currDoc, modifiedDoc, incVersion) {
+	if (currDoc.createdAt) {
+		modifiedDoc.createdAt = currDoc.createdAt;
+	}
+
+	if (currDoc.updatedAt) {
+		modifiedDoc.updatedAt = currDoc.updatedAt;
+	}
+
+	let updates = rusDiff.diff(currDoc, modifiedDoc);
+
+	if (updates) {
+		if (updates.$set && !Object.keys(updates.$set).length) {
+			delete updates.$set;
+		}
+
+		if (incVersion) {
+			updates.$inc = {__v: 1};
+		}
+	}
+	else {
+		if (incVersion) {
+			updates = {
+				$inc: {__v: 1}
+			};
+		}
+	}
+
+	return updates;
+}
+
+export function getMongoMergeUpdatedDoc(f_doc, currentDoc, oldDoc) {
+	let upDoc = deepCopy(currentDoc); // was oldDoc
+	upDoc.__v = currentDoc.__v;
+
+	let diff_1 = getDeepDiff(oldDoc, currentDoc);
+	let diff_2 = getDeepDiff(oldDoc, f_doc);
+
+	let updates = mergeUpdates(diff_2, diff_1);
+	applyMongoUpdate(upDoc, updates);
+	return upDoc;
+}
+
+
+export function mergeUpdates(...updatesToMerge) {
+    const merged = {
+        $set: {},
+        $unset: {},
+        $inc: {},
+        $push: {},
+        $pull: {}
+    };
+
+    updatesToMerge.filter(Boolean).forEach(anUpdate => {
+        anUpdate.forEach(change => {
+            const path = change.path.join('.');
+
+            switch (change.kind) {
+                case 'E':
+                    handleEditedChange(merged, path, change);
+                    break;
+                case 'A':
+                    handleArrayChange(merged, path, change);
+                    break;
+                default:
+                    break;
+            }
+        });
+    });
+
+    return merged;
+}
+
+function handleEditedChange(merged, path, change) {
+	// Later diffs override earlier ones
+	if (typeof(change.rhs) === 'number' && (path.includes('quantity') || path.includes('qty'))) {
+		merged.$inc[path] = (merged.$inc[path] || 0) + change.rhs - change.lhs;
+	}
+	else {
+		merged.$set[path] = change.rhs;
+	}
+}
+
+
+function handleArrayChange(merged, path, change) {
+	if (change.item.kind === 'N') {
+		if (!merged.$push[path]) merged.$push[path] = { $each: [] };
+
+		if (!merged.$push[path].$each.some(a => JSON.stringify(a) === JSON.stringify(change.item.rhs))) {
+			merged.$push[path].$each.push(change.item.rhs);
+		}
+	}
+	else if (change.item.kind === 'D') {
+		if (!merged.$pull[path]) merged.$pull[path] = [];
+
+		if (!merged.$pull[path].some(a => JSON.stringify(a) === JSON.stringify(change.item.lhs))) {
+			merged.$pull[path].push(change.item.lhs);
+		}
+	}
+}
+
+export function getDeepDiff(doc1, doc2) {
+	delete doc1._id;
+	delete doc1.__v;
+
+	if (doc1.updatedAt) {
+		delete doc1.updatedAt;
+	}
+
+	if (doc1.createdAt) {
+		delete doc1.createdAt;
+	}
+
+	delete doc2._id;
+	delete doc2.__v;
+
+	if (doc2.updatedAt) {
+		delete doc2.updatedAt;
+	}
+
+	if (doc2.createdAt) {
+		delete doc2.createdAt;
+	}
+
+	return deepDiff(doc1, doc2);
+}
+
+export function applyMongoUpdate(uDoc: any, delta: any): any {
+    const orig = deepCopy(uDoc);
+
+    if (delta) {
+        if (delta.$rename) handleRename(uDoc, delta.$rename);
+        if (delta.$set) handleSet(uDoc, delta.$set);
+        if (delta.$inc) handleInc(uDoc, delta.$inc);
+        if (delta.$unset) handleUnset(uDoc, delta.$unset);
+        if (delta.$pull) handlePull(uDoc, orig, delta.$pull);
+        if (delta.$push) handlePush(uDoc, delta.$push);
+    }
+
+    return uDoc;
+}
+
+function handleRename(uDoc: any, renameMap: any) {
+    for (const k in renameMap) {
+        const v = renameMap[k];
+        const [o1, n1] = resolve(uDoc, k);
+        const [o2, n2] = resolve(uDoc, v);
+        if (o1 && n1.length === 1) {
+            if (o2 && n2.length === 1) {
+                o2[n2[0]] = o1[n1[0]];
+                delete o1[n1[0]];
+            } else {
+                logError(o2, n2, uDoc, v);
+            }
+        } else {
+            logError(o1, n1, uDoc, k);
+        }
+    }
+}
+
+function handleSet(uDoc: any, setMap: any) {
+    for (const k in setMap) {
+        const v = setMap[k];
+        const [o, n] = resolve(uDoc, k, { force: true });
+        if (o && n.length === 1) {
+            o[n[0]] = v;
+        } else {
+            logError(o, n, uDoc, k);
+        }
+    }
+}
+
+function handleInc(uDoc: any, incMap: any) {
+    for (const k in incMap) {
+        const v = incMap[k];
+        const [o, n] = resolve(uDoc, k, { force: true });
+        if (o && n.length === 1) {
+			if (typeof o[n[0]] !== 'number') {
+				o[n[0]] = 0;
+			}
+			o[n[0]] += v;
+        } else {
+            logError(o, n, uDoc, k);
+        }
+    }
+}
+
+function handleUnset(uDoc: any, unsetMap: any) {
+    for (const k in unsetMap) {
+        const [o, n] = resolve(uDoc, k);
+        if (o && n.length === 1) {
+            delete o[n[0]];
+        } else {
+            logError(o, n, uDoc, k);
+        }
+    }
+}
+
+function handlePull(uDoc: any, orig: any, pullMap: any) {
+    for (const pathk in pullMap) {
+        const pullValues = pullMap[pathk];
+        for (let vk of pullValues) {
+            const [o, n] = resolve(uDoc, pathk);
+            const [o2, n2] = resolve(orig, pathk);
+            if (o && n.length === 1) {
+				const index = (<Array<any>>o2[n2[0]]).findIndex(z => JSON.stringify(z) === JSON.stringify(vk));
+				if (index !== -1) {
+					o[n[0]].splice(index, 1);
+				}
+            } else {
+                logError(o, n, uDoc, pathk);
+            }
+        }
+    }
+}
+
+function handlePush(uDoc: any, pushMap: any) {
+	for (const pathk in pushMap) {
+		const pushValues = pushMap[pathk];
+
+		// Normalize ─ accept $each, scalar, or array
+		let values: any[] = [];
+		if (Array.isArray(pushValues)) {
+			values = pushValues;
+		}
+		else if (pushValues && typeof pushValues === 'object') {
+			if (Array.isArray(pushValues.$each)) {
+				values = pushValues.$each;          // canonical `$each`
+			} else {
+				values = [pushValues];              // single element object
+			}
+		}
+		else {
+			values = [pushValues];                  // scalar push
+		}
+
+		for (const vk of values) {
+			const [o, n] = resolve(uDoc, pathk);
+			if (o && n.length === 1 && Array.isArray(o[n[0]])) {
+				o[n[0]].push(vk);
+			}
+			else {
+				logError(o, n, uDoc, pathk);
+			}
+		}
+	}
+}
+
+function logError(o: any, n: any, uDoc: any, key: any) {
+    console.log('Error', o + '/' + n + ' - couldn\'t resolve for ' + JSON.stringify(uDoc) + ' ' + key);
+}
+
+function resolve(a: any, path: string, options: any = {}): [any, any] {
+    const stack = arrize(path);
+    let last = [];
+
+    if (stack.length > 0) {
+        last.unshift(stack.pop());
+    }
+
+    let e = a;
+    while (stack.length > 0) {
+        const k = stack.shift();
+        if (e[k] !== void 0) {
+            e = e[k];
+        } else {
+            if (!options.force) {
+                last.unshift(k);
+                last = stack.concat(last);
+                break;
+            }
+            const isNextNum = typeof stack[0] === 'number';
+            const isLastNum = stack.length === 0 && typeof last[0] === 'number';
+            e[k] = isNextNum || isLastNum ? [] : {};
+            e = e[k];
+        }
+    }
+
+    return [e, last];
+}
+
+function arrize(path: any, glue: string = '.'): string[] {
+    if (Array.isArray(path)) {
+        return path.slice();
+    }
+
+    if (path === void 0 || path === null || path === false || path === '') {
+        return [];
+    }
+
+    return path.toString().split(glue)
+        .map(e => {
+            if ([void 0, null, false, ''].includes(e)) {
+                return null;
+            }
+            return e.toString();
+        })
+        .filter(e => e !== null);
+}
+
+export function deepDiffDetails(object1: Object, object2: Object): string {
+    let obj1 = deepCopy(object1);
+	let obj2 = deepCopy(object2);
+
+	let diff = detailedDiff(obj1, obj2);
+	let diffString = '';
+
+	const formatValue = (value: any): string => {
+		if (value instanceof Date) {
+			return moment(value).format('llll');
+		} 
+		else if (typeof value === 'object' && value !== null) {
+			Object.keys(value).filter(a => a.startsWith('_id') || a.startsWith('id_')).forEach(key => {
+				delete value[key];
+			});
+			return JSON.stringify(value); // Pretty print objects
+		} 
+		else {
+			return typeof value === 'string' ? `"${value}"` : String(value);
+		}
+	};
+
+	const customArrayDiff = (arr1: any[], arr2: any[]): string => {
+        let arrayDiffResults = [];
+        const maxLength = Math.max(arr1.length, arr2.length);
+
+        for (let i = 0; i < maxLength; i++) {
+            if (arr1[i] && !arr2[i]) {
+                arrayDiffResults.push(`Removed at index ${i}: ${formatValue(arr1[i])}`);
+            } 
+			else if (!arr1[i] && arr2[i]) {
+                arrayDiffResults.push(`Added at index ${i}: ${formatValue(arr2[i])}`);
+            } 
+			else if (arr1[i] && arr2[i] && JSON.stringify(arr1[i]) !== JSON.stringify(arr2[i])) {
+                arrayDiffResults.push(`Changed at index ${i}: {${formatObjectDiff(arr1[i], arr2[i])}}`);
+            }
+        }
+
+        return arrayDiffResults.join(', ');
+    };
+
+	const formatObjectDiff = (obj1: any, obj2: any): string => {
+		if (obj1 === null || obj2 === null || typeof obj1 !== 'object' || typeof obj2 !== 'object') {
+			return `from: ${formatValue(obj1)} to: ${formatValue(obj2)}`;
+		}
+
+		if (Array.isArray(obj1) || Array.isArray(obj2)) {
+			return customArrayDiff(Array.isArray(obj1) ? obj1 : [], Array.isArray(obj2) ? obj2 : []);
+		}
+
+		return Object.keys({...obj1, ...obj2}).filter(a => !a.startsWith('_id') && !a.startsWith('id_')).map(key => {
+			const obj1Val = obj1 ? obj1[key] : undefined;
+			const obj2Val = obj2 ? obj2[key] : undefined;
+			return `${toTitleCase(key)}: ${formatObjectDiff(obj1Val, obj2Val)}`;
+		}).join(', ');
+	};
+
+	// Handle each diff type
+	['added', 'deleted', 'updated'].forEach(diffType => {
+		if (Object.keys(diff[diffType]).length > 0) {
+			const updates = Object.keys(diff[diffType])
+				.filter(key => diffType === 'added' ? true : (diffType === 'deleted' ? !diff['added'][key] : !diff['added'][key] && !diff['deleted'][key]))
+				.filter(key => !key.startsWith('_id') && !key.startsWith('id_'))
+				.map(key => `\n${toTitleCase(key)}: ${formatObjectDiff(obj1[key], obj2[key])}`)
+				.join(',');
+
+			diffString += updates ? `${updates}` : '';
+		}
+	});
+
+	return diffString;
+}
+
+export function getBinarySize(string) {
+	if (string) {
+		return Buffer.byteLength(string, 'utf8');
+	}
+	else {
+		return 0;
+	}
+}
+
+export function pad(num, size) {
+	let s = num + '';
+	while (s.length < size) { s = '0' + s; }
+	return s;
+}
+
+export function randomString(length, chars) {
+	let result = '';
+	for (let i = length; i > 0; --i) { result += chars[Math.floor(Math.random() * chars.length)]; }
+	return result;
+}
+
+export function toTitleCase(str) {
+	return str.replace(/\w\S*/g, function(txt){
+		return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
+	});
+}
+
+export function isObject(item) {
+	return (item && typeof item === 'object' && !Array.isArray(item));
+}
+
+export function mergeDeep(target, ...sources) {
+	if (!sources.length) {
+		return target;
+	}
+	const source = sources.shift();
+
+	if (isObject(target) && isObject(source)) {
+		for (const key in source) {
+			if (isObject(source[key])) {
+				if (!target[key]) {
+					Object.assign(target, { [key]: {} });
+				}
+				mergeDeep(target[key], source[key]);
+			} 
+			else {
+				Object.assign(target, { [key]: source[key] });
+			}
+		}
+	}
+
+	return mergeDeep(target, ...sources);
+}
+
+export function generateSearchTokensFromFields(doc: any, fields: string[]): string[] {
+	const tokens = new Set<string>();
+
+	fields.forEach(field => {
+		const val = doc[field];
+		if (typeof val === 'string' && val.trim().length) {
+			const words = val.toLowerCase().split(/\s+/);
+			words.forEach(word => {
+				for (let i = 3; i <= word.length; i++) {
+					tokens.add(word.slice(0, i)); // prefix-based tokens only
+				}
+			});
+		}
+	});
+
+	return Array.from(tokens);
+}