@resolveio/server-lib 22.3.54 → 22.3.55

package/src/methods/collections.ts

@@ -0,0 +1,641 @@
+import SimpleSchema from 'simpl-schema';
+import { MethodManager } from '../managers/method.manager';
+import { PaginationOptions, PaginationOptionsSchema } from '../models/pagination.model';
+import { ResolveIOServer } from '../resolveio-server-app';
+import { deepCopy, getMongoMergeUpdatedDoc, objectIdHexString } from '../util/common';
+
+const ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/;
+const INVOICE_COLLECTION = 'invoices';
+const SUPPORT_TICKET_COLLECTION = 'support-tickets';
+const SUPPORT_TICKET_SYSTEM_USER_ID = 'resolveio';
+const SUPPORT_TICKET_SYSTEM_USER = 'ResolveIO';
+
+function coerceDateValue(value: unknown): unknown {
+	if (value instanceof Date) {
+		return value;
+	}
+
+	if (typeof value !== 'string' || !ISO_DATE_REGEX.test(value)) {
+		return value;
+	}
+
+	const parsed = new Date(value);
+	return Number.isNaN(parsed.getTime()) ? value : parsed;
+}
+
+function coerceDatePath(target: any, segments: string[]) {
+	if (!target || !segments.length) {
+		return;
+	}
+
+	const [segment, ...rest] = segments;
+
+	if (segment === '$') {
+		if (Array.isArray(target)) {
+			target.forEach(item => coerceDatePath(item, rest));
+		}
+		return;
+	}
+
+	if (!Object.prototype.hasOwnProperty.call(target, segment)) {
+		return;
+	}
+
+	if (rest.length === 0) {
+		const updatedValue = coerceDateValue(target[segment]);
+		if (updatedValue !== target[segment]) {
+			target[segment] = updatedValue;
+		}
+		return;
+	}
+
+	coerceDatePath(target[segment], rest);
+}
+
+function coerceDateFields(collectionRef: any, doc: any) {
+	if (!collectionRef || !collectionRef.simplschema || !doc) {
+		return;
+	}
+
+	const schema = collectionRef.simplschema;
+	const schemaKeys = Object.keys(schema.schema());
+
+	schemaKeys.forEach(schemaKey => {
+		const definition = schema.schema(schemaKey);
+		const typeDefs = definition?.type?.definitions;
+		if (!typeDefs || !typeDefs.some(typeDef => typeDef.type === Date)) {
+			return;
+		}
+
+		coerceDatePath(doc, schemaKey.split('.'));
+	});
+}
+
+function normalizeSupportTicketMessage(message: any): any {
+	if (!message || typeof message !== 'object' || Array.isArray(message)) {
+		return message;
+	}
+
+	const normalizedMessage = {
+		...message
+	};
+	const currentIdUser = typeof normalizedMessage.id_user === 'string' ? normalizedMessage.id_user.trim() : '';
+	if (currentIdUser) {
+		return normalizedMessage;
+	}
+
+	const normalizedUser = String(normalizedMessage.user || '').trim().toLowerCase();
+	const normalizedType = String(normalizedMessage.type || '').trim().toLowerCase();
+	const normalizedSource = String(normalizedMessage.source || '').trim().toLowerCase();
+	const normalizedVisibility = String(normalizedMessage.visibility || '').trim().toLowerCase();
+	const normalizedBadge = String(normalizedMessage.badge || '').trim().toLowerCase();
+	const isInternalSystemMessage = normalizedMessage.internal === true
+		|| normalizedType === 'resolveio'
+		|| normalizedType === 'internal'
+		|| normalizedSource.startsWith('support-')
+		|| normalizedSource.startsWith('support_')
+		|| normalizedVisibility === 'internal'
+		|| normalizedBadge === 'internal'
+		|| normalizedBadge === 'ai'
+		|| normalizedUser.startsWith('resolveio');
+
+	if (!isInternalSystemMessage) {
+		return normalizedMessage;
+	}
+
+	normalizedMessage.id_user = SUPPORT_TICKET_SYSTEM_USER_ID;
+	if (!String(normalizedMessage.user || '').trim()) {
+		normalizedMessage.user = SUPPORT_TICKET_SYSTEM_USER;
+	}
+	return normalizedMessage;
+}
+
+function roundInvoiceLifecycleDate(value: unknown): Date | null {
+	const parsedValue = coerceDateValue(value);
+	if (!(parsedValue instanceof Date) || Number.isNaN(parsedValue.getTime())) {
+		return null;
+	}
+
+	const roundedDate = new Date(parsedValue);
+	roundedDate.setSeconds(0, 0);
+	return roundedDate;
+}
+
+function normalizeInvoiceLifecycleDates(doc: any) {
+	if (!doc || (doc.status !== 'Invoiced' && doc.status !== 'Paid/Closed')) {
+		return;
+	}
+
+	const invoiceDate = roundInvoiceLifecycleDate(doc.date_invoice)
+		|| roundInvoiceLifecycleDate(doc.createdAt)
+		|| roundInvoiceLifecycleDate(new Date());
+
+	if (!doc.date_invoice && invoiceDate) {
+		doc.date_invoice = invoiceDate;
+	}
+	if (!doc.date_due && doc.date_invoice instanceof Date && !Number.isNaN(doc.date_invoice.getTime())) {
+		const dueDate = new Date(doc.date_invoice);
+		dueDate.setDate(dueDate.getDate() + 30);
+		doc.date_due = dueDate;
+	}
+}
+
+function normalizeDocumentBeforeReplace(collection: string, doc: any) {
+	if (!doc) {
+		return;
+	}
+
+	if (collection === INVOICE_COLLECTION) {
+		normalizeInvoiceLifecycleDates(doc);
+	}
+
+	if (collection === SUPPORT_TICKET_COLLECTION && Array.isArray(doc.messages)) {
+		doc.messages = doc.messages.map((message: any) => normalizeSupportTicketMessage(message));
+	}
+}
+
+export function loadCollectionMethods(methodManager: MethodManager) {
+	methodManager.methods({
+		collectionListAll: {
+			function: function() {
+				return Promise.resolve(ResolveIOServer.getMongoManager().collections().map(a => a.collectionName).sort((a, b) => a.localeCompare(b)));
+			}
+		},
+		collectionListRB: {
+			function: function() {
+				return Promise.resolve(ResolveIOServer.getMongoManager().collections().filter(a => a.useRB).map(a => a.collectionName).sort((a, b) => a.localeCompare(b)));
+			}
+		},
+		// Query database for any collection and query
+		findOne: {
+			bypassSession: true,
+			bypassLogs: true,
+			check: new SimpleSchema({
+				collection: {
+					type: String
+				},
+				query: {
+					type: Object,
+					blackbox: true
+				}
+			}),
+			function: function(collection: string, query = {}) {
+				if (!ResolveIOServer.getMongoManager().collection(collection)) {
+					throw new Error('Error in Find One Collection: Invalid collection');
+				}
+
+				return ResolveIOServer.getMongoManager().collection(collection).findOne(query);
+			}
+		},
+		find: {
+			bypassSession: true,
+			bypassLogs: true,
+			check: new SimpleSchema({
+				collection: {
+					type: String
+				},
+				query: {
+					type: Object,
+					blackbox: true
+				},
+				sort: {
+					type: Object,
+					blackbox: true,
+					optional: true
+				}
+			}),
+			function: function(collection: string, query = {}, sortQuery = {}) {
+				if (!ResolveIOServer.getMongoManager().collection(collection)) {
+					throw new Error('Error in Find Collection: Invalid collection');
+				}
+				
+				return ResolveIOServer.getMongoManager().collection(collection).find(query, {sort: sortQuery});
+			}
+		},
+		findWithOptions: {
+			bypassSession: true,
+			bypassLogs: true,
+			check: new SimpleSchema({
+				collection: {
+					type: String
+				},
+				query: {
+					type: Object,
+					blackbox: true
+				},
+				options: {
+					type: PaginationOptionsSchema
+				}
+			}),
+			function: function(collection: string, query: Object, options: PaginationOptions) {
+				if (!ResolveIOServer.getMongoManager().collection(collection)) {
+					throw new Error('Error in Find With Options Collection: Invalid collection');
+				}
+				else {
+					let optionsQuery = {};
+
+					if (options.fields && Object.keys(options.fields).length) {
+						optionsQuery['projection'] = options.fields;
+					}
+
+					if (options.sort && Object.keys(options.sort).length) {
+						optionsQuery['sort'] = options.sort;
+					}
+
+					if (options.limit) {
+						optionsQuery['limit'] = options.limit;
+					}
+
+					if (options.skip) {
+						optionsQuery['skip'] = options.skip;
+					}
+
+					return ResolveIOServer.getMongoManager().collection(collection).find(query, optionsQuery);
+				}
+			}
+		},
+		// Insert 1 document
+		// @Inputs: collection, document
+		// @Outputs: res = _id of new document, err = not inserted
+		insertDocument: {
+			check: new SimpleSchema({
+				collection: {
+					type: String
+				},
+				document: {
+					type: Object,
+					blackbox: true
+				}
+			}),
+			function: async function(collection: string, document: Object) {
+				if (!ResolveIOServer.getMongoManager().collection(collection)) {
+					throw new Error('Error in Insert Document Collection: Invalid collection');
+				}
+				else {
+					let id = objectIdHexString();
+					document['_id'] = id;
+					document['__v'] = 0;
+
+					await ResolveIOServer.getMongoManager().collection(collection).insertOne(document);
+					return id;
+				}
+			}
+		},
+		// Insert 1 document
+		// @Inputs: collection, document
+		// @Outputs: res = _id of new document, err = not inserted
+		insertManyDocuments: {
+			check: new SimpleSchema({
+				collection: {
+					type: String
+				},
+				documents: {
+					type: Array
+				},
+				'documents.$': {
+					type: Object,
+					blackbox: true
+				}
+			}),
+			function: async function(collection: string, documents: Object[]) {
+				if (!ResolveIOServer.getMongoManager().collection(collection)) {
+					throw new Error('Error in Insert Many Documents Collection: Invalid collection');
+				}
+				else {
+					documents.forEach(document => {
+						document['_id'] = objectIdHexString();
+						document['__v'] = 0;
+					});
+
+					await ResolveIOServer.getMongoManager().collection(collection).insertMany(documents);
+					return documents.map(a => a['_id']);
+				}
+			}
+		},
+		// Replaces 1 document with new document (from _id)
+		// @Inputs: collection, document id
+		// @Outputs: res = 1 (updated 1), err = not updated/wrong version
+		// Search for doc, check version, if found then try and update
+		updateDocument: {
+			check: new SimpleSchema({
+				collection: {
+					type: String
+				},
+				f_document: {
+					type: Object,
+					blackbox: true
+				}
+			}),
+			function: async function(collection: string, f_document: Object) {
+				const collectionRef = ResolveIOServer.getMongoManager().collection(collection);
+				if (!collectionRef) {
+					throw new Error('Error in Update Document Collection: Invalid collection');
+				}
+
+				normalizeDocumentBeforeReplace(collection, f_document);
+				coerceDateFields(collectionRef, f_document);
+				await collectionRef.replaceOne({_id: f_document['_id']}, f_document);
+				return true;
+			}
+		},
+		// Updates 1 document's props (from _id)
+		// @Inputs: collection, document id, document version, update paramters ({prop: 'xxx', data: 'yyy})
+		// @Outputs: res = 1 (updated 1), res = 0 (not updated), err = not updated/wrong version
+		// Search for doc, check version, if found then try and update props
+		updateDocumentProps: {
+			check: new SimpleSchema({
+				collection: {
+					type: String
+				},
+				doc_id: {
+					type: String
+				},
+				updateParams: {
+					type: Array
+				},
+				'updateParams.$': {
+					type: Object,
+					blackbox: true
+				},
+				doc__v: {
+					type: Number,
+					optional: true
+				}
+			}),
+			function: async function(collection: string, doc_id: string, updateParams: any[], doc__v?: number) {
+				const collectionRef = ResolveIOServer.getMongoManager().collection(collection);
+				if (!collectionRef) {
+					throw new Error('Error in Update Document Props Collection: Invalid collection');
+				}
+				else {
+					let currDoc = await collectionRef.findOne({_id: doc_id});
+					if (currDoc) {
+						let modifiedDoc = deepCopy(currDoc);
+
+						updateParams.forEach(data => {
+							modifiedDoc[data.prop] = data.data;
+						});
+
+						if (!doc__v || modifiedDoc.__v === doc__v) {
+							normalizeDocumentBeforeReplace(collection, modifiedDoc);
+							coerceDateFields(collectionRef, modifiedDoc);
+							await collectionRef.replaceOne({_id: modifiedDoc._id}, modifiedDoc, {}, false, false, currDoc);
+						}
+						else {
+							console.log(new Date(), 'invalid version - ' + collection, currDoc.__v, doc__v);
+
+							if (ResolveIOServer.getMongoManager().collection(collection + '.versions')) {
+								let oldDoc = await ResolveIOServer.getMongoManager().collection(collection + '.versions').findOne({
+									_id: {
+										_id: currDoc._id,
+										__v: doc__v
+									}
+								});
+
+								let newCurrDocId = currDoc._id;
+								let newCurrDocV = currDoc.__v;
+
+								if (oldDoc) {
+									let updatedDoc = getMongoMergeUpdatedDoc(modifiedDoc, currDoc, oldDoc);
+									updatedDoc._id = newCurrDocId;
+									updatedDoc.__v = newCurrDocV;
+									currDoc._id = newCurrDocId;
+									currDoc.__v = newCurrDocV;
+
+									normalizeDocumentBeforeReplace(collection, updatedDoc);
+									coerceDateFields(collectionRef, updatedDoc);
+									await collectionRef.replaceOne({_id: newCurrDocId}, updatedDoc, {}, false, false, currDoc);
+								}
+								else {
+									// throw new Error('Error In Update Document Props Collections: Invalid Version And Could Not Find History Props - DB: ' + newCurrDocV + ', Trying to update with :' + doc__v);
+									console.log(new Date(), 'Error In Update Document Props Collections: Invalid Version And Could Not Find History Props - DB: ' + newCurrDocV + ', Trying to update with :' + doc__v)
+								}
+							}
+							else {
+								throw new Error('Error In Update Document Props Collections: Invalid Version And We Are NOT Using Versions On This Collection!');
+							}
+						}
+					}
+					else {
+						throw new Error('Error in Update Document Props Collections: No Document');
+					}
+				}
+
+				return true;
+			}
+		},
+		updateDocumentOffline: {
+			check: new SimpleSchema({
+				collection: {
+					type: String
+				},
+				f_document: {
+					type: Object,
+					blackbox: true
+				}
+			}),
+			function: async function(collection: string, f_document: Object) {
+				const collectionRef = ResolveIOServer.getMongoManager().collection(collection);
+				if (!collectionRef) {
+					throw new Error('Error in Update Document Offline Collection: Invalid collection');
+				}
+				else {
+					let currDoc = await collectionRef.findOne({_id: f_document['_id']});
+					if (currDoc) {
+						if (currDoc.__v === f_document['__v']) {
+							normalizeDocumentBeforeReplace(collection, f_document);
+							coerceDateFields(collectionRef, f_document);
+							await collectionRef.replaceOne({_id: f_document['_id']}, f_document, {}, false, false, currDoc);
+						}
+						else {
+							console.log('OFFLINE - invalid version - ' + collection, currDoc.__v, f_document['__v']);
+
+							let newCurrDocId = currDoc._id;
+							let newCurrDocV = currDoc.__v;
+							let oldDocV = f_document['__v'];
+							
+							if (ResolveIOServer.getMongoManager().collection(collection + '.versions')) {
+								let oldDoc = await ResolveIOServer.getMongoManager().collection(collection + '.versions').findOne({
+									_id: {
+										_id: newCurrDocId,
+										__v: oldDocV
+									}
+								});
+
+								if (oldDoc) {
+									let updatedDoc = getMongoMergeUpdatedDoc(f_document, currDoc, oldDoc);
+									updatedDoc._id = newCurrDocId;
+									updatedDoc.__v = newCurrDocV;
+									currDoc._id = newCurrDocId;
+									currDoc.__v = newCurrDocV;
+
+									normalizeDocumentBeforeReplace(collection, updatedDoc);
+									coerceDateFields(collectionRef, updatedDoc);
+									await collectionRef.replaceOne({_id: newCurrDocId}, updatedDoc, {}, false, false, currDoc);
+								}
+								else {
+									throw new Error('Error in Update Document Offline Collections: OFFLINE - Invalid Version And Could Not Find History Props - DB: ' + newCurrDocV + ', Trying to update with :' + oldDocV);
+								}
+							}
+							else {
+								throw new Error('Error in Update Document Offline Collections: Invalid Version And We Are NOT Using Versions On This Collection!');
+							}
+						}
+					}
+					else {
+						throw new Error('Error in Update Document Offline Collections: No Document');
+					}
+				}
+
+				return true;
+			}
+		},
+		// Updates 1 document's props (from _id)
+		// @Inputs: collection, document id, document version, update paramters ({prop: 'xxx', data: 'yyy})
+		// @Outputs: res = 1 (updated 1), res = 0 (not updated), err = not updated/wrong version
+		// Search for doc, check version, if found then try and update props
+		updateDocumentPropsOffline: {
+			check: new SimpleSchema({
+				collection: {
+					type: String
+				},
+				doc_id: {
+					type: String
+				},
+				updateParams: {
+					type: Array
+				},
+				'updateParams.$': {
+					type: Object,
+					blackbox: true
+				},
+				doc__v: {
+					type: Number
+				}
+			}),
+			function: async function(collection: string, doc_id: string, updateParams: any[], doc__v: number) {
+				const collectionRef = ResolveIOServer.getMongoManager().collection(collection);
+				if (!collectionRef) {
+					throw new Error('Error in Update Document Props Offline Collection: Invalid collection');
+				}
+				else {
+					let currDoc = await collectionRef.findOne({_id: doc_id}, null, true);
+					if (currDoc) {
+						let modifiedDoc = deepCopy(currDoc);
+
+						updateParams.forEach(data => {
+							modifiedDoc[data.prop] = data.data;
+						});
+
+						if (modifiedDoc.__v === doc__v) {
+							normalizeDocumentBeforeReplace(collection, modifiedDoc);
+							coerceDateFields(collectionRef, modifiedDoc);
+							await collectionRef.replaceOne({_id: modifiedDoc._id}, modifiedDoc, {}, false, false, currDoc);
+						}
+						else {
+							console.log('OFFLINE - invalid version - ' + collection, currDoc.__v, doc__v);
+
+							let newCurrDocId = currDoc._id;
+							let newCurrDocV = currDoc.__v;
+							
+							if (ResolveIOServer.getMongoManager().collection(collection + '.versions')) {
+								let oldDoc = await ResolveIOServer.getMongoManager().collection(collection + '.versions').findOne({
+									_id: {
+										_id: currDoc._id,
+										__v: doc__v
+									}
+								});
+								
+								if (oldDoc) {
+									let updatedDoc = getMongoMergeUpdatedDoc(modifiedDoc, currDoc, oldDoc);
+									updatedDoc._id = newCurrDocId;
+									updatedDoc.__v = newCurrDocV;
+									currDoc._id = newCurrDocId;
+									currDoc.__v = newCurrDocV;
+
+									normalizeDocumentBeforeReplace(collection, updatedDoc);
+									coerceDateFields(collectionRef, updatedDoc);
+									await collectionRef.replaceOne({_id: newCurrDocId}, updatedDoc, {}, false, false, currDoc);
+								}
+								else {
+									throw new Error('Error in Update Document Props Offline Collections: OFFLINE - Invalid Version And Could Not Find History Props - DB: ' + newCurrDocV + ', Trying to update with :' + doc__v);
+								}
+							}
+							else {
+								throw new Error('Error in Update Document Props Offline Collections: Invalid Version And We Are NOT Using Versions On This Collection!');
+							}
+						}
+					}
+					else {
+						throw new Error('Error in Update Document Props Offline Collections: No Document');
+					}
+				}
+
+				return true;
+			}
+		},
+		// Removes 1 document (from _id)
+		// @Inputs: collection, document id
+		// @Outputs: res = 1 (deleted), res = 0 (not deleted), err = not deleted
+		// Search for doc, if found then try and remove
+		removeDocument: {
+			check: new SimpleSchema({
+				collection: {
+					type: String
+				},
+				doc_id: {
+					type: String
+				}
+			}),
+			function: async function(collection: string, doc_id: string) {
+				if (!ResolveIOServer.getMongoManager().collection(collection)) {
+					throw new Error('Error in Remove Document Collection: Invalid collection');
+				}
+				
+				await ResolveIOServer.getMongoManager().collection(collection).deleteOne({_id: doc_id});
+
+				return true;
+			}
+		},
+		removeDocumentWithQuery: {
+			check: new SimpleSchema({
+				collection: {
+					type: String
+				},
+				query: {
+					type: Object,
+					blackbox: true
+				}
+			}),
+			function: async function(collection: string, query: Object) {
+				if (!ResolveIOServer.getMongoManager().collection(collection)) {
+					throw new Error('Error in Remove Document With Query Collection: Invalid collection');
+				}
+				
+				await ResolveIOServer.getMongoManager().collection(collection).deleteOne(query);
+
+				return true;
+			}
+		},
+		removeDocumentsWithQuery: {
+			check: new SimpleSchema({
+				collection: {
+					type: String
+				},
+				query: {
+					type: Object,
+					blackbox: true
+				}
+			}),
+			function: async function(collection: string, query: Object) {
+				if (!ResolveIOServer.getMongoManager().collection(collection)) {
+					throw new Error('Error in Remove Documents With Query Collections: Invalid Collection');
+				}
+					
+				await ResolveIOServer.getMongoManager().collection(collection).deleteMany(query);
+
+				return true;
+			}
+		}
+	});
+}

package/src/methods/counters.ts

@@ -0,0 +1,69 @@
+import SimpleSchema from 'simpl-schema';
+import { Counters } from '../collections/counter.collection';
+import { MethodManager } from '../managers/method.manager';
+import { ResolveIOServer } from '../resolveio-server-app';
+import { objectIdHexString } from '../util/common';
+
+export function loadCounterMethods(methodManager: MethodManager) {
+	methodManager.methods({
+		incCounter: {
+			check: new SimpleSchema({
+				counterType: {
+					type: String
+				}
+			}),
+			bypassLogs: true,
+			function: async function(counterType: string) {
+				let counter = await Counters.findOne({type: counterType});
+
+				if (!counter) {
+					await Counters.create({
+						_id: objectIdHexString(),
+						count: 2,
+						type: counterType
+					});
+
+					return 1;
+				}
+				else {
+					let newCount = await Counters.findOneAndUpdate({type: counterType}, {$inc: {count: 1}});
+
+					return newCount.count;
+				}
+			}
+		},
+		countCollectionWithQuery: {
+			check: new SimpleSchema({
+				collectionType: {
+					type: String
+				},
+				query: {
+					type: Object,
+					blackbox: true
+				}
+			}),
+			bypassLogs: true,
+			function: function(collectionType: string, query: Object) {
+				if (!ResolveIOServer.getMongoManager().collection(collectionType)) {
+					throw new Error('Error in Count Collection With Query: Invalid collection');
+				}
+				
+				return ResolveIOServer.getMongoManager().collection(collectionType).countDocuments(query);
+			}
+		},
+		countCollection: {
+			check: new SimpleSchema({
+				collectionType: {
+					type: String
+				}
+			}),
+			function: function(collectionType: string) {
+				if (!ResolveIOServer.getMongoManager().collection(collectionType)) {
+					throw new Error('Error in Count Collection: Invalid collection');
+				}
+				
+				return ResolveIOServer.getMongoManager().collection(collectionType).countDocuments();
+			}
+		}
+	});
+}