@resolveio/server-lib 12.5.54 → 12.5.55

package/src/collections/flag.collection.ts

@@ -1,56 +0,0 @@
-import { ResolveIOServer } from '../index';
-import { MongoManagerCollection, MongoManagerModel } from '../managers/mongo.manager';
-import { FlagModel } from '../models/flag.model';
-
-let schema: any = {
-	_id: {
-		type: String,
-		optional: true
-	},
-	__v: {
-		type: Number,
-		optional: true
-	},
-	updatedAt: {
-		type: Date,
-		optional: true
-	},
-	createdAt: {
-		type: Date,
-		optional: true
-	},
-	type: {
-		type: String
-	},
-	value: {
-		type: Boolean,
-		optional: true
-	}
-};
-
-export let Flags: MongoManagerCollection<FlagModel> = null;
-
-initializeCollection();
-
-function initializeCollection() {
-	if (ResolveIOServer && ResolveIOServer.getMainDB()) {
-		const model = new MongoManagerModel<FlagModel>({
-			collectionName: 'flags',
-			schema: schema,
-			useVersionCollection: false,
-			useReportBuilder: false,
-			reportBuilderLookupTables: [],
-			timestamps: true,
-			createLogs: false,
-			checkSchema: true,
-			collectionOptions: null
-		});
-		Flags = model.collection_main;
-		Flags.createIndex({type: 1}, {unique: true});
-	}
-	else {
-		setTimeout(() => {
-			initializeCollection();
-		}, 0);
-	}
-}

package/src/collections/log-method-latency.collection.ts

@@ -1,64 +0,0 @@
-import { ResolveIOServer } from '../index';
-import { MongoManagerCollection, MongoManagerModel } from '../managers/mongo.manager';
-import { LogMethodLatencyModel } from '../models/log-method-latency.model';
-
-let schema: any = {
-	_id: {
-		type: String,
-		optional: true
-	},
-	__v: {
-		type: Number,
-		optional: true
-	},
-	updatedAt: {
-		type: Date,
-		optional: true
-	},
-	createdAt: {
-		type: Date,
-		optional: true
-	},
-	date_start: {
-		type: Date
-	},
-	date_end: {
-		type: Date,
-		optional: true
-	},
-	latency_ms: {
-		type: Number
-	},
-	method: {
-		type: String
-	}
-};
-
-export let LogMethodLatencies: MongoManagerCollection<LogMethodLatencyModel> = null;
-
-initializeCollection();
-
-function initializeCollection() {
-	if (ResolveIOServer && ResolveIOServer.getMainDB()) {
-		const model = new MongoManagerModel<LogMethodLatencyModel>({
-			collectionName: 'log-method-latencies',
-			schema: schema,
-			useVersionCollection: false,
-			useReportBuilder: true,
-			reportBuilderLookupTables: [],
-			timestamps: true,
-			createLogs: false,
-			checkSchema: true,
-			collectionOptions: null
-		});
-		LogMethodLatencies = model.collection_main;
-		LogMethodLatencies.createIndex({createdAt: 1}, {expireAfterSeconds: 60 * 60 * 24 * 30});
-		LogMethodLatencies.createIndex({latency_ms: 1});
-		LogMethodLatencies.createIndex({method: 1});
-	}
-	else {
-		setTimeout(() => {
-			initializeCollection();
-		}, 1);
-	}
-}

package/src/collections/log-subscription.collection.ts

@@ -1,68 +0,0 @@
-import { ResolveIOServer } from '../index';
-import { MongoManagerCollection, MongoManagerModel } from '../managers/mongo.manager';
-import { LogSubscriptionModel } from '../models/log-subscription.model';
-
-let schema: any = {
-	_id: {
-		type: String,
-		optional: true
-	},
-	__v: {
-		type: Number,
-		optional: true
-	},
-	updatedAt: {
-		type: Date,
-		optional: true
-	},
-	createdAt: {
-		type: Date,
-		optional: true
-	},
-	date: {
-		type: Date
-	},
-	type: {
-		type: String
-	},
-	subscription: {
-		type: String
-	},
-	collection_name: {
-		type: String
-	},
-	subData: {
-		type: String	
-	}
-};
-
-export let LogSubscriptions: MongoManagerCollection<LogSubscriptionModel> = null;
-
-initializeCollection();
-
-function initializeCollection() {
-	if (ResolveIOServer && ResolveIOServer.getMainDB()) {
-		const model = new MongoManagerModel<LogSubscriptionModel>({
-			collectionName: 'log-subscriptions',
-			schema: schema,
-			useVersionCollection: false,
-			useReportBuilder: true,
-			reportBuilderLookupTables: [],
-			timestamps: true,
-			createLogs: false,
-			checkSchema: true,
-			collectionOptions: null
-		});
-		LogSubscriptions = model.collection_main;
-		LogSubscriptions.createIndex({date: 1}, {expireAfterSeconds: 60 * 60 * 24 * 30});
-		LogSubscriptions.createIndex({type: 1});
-		LogSubscriptions.createIndex({collection_name: 1});
-		LogSubscriptions.createIndex({date: 1, type: 1});
-		LogSubscriptions.createIndex({createdAt: 1});
-	}
-	else {
-		setTimeout(() => {
-			initializeCollection();
-		}, 1);
-	}
-}

package/src/collections/log-ts.collection.ts

@@ -1,78 +0,0 @@
-import { ResolveIOServer } from '../index';
-import { MongoManagerCollection, MongoManagerModel } from '../managers/mongo.manager';
-import { LogModel } from '../models/log.model';
-
-let schema: any = {
-	_id: {
-		type: String,
-		optional: true
-	},
-	createdAt: {
-		type: Date,
-		optional: true
-	},
-	metadata: {
-		type: Object
-	},
-	'metadata.type': {
-		type: String
-	},
-	'metadata.collection': {
-		type: String
-	},
-	id_document: {
-		type: String
-	},
-	payload: {
-		type: String
-	},
-	method: {
-		type: String
-	},
-	id_user: {
-		type: String
-	},
-	user: {
-		type: String
-	},
-	messageId: {
-		type: Number
-	},
-	route: {
-		type: String
-	}
-};
-
-export let Logs: MongoManagerCollection<LogModel> = null;
-
-initializeCollection();
-
-function initializeCollection() {
-	if (ResolveIOServer && ResolveIOServer.getMainDB()) {
-		const model = new MongoManagerModel<LogModel>({
-			collectionName: 'logs',
-			schema: schema,
-			useVersionCollection: false,
-			useReportBuilder: false,
-			reportBuilderLookupTables: [],
-			timestamps: true,
-			createLogs: false,
-			checkSchema: true,
-			collectionOptions: null
-		});
-		Logs = model.collection_main;
-		Logs.createIndex({createdAt: 1}, {expireAfterSeconds: 60 * 60 * 24 * 90});
-		Logs.createIndex({createdAt: -1, type: 1, id_document: 1});
-		Logs.createIndex({createdAt: -1, type: 1, user: 1});
-		Logs.createIndex({createdAt: -1, type: 1, method: 1});
-		Logs.createIndex({createdAt: -1, type: 1, route: 1});
-		Logs.createIndex({createdAt: -1, type: 1, collection: 1, id_document: 1});
-		Logs.createIndex({createdAt: -1, type: 1, collection: 1, method: 1, route: 1});
-		Logs.createIndex({createdAt: -1, type: 1, collection: 1, route: 1});
-	}
-	else {
-		setTimeout(() => {
-			initializeCollection();
-		}, 1);
-	}
-}

package/src/collections/log.collection.ts

@@ -1,77 +0,0 @@
-import { ResolveIOServer } from '../index';
-import { MongoManagerCollection, MongoManagerModel } from '../managers/mongo.manager';
-import { LogModel } from '../models/log.model';
-
-let schema: any = {
-	_id: {
-		type: String,
-		optional: true
-	},
-	__v: {
-		type: Number,
-		optional: true
-	},
-	updatedAt: {
-		type: Date,
-		optional: true
-	},
-	createdAt: {
-		type: Date,
-		optional: true
-	},
-	type: {
-		type: String
-	},
-	collection: {
-		type: String
-	},
-	id_document: {
-		type: String
-	},
-	payload: {
-		type: String
-	},
-	method: {
-		type: String
-	},
-	id_user: {
-		type: String
-	},
-	user: {
-		type: String
-	},
-	messageId: {
-		type: Number
-	},
-	route: {
-		type: String
-	}
-};
-
-export let Logs: MongoManagerCollection<LogModel> = null;
-
-initializeCollection();
-
-function initializeCollection() {
-	if (ResolveIOServer && ResolveIOServer.getMainDB()) {
-		const model = new MongoManagerModel<LogModel>({
-			collectionName: 'logs',
-			schema: schema,
-			useVersionCollection: false,
-			useReportBuilder: false,
-			reportBuilderLookupTables: [],
-			timestamps: true,
-			createLogs: false,
-			checkSchema: true,
-			collectionOptions: null
-		});
-		Logs = model.collection_main;
-		Logs.createIndex({createdAt: 1}, {expireAfterSeconds: 60 * 60 * 24 * 90});
-		Logs.createIndex({createdAt: -1, type: 1, id_document: 1});
-	}
-	else {
-		setTimeout(() => {
-			initializeCollection();
-		}, 1);
-	}
-}

package/src/collections/logged-in-users.collection.ts

@@ -1,65 +0,0 @@
-import { ResolveIOServer } from '../index';
-import { MongoManagerCollection, MongoManagerModel } from '../managers/mongo.manager';
-import { LoggedInUserModel } from '../models/logged-in-users.model';
-
-let schema: any = {
-	_id: {
-		type: String,
-		optional: true
-	},
-	__v: {
-		type: Number,
-		optional: true
-	},
-	updatedAt: {
-		type: Date,
-		optional: true
-	},
-	createdAt: {
-		type: Date,
-		optional: true
-	},
-	date: {
-		type: Date
-	},
-	id_user: {
-		type: String
-	},
-	user: {
-		type: String
-	},
-	id_ws: {
-		type: String
-	},
-	latency: {
-		type: Number,
-		optional: true
-	}
-};
-
-export let LoggedInUsers: MongoManagerCollection<LoggedInUserModel> = null;
-
-initializeCollection();
-
-function initializeCollection() {
-	if (ResolveIOServer && ResolveIOServer.getMainDB()) {
-		const model = new MongoManagerModel<LoggedInUserModel>({
-			collectionName: 'logged-in-users',
-			schema: schema,
-			useVersionCollection: false,
-			useReportBuilder: false,
-			reportBuilderLookupTables: [],
-			timestamps: true,
-			createLogs: false,
-			checkSchema: true,
-			collectionOptions: null
-		});
-		LoggedInUsers = model.collection_main;
-		LoggedInUsers.createIndex({id_ws: 1});
-	}
-	else {
-		setTimeout(() => {
-			initializeCollection();
-		}, 1);
-	}
-}

package/src/collections/method-response.collection.ts

@@ -1,66 +0,0 @@
-import { ResolveIOServer } from '../index';
-import { MongoManagerCollection, MongoManagerModel } from '../managers/mongo.manager';
-import { MethodResponseModel } from '../models/method-response.model';
-
-let schema: any = {
-	_id: {
-		type: String,
-		optional: true
-	},
-	__v: {
-		type: Number,
-		optional: true
-	},
-	updatedAt: {
-		type: Date,
-		optional: true
-	},
-	createdAt: {
-		type: Date,
-		optional: true
-	},
-	id_user: {
-		type: String
-	},
-	message_id: {
-		type: Number
-	},
-	method: {
-		type: String
-	},
-	response: {
-		type: Object,
-		blackbox: true
-	},
-	date: {
-		type: Date
-	}
-};
-
-export let MethodResponses: MongoManagerCollection<MethodResponseModel> = null;
-
-initializeCollection();
-
-function initializeCollection() {
-	if (ResolveIOServer && ResolveIOServer.getMainDB()) {
-		const model = new MongoManagerModel<MethodResponseModel>({
-			collectionName: 'method-responses',
-			schema: schema,
-			useVersionCollection: false,
-			useReportBuilder: false,
-			reportBuilderLookupTables: [],
-			timestamps: true,
-			createLogs: false,
-			checkSchema: true,
-			collectionOptions: null
-		});
-		MethodResponses = model.collection_main;
-		MethodResponses.createIndex({id_user: 1, message_id: 1});
-		MethodResponses.createIndex({createdAt: 1}, {expireAfterSeconds: 86400});
-	}
-	else {
-		setTimeout(() => {
-			initializeCollection();
-		}, 1);
-	}
-}

package/src/collections/monitor-cpu.collection.ts

@@ -1,63 +0,0 @@
-import { ResolveIOServer } from '../index';
-import { MongoManagerCollection, MongoManagerModel } from '../managers/mongo.manager';
-import { MonitorCPUModel } from '../models/monitor-cpu.model';
-
-let schema: any = {
-	_id: {
-		type: String,
-		optional: true
-	},
-	metadata: {
-		type: Object
-	},
-	'metadata.client': {
-		type: String
-	},
-	'metadata.instance': {
-		type: String
-	},
-	date: {
-		type: Date
-	},
-	app: {
-		type: Number
-	},
-	system: {
-		type: Number
-	}
-};
-
-export let MonitorCPUs: MongoManagerCollection<MonitorCPUModel> = null;
-
-initializeCollection();
-
-function initializeCollection() {
-	if (ResolveIOServer && ResolveIOServer.getMainDB()) {
-		const model = new MongoManagerModel<MonitorCPUModel>({
-			collectionName: 'monitor-cpus',
-			schema: schema,
-			useVersionCollection: false,
-			useReportBuilder: false,
-			reportBuilderLookupTables: [],
-			timestamps: false,
-			createLogs: false,
-			checkSchema: false,
-			collectionOptions: {
-				timeseries: {
-					timeField: 'date',
-					granularity: 'seconds',
-					metaField: 'metadata'
-				},
-				expireAfterSeconds: 60 * 60 * 24 * 3
-			}
-		});
-		MonitorCPUs = model.collection_main;
-		MonitorCPUs.createIndex({'metadata.client': 1, date: 1});
-		MonitorCPUs.createIndex({'metadata.client': 1, 'metadata.instance': 1, date: 1});
-	}
-	else {
-		setTimeout(() => {
-			initializeCollection();
-		}, 1);
-	}
-}

package/src/collections/monitor-memory.collection.ts

@@ -1,75 +0,0 @@
-import { ResolveIOServer } from '../index';
-import { MongoManagerCollection, MongoManagerModel } from '../managers/mongo.manager';
-import { MonitorMemoryModel } from '../models/monitor-memory.model';
-
-let schema: any = {
-	_id: {
-		type: String,
-		optional: true
-	},
-	metadata: {
-		type: Object
-	},
-	'metadata.client': {
-		type: String
-	},
-	'metadata.instance': {
-		type: String
-	},
-	date: {
-		type: Date
-	},
-	physical_total: {
-		type: Number
-	},
-	physical_used: {
-		type: Number
-	},
-	physical_free: {
-		type: Number
-	},
-	virtual: {
-		type: Number
-	},
-	private: {
-		type: Number
-	},
-	physical: {
-		type: Number
-	}
-};
-
-export let MonitorMemorys: MongoManagerCollection<MonitorMemoryModel> = null;
-
-initializeCollection();
-
-function initializeCollection() {
-	if (ResolveIOServer && ResolveIOServer.getMainDB()) {
-		const model = new MongoManagerModel<MonitorMemoryModel>({
-			collectionName: 'monitor-memorys',
-			schema: schema,
-			useVersionCollection: false,
-			useReportBuilder: false,
-			reportBuilderLookupTables: [],
-			timestamps: false,
-			createLogs: false,
-			checkSchema: false,
-			collectionOptions: {
-				timeseries: {
-					timeField: 'date',
-					granularity: 'seconds',
-					metaField: 'metadata'
-				},
-				expireAfterSeconds: 60 * 60 * 24 * 3
-			}
-		});
-		MonitorMemorys = model.collection_main;
-		MonitorMemorys.createIndex({'metadata.client': 1, date: 1});
-		MonitorMemorys.createIndex({'metadata.client': 1, 'metadata.instance': 1, date: 1});
-	}
-	else {
-		setTimeout(() => {
-			initializeCollection();
-		}, 1);
-	}
-}

package/src/collections/monitor-mongo.collection.ts

@@ -1,69 +0,0 @@
-import { ResolveIOServer } from '../index';
-import { MongoManagerCollection, MongoManagerModel } from '../managers/mongo.manager';
-import { MonitorMongoModel } from '../models/monitor-mongo.model';
-
-let schema: any = {
-	_id: {
-		type: String,
-		optional: true
-	},
-	metadata: {
-		type: Object
-	},
-	'metadata.client': {
-		type: String
-	},
-	'metadata.instance': {
-		type: String
-	},
-	date: {
-		type: Date
-	},
-	method: {
-		type: String
-	},
-	doc_collection: {
-		type: String
-	},
-	duration: {
-		type: Number
-	},
-	query: {
-		type: String
-	}
-};
-
-export let MonitorMongos: MongoManagerCollection<MonitorMongoModel> = null;
-
-initializeCollection();
-
-function initializeCollection() {
-	if (ResolveIOServer && ResolveIOServer.getMainDB()) {
-		const model = new MongoManagerModel<MonitorMongoModel>({
-			collectionName: 'monitor-mongos',
-			schema: schema,
-			useVersionCollection: false,
-			useReportBuilder: false,
-			reportBuilderLookupTables: [],
-			timestamps: false,
-			createLogs: false,
-			checkSchema: false,
-			collectionOptions: {
-				timeseries: {
-					timeField: 'date',
-					granularity: 'seconds',
-					metaField: 'metadata'
-				},
-				expireAfterSeconds: 60 * 60 * 24 * 3
-			}
-		});
-		MonitorMongos = model.collection_main;
-		MonitorMongos.createIndex({'metadata.client': 1, date: 1});
-		MonitorMongos.createIndex({'metadata.client': 1, 'metadata.instance': 1, date: 1});
-	}
-	else {
-		setTimeout(() => {
-			initializeCollection();
-		}, 1);
-	}
-}