@resolveio/server-lib 12.5.54 → 12.5.56

package/src/methods/collections.ts

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

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