@resolveio/server-lib 22.3.18 → 22.3.19

package/src/util/report-builder-unwinds.ts

@@ -0,0 +1,180 @@
+export function normalizeLookupField(path: string) {
+	if (!path) {
+		return path;
+	}
+
+	let cleaned = path.replace(/\.\$/g, '');
+	cleaned = cleaned.replace(/^[^\.]*\(.*?Lookup.*?\)\.?/, '');
+
+	return cleaned;
+}
+
+function buildSafeSizeExpression(sourceExpr: string) {
+	return {$size: {$cond: [{$isArray: sourceExpr}, sourceExpr, []]}};
+}
+
+export function ensureLookupLocalKeyUnwinds(options: {query: any[]; sizes: string[]; lookupLocalKey: string; lookupAs?: string}) {
+	const {query, sizes, lookupLocalKey, lookupAs = ''} = options || {};
+
+	if (!lookupLocalKey || typeof lookupLocalKey !== 'string') {
+		return;
+	}
+
+	if (!query || !Array.isArray(query) || !sizes || !Array.isArray(sizes)) {
+		return;
+	}
+
+	let unwindPathSeed = lookupLocalKey;
+
+	// Some lookup local keys are stored without `.$` even when sourced from array paths.
+	// Infer the array segment from lookup alias and synthesize the unwind marker.
+	if (!unwindPathSeed.includes('.$') && typeof lookupAs === 'string' && lookupAs.includes('.$.')) {
+		const inferredArrayPrefix = lookupAs.split('.$.')[0];
+		if (inferredArrayPrefix) {
+			if (unwindPathSeed.startsWith(inferredArrayPrefix + '.')) {
+				unwindPathSeed = inferredArrayPrefix + '.$.' + unwindPathSeed.substring(inferredArrayPrefix.length + 1);
+			}
+			else {
+				unwindPathSeed = inferredArrayPrefix + '.$';
+			}
+		}
+	}
+
+	if (!unwindPathSeed.includes('.$')) {
+		return;
+	}
+
+	const fieldData = unwindPathSeed.split('.$');
+	let fieldPath = '';
+
+	for (let i = 0; i < fieldData.length - 1; i++) {
+		fieldPath += fieldData[i];
+		const sizeKey = fieldPath.replace(/\./g, '_');
+		if (!sizes.includes(sizeKey)) {
+			sizes.push(sizeKey);
+		}
+
+		if (!query.some(a => a && a.$addFields && Object.keys(a.$addFields).includes('size_' + sizeKey))) {
+			const sourceExpr = '$' + fieldPath;
+			query.push({$addFields: {['size_' + sizeKey]: buildSafeSizeExpression(sourceExpr)}});
+		}
+
+		const unwindPath = '$' + fieldPath;
+		if (!query.some(a => a && a.$unwind && a.$unwind.path === unwindPath)) {
+			query.push({'$unwind': {path: unwindPath, preserveNullAndEmptyArrays: true}});
+		}
+	}
+}
+
+export function applyLinkFieldUnwinds(options: {
+	query: any[];
+	sizes: string[];
+	fieldsLink: any[];
+	selectedFields?: any[];
+	filterArrayFields?: any[];
+	groupsRow?: any[];
+}) {
+	const {query, sizes, fieldsLink, selectedFields = [], filterArrayFields = [], groupsRow = []} = options || {};
+
+	if (!query || !Array.isArray(query) || !sizes || !Array.isArray(sizes) || !Array.isArray(fieldsLink) || !fieldsLink.length) {
+		return;
+	}
+
+	const leafByPath = new Map<string, any>();
+
+	(selectedFields || []).forEach(field => {
+		if (field?.fieldPath && !leafByPath.has(field.fieldPath)) {
+			leafByPath.set(field.fieldPath, field);
+		}
+	});
+
+	(filterArrayFields || []).forEach(field => {
+		if (field?.fieldPath && !leafByPath.has(field.fieldPath)) {
+			leafByPath.set(field.fieldPath, field);
+		}
+	});
+
+	(groupsRow || []).forEach(group => {
+		if (group?.treeItem?.fieldPath && !leafByPath.has(group.treeItem.fieldPath)) {
+			leafByPath.set(group.treeItem.fieldPath, group.treeItem);
+		}
+	});
+
+	const hasUnwindPath = (unwindPath: string) => {
+		return query.some(a => a && a.$unwind && a.$unwind.path === unwindPath);
+	};
+
+	const ensureUnwindsForPath = (targetPath: string) => {
+		if (!targetPath || typeof targetPath !== 'string' || !targetPath.includes('.$')) {
+			return;
+		}
+
+		const leaf = leafByPath.get(targetPath);
+
+		const fieldData = targetPath.split('.$');
+		let fieldPath = '';
+
+		for (let i = 0; i < fieldData.length - 1; i++) {
+			fieldPath += fieldData[i];
+
+			const lastSegment = fieldPath.split('.$')[fieldPath.split('.$').length - 1];
+			const hasLookup = (lastSegment || '').includes('(Lookup') || (leaf?.lookup_as && fieldPath === leaf.lookup_as);
+
+			if (hasLookup && leaf?.lookup_collection && leaf?.lookup_as) {
+				ensureLookupLocalKeyUnwinds({
+					query,
+					sizes,
+					lookupLocalKey: leaf.lookup_local_key || '',
+					lookupAs: leaf.lookup_as || ''
+				});
+
+				const lookupAsRaw = leaf.lookup_as || '';
+				const lookupAs = lookupAsRaw.replace(/\.\$/g, '');
+				const hasLookupStage = query.some(a => a && a.$lookup && a.$lookup.as === lookupAs);
+
+				if (!hasLookupStage) {
+					query.push({$lookup: {
+						from: leaf.lookup_collection,
+						localField: normalizeLookupField(leaf.lookup_local_key || ''),
+						foreignField: normalizeLookupField(leaf.lookup_foreign_key || ''),
+						as: lookupAs
+					}});
+				}
+
+				const sizeKey = lookupAsRaw.replace(/\.\$\./g, '_').replace(/\./g, '_');
+				if (!query.some(a => a && a.$addFields && Object.keys(a.$addFields).includes('size_' + sizeKey))) {
+					sizes.push(sizeKey);
+					const sourceExpr = '$' + lookupAs;
+					query.push({$addFields: {['size_' + sizeKey]: buildSafeSizeExpression(sourceExpr)}});
+				}
+
+				const unwindPath = '$' + lookupAs;
+				if (!hasUnwindPath(unwindPath)) {
+					query.push({'$unwind': {path: unwindPath, preserveNullAndEmptyArrays: true}});
+				}
+			}
+			else {
+				const sizeKey = fieldPath.replace(/\.\$\./g, '.').replace(/\./g, '_');
+				if (!query.some(a => a && a.$addFields && Object.keys(a.$addFields).includes('size_' + sizeKey))) {
+					sizes.push(sizeKey);
+					const sourceExpr = '$' + fieldPath.replace(/\.\$\./g, '.');
+					query.push({$addFields: {['size_' + sizeKey]: buildSafeSizeExpression(sourceExpr)}});
+				}
+
+				const unwindPath = '$' + fieldPath.replace(/\.\$\./g, '.');
+				if (!hasUnwindPath(unwindPath)) {
+					query.push({'$unwind': {path: unwindPath, preserveNullAndEmptyArrays: true}});
+				}
+			}
+
+			fieldPath += '.$';
+		}
+	};
+
+	(fieldsLink || [])
+		.filter(a => a && a.field_first && a.field_second)
+		.forEach(link => {
+			ensureUnwindsForPath(link.field_first);
+			ensureUnwindsForPath(link.field_second);
+		});
+}

package/src/util/schema-report-builder.ts

@@ -0,0 +1,448 @@
+import { CollectionTree } from '../models/report-builder.model';
+import { ResolveIOServer } from '../resolveio-server-app';
+import { toTitleCase } from './common';
+
+function assertLookupCollection(collectionName: string, referringField?: string) {
+	let collectionModel = ResolveIOServer.getMongoManager().collection(collectionName);
+
+	if (!collectionModel) {
+		let context = referringField ? ` referenced by '${referringField}'` : '';
+		throw new Error(`Report Builder: collection '${collectionName}'${context} is not registered.`);
+	}
+
+	if (!collectionModel.useRB || !collectionModel.rbSchema) {
+		let context = referringField ? ` referenced by '${referringField}'` : '';
+		throw new Error(`Report Builder: collection '${collectionName}'${context} is not configured for Report Builder.`);
+	}
+
+	return collectionModel;
+}
+
+export function getReportLookupSchemas(collection_root: string) {
+	let lookupTrees: CollectionTree[] = [];
+	let processedCollections = new Set<string>();
+	let pendingCollections: Array<{ name: string; isRoot: boolean; referringField?: string }> = [{ name: collection_root, isRoot: true }];
+
+	while (pendingCollections.length) {
+		let current = pendingCollections.shift();
+
+		if (!current) {
+			continue;
+		}
+
+		if (processedCollections.has(current.name)) {
+			continue;
+		}
+
+		let collectionModel = assertLookupCollection(current.name, current.referringField);
+		let schemaObj = collectionModel.rbSchema;
+
+		lookupTrees.push({ collection_name: current.name, tree: schemaObj, is_root: current.isRoot });
+		processedCollections.add(current.name);
+
+		Object.keys(schemaObj).forEach(field => {
+			if (schemaObj[field].lookup_collection && !processedCollections.has(schemaObj[field].lookup_collection)) {
+				pendingCollections.push({
+					name: schemaObj[field].lookup_collection,
+					isRoot: false,
+					referringField: `${current.name}.${field}`
+				});
+			}
+		});
+	}
+
+	return lookupTrees;
+}
+
+export function buildTree(current_root, schemaTree, lookup?) {
+	let res = [];
+
+	Object.keys(schemaTree).filter(a => a !== '__v').forEach(key => {
+	// Object.keys(schemaTree).filter(a => a !== '__v').forEach(key => {
+		if (!lookup || (lookup && !schemaTree[key].lookup_collection)) {
+			let treeItemSplit = key.split('.');
+		
+			// debugger;
+
+			if (treeItemSplit.length === 1) {
+				if (schemaTree[key].rbType === 'String' || schemaTree[key].rbType === 'Number' || schemaTree[key].rbType === 'Boolean' || schemaTree[key].rbType === 'Date') {
+					res.push({
+						collection_name: current_root,
+						columnName: toTitleCase(key.replace(/\_/g, ' ')),
+						fieldName: key,
+						fieldType: schemaTree[key].rbType,
+						fieldTypeName: schemaTree[key].rbType === 'String' ? 'Text' : (schemaTree[key].rbType === 'Boolean' ? 'T/F' : schemaTree[key].rbType),
+						distinctFieldValues: [],
+						fieldPath: lookup ? lookup.lookup_as + '.$.' + key : key,
+						fieldPathName: lookup ? (toTitleCase(lookup.lookup_as.replace(/\.\$\./g, ' (List) -> ').replace(/\./g, ' (Group) -> '))) + ' (List) -> ' + (toTitleCase(key.replace(/\.\$\./g, ' (List) -> ').replace(/\./g, ' (Group) -> '))) : toTitleCase(key.replace(/\.\$\./g, ' (List) -> ').replace(/\./g, ' (Group) -> ')),
+						lookup_collection: lookup ? lookup.lookup_collection : (schemaTree[key].lookup_collection ? schemaTree[key].lookup_collection : ''),
+						lookup_local_key: lookup ? lookup.lookup_local_key : (schemaTree[key].lookup_collection ? schemaTree[key].local_key : ''),
+						lookup_foreign_key: lookup ? lookup.lookup_foreign_key : (schemaTree[key].lookup_collection ? schemaTree[key].lookup_key : ''),
+						lookup_as: lookup ? lookup.lookup_as : (schemaTree[key].lookup_collection ? schemaTree[key].lookup_as : ''),
+						text: toTitleCase(key.replace(/\_/g, ' ')),
+						value: key,
+						isLeaf: true,
+						isActive: false,
+						isSelected: false,
+						depth: 0,
+						leafValueType: '',
+						leafValueTypes: getLeafValueTypes(schemaTree[key], key),
+						leafFormatType: '',
+						leafFormatTypes: getLeafFormatTypes(schemaTree[key], key)
+					});
+				}
+				else {
+					res.push({
+						collection_name: current_root,
+						columnName: toTitleCase(key.replace(/\_/g, ' ')),
+						fieldName: key,
+						fieldType: schemaTree[key].lookup_collection ? 'Lookup' : schemaTree[key].rbType,
+						fieldTypeName: schemaTree[key].lookup_collection ? 'Lookup' : (schemaTree[key].rbType === 'Array' ? 'List' : 'Group'),
+						distinctFieldValues: [],
+						fieldPath: lookup ? lookup.lookup_as + '.$.' + key : key,
+						fieldPathName: lookup ? (toTitleCase(lookup.lookup_as.replace(/\.\$\./g, ' (List) -> ').replace(/\./g, ' (Group) -> '))) + ' (List) -> ' + (toTitleCase(key.replace(/\.\$\./g, ' (List) -> ').replace(/\./g, ' (Group) -> '))) : toTitleCase(key.replace(/\.\$\./g, ' (List) -> ').replace(/\./g, ' (Group) -> ')),
+						lookup_collection: lookup ? lookup.lookup_collection : (schemaTree[key].lookup_collection ? schemaTree[key].lookup_collection : ''),
+						lookup_local_key: lookup ? lookup.lookup_local_key : (schemaTree[key].lookup_collection ? schemaTree[key].local_key : ''),
+						lookup_foreign_key: lookup ? lookup.lookup_foreign_key : (schemaTree[key].lookup_collection ? schemaTree[key].lookup_key : ''),
+						lookup_as: lookup ? lookup.lookup_as : (schemaTree[key].lookup_collection ? schemaTree[key].lookup_as : ''),
+						text: toTitleCase(key.replace(/\_/g, ' ')),
+						value: key,
+						isLeaf: false,
+						isActive: false,
+						isSelected: false,
+						depth: 0,
+						leafValueType: '',
+						leafFormatType: '',
+						children: []
+					});
+				}
+
+				res = res.sort((a, b) => a.fieldName.localeCompare(b.fieldName));
+			}
+			else {
+				let child = null;
+
+				treeItemSplit.forEach((layer, index) => {
+					if (!child) {
+						child = res.find(a => a.fieldName === layer);
+					}
+					else {
+						if (child.children.find(a => a.fieldName === layer)) {
+							child = child.children.find(a => a.fieldName === layer);
+						}
+						else {
+							if (schemaTree[key].rbType === 'String' || schemaTree[key].rbType === 'Number' || schemaTree[key].rbType === 'Boolean' || schemaTree[key].rbType === 'Date') {							
+								child.children.push({
+									collection_name: current_root,
+									columnName: toTitleCase(key.replace(/\_/g, ' ')),
+									fieldName: layer,
+									fieldType: schemaTree[key].rbType,
+									fieldTypeName: schemaTree[key].rbType === 'String' ? 'Text' : (schemaTree[key].rbType === 'Boolean' ? 'T/F' : schemaTree[key].rbType),
+									distinctFieldValues: [],
+									fieldPath: lookup ? lookup.lookup_as + '.$.' + key : key,
+									fieldPathName: lookup ? (toTitleCase(lookup.lookup_as.replace(/\.\$\./g, ' (List) -> ').replace(/\./g, ' (Group) -> '))) + ' (List) -> ' + (toTitleCase(key.replace(/\.\$\./g, ' (List) -> ').replace(/\./g, ' (Group) -> '))) : toTitleCase(key.replace(/\.\$\./g, ' (List) -> ').replace(/\./g, ' (Group) -> ')),
+									lookup_collection: lookup ? lookup.lookup_collection : (schemaTree[key].lookup_collection ? schemaTree[key].lookup_collection : ''),
+									lookup_local_key: lookup ? lookup.lookup_local_key : (schemaTree[key].lookup_collection ? schemaTree[key].local_key : ''),
+									lookup_foreign_key: lookup ? lookup.lookup_foreign_key : (schemaTree[key].lookup_collection ? schemaTree[key].lookup_key : ''),
+									lookup_as: lookup ? lookup.lookup_as : (schemaTree[key].lookup_collection ? schemaTree[key].lookup_as : ''),
+									text: toTitleCase(layer.replace(/\_/g, ' ')),
+									value: layer,
+									isLeaf: true,
+									isActive: false,
+									isSelected: false,
+									depth: index,
+									leafValueType: '',
+									leafValueTypes: getLeafValueTypes(schemaTree[key], key),
+									leafFormatType: '',
+									leafFormatTypes: getLeafFormatTypes(schemaTree[key], key)
+								});
+							}
+							else {
+								child.children.push({
+									collection_name: current_root,
+									columnName: toTitleCase(key.replace(/\_/g, ' ')),
+									fieldName: layer,
+									fieldType: schemaTree[key].lookup_collection ? 'Lookup' : schemaTree[key].rbType,
+									fieldTypeName: schemaTree[key].lookup_collection ? 'Lookup' : (schemaTree[key].rbType === 'Array' ? 'List' : 'Group'),
+									distinctFieldValues: [],
+									fieldPath: lookup ? lookup.lookup_as + '.$.' + key : key,
+									fieldPathName: lookup ? (toTitleCase(lookup.lookup_as.replace(/\.\$\./g, ' (List) -> ').replace(/\./g, ' (Group) -> '))) + ' (List) -> ' + (toTitleCase(key.replace(/\.\$\./g, ' (List) -> ').replace(/\./g, ' (Group) -> '))) : toTitleCase(key.replace(/\.\$\./g, ' (List) -> ').replace(/\./g, ' (Group) -> ')),
+									lookup_collection: lookup ? lookup.lookup_collection : (schemaTree[key].lookup_collection ? schemaTree[key].lookup_collection : ''),
+									lookup_local_key: lookup ? lookup.lookup_local_key : (schemaTree[key].lookup_collection ? schemaTree[key].local_key : ''),
+									lookup_foreign_key: lookup ? lookup.lookup_foreign_key : (schemaTree[key].lookup_collection ? schemaTree[key].lookup_key : ''),
+									lookup_as: lookup ? lookup.lookup_as : (schemaTree[key].lookup_collection ? schemaTree[key].lookup_as : ''),
+									text: toTitleCase(layer.replace(/\_/g, ' ')),
+									value: layer,
+									isLeaf: false,
+									isActive: false,
+									isSelected: false,
+									depth: index,
+									leafValueType: '',
+									leafFormatType: '',
+									children: []
+								});
+							}
+
+							child.children = child.children.sort((a, b) => a.fieldName.localeCompare(b.fieldName));
+						}
+					}
+				});
+			}
+		}
+	});
+
+	return res;
+}
+
+// eslint-disable-next-line no-unused-vars
+export function getLeafValueTypes(schemaTree, fieldPath) {
+	let leafTypes = [];
+
+	if (schemaTree.rbType === 'String') {
+		leafTypes = [
+			{
+				text: 'As Value',
+				value: 'Value'
+			},
+			{
+				text: 'Unique',
+				value: 'Unique'
+			},
+			{
+				text: 'As Count',
+				value: 'Count'
+			},
+			{
+				text: 'First',
+				value: 'First'
+			},
+			{
+				text: 'Last',
+				value: 'Last'
+			}
+		];
+	}
+	else if (schemaTree.rbType === 'Number') {
+		leafTypes = [
+			{
+				text: 'As Value',
+				value: 'Value'
+			},
+			{
+				text: 'Unique',
+				value: 'Unique'
+			},
+			{
+				text: 'As Average',
+				value: 'Average'
+			},
+			{
+				text: 'As Count',
+				value: 'Count'
+			},
+			{
+				text: 'As Sum',
+				value: 'Sum'
+			},
+			{
+				text: 'Minimum',
+				value: 'Minimum'
+			},
+			{
+				text: 'Maximum',
+				value: 'Maximum'
+			},
+			{
+				text: 'First',
+				value: 'First'
+			},
+			{
+				text: 'Last',
+				value: 'Last'
+			}
+		];
+	}
+	else if (schemaTree.rbType === 'Boolean') {
+		leafTypes = [
+			{
+				text: 'As Value',
+				value: 'Value'
+			},
+			{
+				text: 'Unique',
+				value: 'Unique'
+			},
+			{
+				text: 'As Count',
+				value: 'Count'
+			},
+			{
+				text: 'First',
+				value: 'First'
+			},
+			{
+				text: 'Last',
+				value: 'Last'
+			}
+		];
+	}
+	else if (schemaTree.rbType === 'Date') {
+		leafTypes = [
+			{
+				text: 'As Value',
+				value: 'Value'
+			},
+			{
+				text: 'Unique',
+				value: 'Unique'
+			},
+			{
+				text: 'As Count',
+				value: 'Count'
+			},
+			{
+				text: 'Minimum',
+				value: 'Minimum'
+			},
+			{
+				text: 'Maximum',
+				value: 'Maximum'
+			},
+			{
+				text: 'First',
+				value: 'First'
+			},
+			{
+				text: 'Last',
+				value: 'Last'
+			}
+		];
+	}
+	return leafTypes;
+}
+
+// eslint-disable-next-line no-unused-vars
+export function getLeafFormatTypes(schemaTree, fieldPath) {
+	let leafTypes = [];
+
+	if (schemaTree.rbType === 'String') {
+		leafTypes = [
+			{
+				text: 'As Text',
+				value: 'String'
+			},
+			{
+				text: 'As Number',
+				value: 'Number'
+			}
+		];
+	}
+	else if (schemaTree.rbType === 'Number') {
+		leafTypes = [
+			{
+				text: 'As Number',
+				value: 'Number'
+			},
+			{
+				text: 'As Currency',
+				value: 'Currency'
+			},
+			{
+				text: 'As Text',
+				value: 'String'
+			}
+		];
+	}
+	else if (schemaTree.rbType === 'Boolean') {
+		leafTypes = [
+			{
+				text: 'As Number',
+				value: 'Number'
+			},
+			{
+				text: 'As Boolean (True/False)',
+				value: 'Boolean'
+			},
+			{
+				text: 'As Text (Yes/No)',
+				value: 'String'
+			},
+			{
+				text: 'As Number (1/0)',
+				value: 'Boolean_Number'
+			}
+		];
+	}
+	else if (schemaTree.rbType === 'Date') {
+		leafTypes = [
+			{
+				text: 'As Number',
+				value: 'Number'
+			},
+			{
+				text: 'As Date (Short Format)',
+				value: 'Date'
+			}, 
+			{
+				text: 'As Time (Short Format)',
+				value: 'Time'
+			}, 
+			{
+				text: 'As Date/Time (Short Format)',
+				value: 'DateTime'
+			}, 
+			{
+				text: 'As Date (Long Format)',
+				value: 'Date_long'
+			},
+			{
+				text: 'As Date/Time (Long Format)',
+				value: 'DateTime_long'
+			}, 
+			{
+				text: 'As Timestamp (MS since 1970)',
+				value: 'Timestamp'
+			}
+		];
+	}
+	return leafTypes;
+}
+
+
+
+
+
+export async function mongoCommand(commandstr: string, collection: string, field?: any) {
+	let tmpObj;
+	try {
+		// Count the number of non-empty fields in a given collection:
+		if (commandstr === 'count') {
+			let obj = {
+				count: collection,
+				query: {}
+			};
+			obj.query[field] = {$ne: null};
+			tmpObj = await ResolveIOServer.getMainDB().command(obj);
+		}
+		// Get all distinct values in a given field.
+		else if (commandstr === 'distinct') {
+			let obj = {
+				distinct: collection,
+				query: {},
+				key: field,
+			};
+			tmpObj = await ResolveIOServer.getMainDB().command(obj);
+		}
+		else if (commandstr === 'listIndexes') {
+			// tmpObj = await this.mainDb.db[collection].getIndexes();
+			// let obj = { 'listIndexes': collection };
+			// tmpObj = await this.mainDb.db.getIndexes(obj);
+		}
+	} catch {
+		// console.log('----------- mongoCommand err: ', err);
+		return -1;
+	}
+	if (tmpObj) {
+		return tmpObj.values;
+	}
+}