@resolveio/server-lib 22.3.23 → 22.3.24

package/src/methods/collections.ts

@@ -1,641 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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();
-			}
-		}
-	});
-}