@resolveio/server-lib 12.5.53 → 12.5.54

package/src/methods/collections.ts

@@ -0,0 +1,512 @@
+import { MethodManager } from '../managers/method.manager';
+import { deepCopy, getMongoMergeUpdatedDoc } from '../util/common';
+import SimpleSchema from 'simpl-schema';
+import { PaginationOptionsSchema, PaginationOptions } from '../models/pagination.model';
+import { ResolveIOServer } from '../index';
+import { objectIdHexString } from '../managers/mongo.manager';
+
+export function loadCollectionMethods(methodManager: MethodManager) {
+	methodManager.methods({
+		collectionListAll: {
+			function: function() {
+				return new Promise((resolve, reject) => {
+					resolve(ResolveIOServer.getMongoManager().collections().map(a => a.collectionName).sort((a, b) => a.localeCompare(b)));
+				});
+			}
+		},
+		collectionListRB: {
+			function: function() {
+				return new Promise((resolve, reject) => {
+					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: {
+			check: new SimpleSchema({
+				collection: {
+					type: String
+				},
+				query: {
+					type: Object,
+					blackbox: true
+				}
+			}),
+			function: function(collection: string, query = {}) {
+				return new Promise((resolve, reject) => {
+					if (!ResolveIOServer.getMongoManager().collection(collection)) {
+						reject('Invalid collection');
+					}
+					else {
+						ResolveIOServer.getMongoManager().collection(collection).findOne(query).then(res => resolve(res), err => reject(err));
+					}
+				});
+			}
+		},
+		find: {
+			check: new SimpleSchema({
+				collection: {
+					type: String
+				},
+				query: {
+					type: Object,
+					blackbox: true
+				},
+				sort: {
+					type: Object,
+					blackbox: true,
+					optional: true
+				}
+			}),
+			function: function(collection: string, query = {}, sortQuery = {}) {
+				return new Promise((resolve, reject) => {
+					if (!ResolveIOServer.getMongoManager().collection(collection)) {
+						reject('Invalid collection');
+					}
+					else {
+						ResolveIOServer.getMongoManager().collection(collection).find(query, {sort: sortQuery}).then(res => resolve(res), err => reject(err));
+					}
+				});
+			}
+		},
+		findWithOptions: {
+			check: new SimpleSchema({
+				collection: {
+					type: String
+				},
+				query: {
+					type: Object,
+					blackbox: true
+				},
+				options: {
+					type: PaginationOptionsSchema
+				}
+			}),
+			function: function(collection: string, query: Object, options: PaginationOptions) {
+				return new Promise((resolve, reject) => {
+					if (!ResolveIOServer.getMongoManager().collection(collection)) {
+						reject('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;
+						}
+
+						ResolveIOServer.getMongoManager().collection(collection).find(query, optionsQuery).then(res => resolve(res), err => reject(err));
+					}
+				});
+			}
+		},
+		// 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: function(collection: string, document: Object) {
+				return new Promise((resolve, reject) => {
+					if (!ResolveIOServer.getMongoManager().collection(collection)) {
+						reject('Invalid collection');
+					}
+					else {
+						let id = objectIdHexString();
+						document['_id'] = id;
+						document['__v'] = 0;
+
+						ResolveIOServer.getMongoManager().collection(collection).insertOne(document).then(() => resolve(id), err => reject(err));
+					}
+				});
+			}
+		},
+		// 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: function(collection: string, documents: Object[]) {
+				return new Promise((resolve, reject) => {
+					if (!ResolveIOServer.getMongoManager().collection(collection)) {
+						reject('Invalid collection');
+					}
+					else {
+						documents.forEach(document => {
+							document['_id'] = objectIdHexString();
+							document['__v'] = 0;
+						});
+
+						ResolveIOServer.getMongoManager().collection(collection).insertMany(documents).then(() => resolve(documents.map(a => a['_id'])), err => reject(err));
+					}
+				});
+			}
+		},
+		// 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: function(collection: string, f_document: Object) {
+				return new Promise((resolve, reject) => {
+					if (!ResolveIOServer.getMongoManager().collection(collection)) {
+						reject('Invalid collection');
+					}
+					else {
+						ResolveIOServer.getMongoManager().collection(collection).replaceOne({_id: f_document['_id']}, f_document).then(res => resolve(res), err => reject(err));
+					}
+				});
+			}
+		},
+		// 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
+				}
+			}),
+			function: function(collection: string, doc_id: string, updateParams: any[], doc__v: number) {
+				return new Promise((resolve, reject) => {
+					if (!ResolveIOServer.getMongoManager().collection(collection)) {
+						reject('Invalid collection');
+					}
+					else {
+						ResolveIOServer.getMongoManager().collection(collection).findOne({_id: doc_id}).then(currDoc => {
+							if (currDoc) {
+								let modifiedDoc = deepCopy(currDoc);
+
+								updateParams.forEach(data => {
+									modifiedDoc[data.prop] = data.data;
+								});
+
+								if (modifiedDoc.__v === doc__v) {
+									ResolveIOServer.getMongoManager().collection(collection).replaceOne({_id: modifiedDoc._id}, modifiedDoc, {}, false, false, currDoc).then(res => {
+										resolve(res);
+									}, err => reject(err));
+								}
+								else {
+									console.log(new Date(), 'invalid version - ' + collection, currDoc.__v, doc__v);
+
+									if (ResolveIOServer.getMongoManager().collection(collection + '.versions')) {
+										ResolveIOServer.getMongoManager().collection(collection + '.versions').findOne({
+											_id: {
+												_id: currDoc._id,
+												__v: doc__v
+											}
+										}).then(oldDoc => {
+											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;
+			
+												ResolveIOServer.getMongoManager().collection(collection).replaceOne({_id: newCurrDocId}, updatedDoc, {}, false, false, currDoc).then(res => {
+													resolve(res);
+												}, err => reject(err));
+											}
+											else {
+												reject('Invalid Version And Could Not Find History Props - DB: ' + newCurrDocV + ', Trying to update with :' + doc__v);
+											}
+										}, () => {});
+									}
+									else {
+										reject('Invalid Version And We Are NOT Using Versions On This Collection!');
+									}
+								}
+							}
+							else {
+								reject('No Document');
+							}
+						}, () => {});
+					}
+				});
+			}
+		},
+		updateDocumentOffline: {
+			check: new SimpleSchema({
+				collection: {
+					type: String
+				},
+				f_document: {
+					type: Object,
+					blackbox: true
+				}
+			}),
+			function: function(collection: string, f_document: Object) {
+				return new Promise((resolve, reject) => {
+					if (!ResolveIOServer.getMongoManager().collection(collection)) {
+						reject('Invalid collection');
+					}
+					else {
+						ResolveIOServer.getMongoManager().collection(collection).findOne({_id: f_document['_id']}).then(currDoc => {
+							if (currDoc) {
+								if (currDoc.__v === f_document['__v']) {
+									ResolveIOServer.getMongoManager().collection(collection).replaceOne({_id: f_document['_id']}, f_document, {}, false, false, currDoc).then(res => {
+										resolve(res);
+									}, err => reject(err));
+								}
+								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')) {
+										ResolveIOServer.getMongoManager().collection(collection + '.versions').findOne({
+											_id: {
+												_id: newCurrDocId,
+												__v: oldDocV
+											}
+										}).then(oldDoc => {
+											if (oldDoc) {
+												let updatedDoc = getMongoMergeUpdatedDoc(f_document, currDoc, oldDoc);
+												updatedDoc._id = newCurrDocId;
+												updatedDoc.__v = newCurrDocV;
+												currDoc._id = newCurrDocId;
+												currDoc.__v = newCurrDocV;
+			
+												ResolveIOServer.getMongoManager().collection(collection).replaceOne({_id: newCurrDocId}, updatedDoc, {}, false, false, currDoc).then(res => {
+													resolve(res);
+												}, err => reject(err));
+											}
+											else {
+												reject('OFFLINE - Invalid Version And Could Not Find History Props - DB: ' + newCurrDocV + ', Trying to update with :' + oldDocV);
+											}
+										}, () => {});
+									}
+									else {
+										reject('Invalid Version And We Are NOT Using Versions On This Collection!');
+									}
+								}
+							}
+							else {
+								reject('No Document');
+							}
+						}, () => {});
+					}
+				});
+			}
+		},
+		// 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: function(collection: string, doc_id: string, updateParams: any[], doc__v: number) {
+				return new Promise((resolve, reject) => {
+					if (!ResolveIOServer.getMongoManager().collection(collection)) {
+						reject('Invalid collection');
+					}
+					else {
+						ResolveIOServer.getMongoManager().collection(collection).findOne({_id: doc_id}, null, true).then(currDoc => {
+							if (currDoc) {
+								let modifiedDoc = deepCopy(currDoc);
+
+								updateParams.forEach(data => {
+									modifiedDoc[data.prop] = data.data;
+								});
+
+								if (modifiedDoc.__v === doc__v) {
+									ResolveIOServer.getMongoManager().collection(collection).replaceOne({_id: modifiedDoc._id}, modifiedDoc, {}, false, false, currDoc).then(res => {
+										resolve(res);
+									}, err => reject(err));
+								}
+								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')) {
+										ResolveIOServer.getMongoManager().collection(collection + '.versions').findOne({
+											_id: {
+												_id: currDoc._id,
+												__v: doc__v
+											}
+										}).then(oldDoc => {
+											if (oldDoc) {
+												let updatedDoc = getMongoMergeUpdatedDoc(modifiedDoc, currDoc, oldDoc);
+												updatedDoc._id = newCurrDocId;
+												updatedDoc.__v = newCurrDocV;
+												currDoc._id = newCurrDocId;
+												currDoc.__v = newCurrDocV;
+			
+												ResolveIOServer.getMongoManager().collection(collection).replaceOne({_id: newCurrDocId}, updatedDoc, {}, false, false, currDoc).then(res => {
+													resolve(res);
+												}, err => reject(err));
+											}
+											else {
+												reject('OFFLINE - Invalid Version And Could Not Find History Props - DB: ' + newCurrDocV + ', Trying to update with :' + doc__v);
+											}
+										}, () => {});
+									}
+									else {
+										reject('Invalid Version And We Are NOT Using Versions On This Collection!');
+									}
+								}
+							}
+							else {
+								reject('No Document');
+							}
+						}, () => {});
+					}
+				});
+			}
+		},
+		// 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: function(collection: string, doc_id: string) {
+				return new Promise((resolve, reject) => {
+					if (!ResolveIOServer.getMongoManager().collection(collection)) {
+						reject('Invalid collection');
+					}
+					else {
+						ResolveIOServer.getMongoManager().collection(collection).deleteOne({_id: doc_id}).then(res => {
+							resolve(res);
+						}, err => {
+							reject(err);
+						});
+					}
+				});
+			}
+		},
+		removeDocumentWithQuery: {
+			check: new SimpleSchema({
+				collection: {
+					type: String
+				},
+				query: {
+					type: Object,
+					blackbox: true
+				}
+			}),
+			function: function(collection: string, query: Object) {
+				return new Promise((resolve, reject) => {
+					if (!ResolveIOServer.getMongoManager().collection(collection)) {
+						reject('Invalid collection');
+					}
+					else {
+						ResolveIOServer.getMongoManager().collection(collection).deleteOne(query).then(res => {
+							resolve(res);
+						}, err => {
+							reject(err);
+						});
+					}
+				});
+			}
+		},
+		removeDocumentsWithQuery: {
+			check: new SimpleSchema({
+				collection: {
+					type: String
+				},
+				query: {
+					type: Object,
+					blackbox: true
+				}
+			}),
+			function: function(collection: string, query: Object) {
+				return new Promise((resolve, reject) => {
+					if (!ResolveIOServer.getMongoManager().collection(collection)) {
+						reject('Invalid collection');
+					}
+					else {
+						ResolveIOServer.getMongoManager().collection(collection).deleteMany(query).then(res => {
+							resolve(res);
+						}, err => {
+							reject(err);
+						});
+					}
+				});
+			}
+		}
+	});
+}

package/src/methods/counters.ts

@@ -0,0 +1,75 @@
+import { MethodManager } from '../managers/method.manager';
+import { Counters } from '../collections/counter.collection';
+import SimpleSchema from 'simpl-schema';
+import { ResolveIOServer } from '..';
+import { objectIdHexString } from '../managers/mongo.manager';
+
+export function loadCounterMethods(methodManager: MethodManager) {
+	methodManager.methods({
+		incCounter: {
+			check: new SimpleSchema({
+				counterType: {
+					type: String
+				}
+			}),
+			function: function(counterType: string) {
+				return new Promise(async (resolve, reject) => {
+					let counter = await Counters.findOne({type: counterType});
+
+					if (!counter) {
+						Counters.create({
+							_id: objectIdHexString(),
+							count: 2,
+							type: counterType
+						});
+
+						resolve(1);
+					}
+					else {
+						let newCount = await Counters.findOneAndUpdate({type: counterType}, {$inc: {count: 1}});
+
+						resolve(newCount.count);
+					}
+				});
+			}
+		},
+		countCollectionWithQuery: {
+			check: new SimpleSchema({
+				collectionType: {
+					type: String
+				},
+				query: {
+					type: Object,
+					blackbox: true
+				}
+			}),
+			function: function(collectionType: string, query: Object) {
+				return new Promise((resolve, reject) => {
+					if (!ResolveIOServer.getMongoManager().collection(collectionType)) {
+						reject('Invalid collection');
+					}
+					else {
+						ResolveIOServer.getMongoManager().collection(collectionType).countDocuments(query).then(res => resolve(res), err => reject(err));
+					}
+				});
+			}
+		},
+		countCollection: {
+			check: new SimpleSchema({
+				collectionType: {
+					type: String
+				}
+			}),
+			function: function(collectionType: string) {
+				return new Promise((resolve, reject) => {
+					if (!ResolveIOServer.getMongoManager().collection(collectionType)) {
+						reject('Invalid collection');
+					}
+					else {
+						ResolveIOServer.getMongoManager().collection(collectionType).countDocuments().then(res => resolve(res), err => reject(err));
+					}
+				});
+			}
+		}
+	});
+}