@resolveio/server-lib 12.5.52 → 12.5.54

package/src/collections/file.collection.ts

@@ -0,0 +1,73 @@
+import { ResolveIOServer } from '../index';
+import { MongoManagerCollection, MongoManagerModel } from '../managers/mongo.manager';
+import { FileModel } from '../models/file.model';
+
+let schema: any = {
+	_id: {
+		type: String,
+		optional: true
+	},
+	__v: {
+		type: Number,
+		optional: true
+	},
+	updatedAt: {
+		type: Date,
+		optional: true
+	},
+	createdAt: {
+		type: Date,
+		optional: true
+	},
+	name: {
+		type: String
+	},
+	size: {
+		type: Number
+	},
+	key: {
+		type: String
+	},
+	type: {
+		type: String
+	},
+	order: {
+		type: Number
+	},
+	status: {
+		type: String,
+		optional: true
+	},
+	default: {
+		type: Boolean,
+		optional: true
+	}
+};
+
+export let Files: MongoManagerCollection<FileModel> = null;
+
+initializeCollection();
+
+function initializeCollection() {
+	if (ResolveIOServer && ResolveIOServer.getMainDB()) {
+		const model = new MongoManagerModel<FileModel>({
+			collectionName: 'files',
+			schema: schema,
+			useVersionCollection: false,
+			useReportBuilder: true,
+			reportBuilderLookupTables: [],
+			timestamps: true,
+			createLogs: false,
+			checkSchema: true,
+			collectionOptions: null
+		});
+		Files = model.collection_main;
+		Files.createIndex({type: 1, createdAt: 1});
+		Files.createIndex({key: 1});
+	}
+	else {
+		setTimeout(() => {
+			initializeCollection();
+		}, 1);
+	}
+}

package/src/collections/flag.collection.ts

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

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

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

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

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

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

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

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

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