@resolveio/server-lib 22.2.34 → 22.2.36

package/src/collections/openai-usage-ledger.collection.ts

@@ -1,77 +0,0 @@
-import { MongoManagerModel } from '../managers/mongo.manager';
-import { OpenAIUsageLedgerModel } from '../models/openai-usage-ledger.model';
-
-const schema: any = {
-	_id: {
-		type: String,
-		optional: true
-	},
-	id_client: {
-		type: String
-	},
-	timestamp: {
-		type: Date
-	},
-	model: {
-		type: String
-	},
-	input_tokens: {
-		type: Number
-	},
-	cached_input_tokens: {
-		type: Number,
-		optional: true
-	},
-	output_tokens: {
-		type: Number
-	},
-	total_tokens: {
-		type: Number
-	},
-	cost_estimate: {
-		type: Number
-	},
-	billable: {
-		type: Boolean
-	},
-	category: {
-		type: String,
-		optional: true
-	},
-	id_request: {
-		type: String,
-		optional: true
-	},
-	id_conversation: {
-		type: String,
-		optional: true
-	}
-};
-
-const model = MongoManagerModel.create<OpenAIUsageLedgerModel>({
-	collectionName: 'openai-usage-ledger',
-	schema,
-	useVersionCollection: false,
-	useReportBuilder: false,
-	reportBuilderLookupTables: [],
-	timestamps: false,
-	createLogs: false,
-	checkSchema: true,
-	collectionOptions: {
-		timeseries: {
-			timeField: 'timestamp',
-			metaField: 'id_client',
-			granularity: 'hours'
-		},
-		expireAfterSeconds: 60 * 60 * 24 * 365
-	},
-	skipCache: true
-});
-
-export const OpenAIUsageLedger = model.collection_main;
-
-setTimeout(async () => {
-	await OpenAIUsageLedger.createIndex({ id_client: 1, timestamp: -1 });
-	await OpenAIUsageLedger.createIndex({ id_conversation: 1, timestamp: -1 });
-	await OpenAIUsageLedger.createIndex({ id_request: 1 });
-}, 5000);

package/src/collections/report-builder-dashboard-builder.collection.ts

@@ -1,109 +0,0 @@
-import { MongoManagerCollection, MongoManagerModel } from '../managers/mongo.manager';
-import { ReportBuilderDashboardBuilderModel } from '../models/report-builder-dashboard-builder.model';
-import { ResolveIOServer } from '../resolveio-server-app';
-
-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
-	},
-	date_created: {
-		type: Date
-	},
-	id_user_created: {
-		type: String
-	},
-	user_created: {
-		type: String
-	},
-	num_rows: {
-		type: Number
-	},
-	num_columns: {
-		type: Number
-	},
-	report_rows: {
-		type: Array
-	},
-	'report_rows.$': {
-		type: Object
-	},
-	'report_rows.$.report_columns': {
-		type: Array
-	},
-	'report_rows.$.report_columns.$': {
-		type: Object
-	},
-	'report_rows.$.report_columns.$.id_report': {
-		type: String
-	},
-	'report_rows.$.report_columns.$.report_name': {
-		type: String
-	},
-	'report_rows.$.report_columns.$.report_type': {
-		type: String
-	},
-	'report_rows.$.report_columns.$.display_type': {
-		type: String
-	},
-	'report_rows.$.report_columns.$.display_values': {
-		type: Array
-	},
-	'report_rows.$.report_columns.$.display_values.$': {
-		type: String
-	},
-	'report_rows.$.report_columns.$.display_text': {
-		type: String
-	},
-	'report_rows.$.report_columns.$.display_value': {
-		type: String
-	},
-	other: {
-		type: Object,
-		blackbox: true,
-		optional: true
-	}
-};
-
-export let ReportBuilderDashboardBuilders: MongoManagerCollection<ReportBuilderDashboardBuilderModel> = null;
-
-initializeCollection();
-
-function initializeCollection() {
-	if (ResolveIOServer && ResolveIOServer.getMainDB() && MongoManagerModel) {
-		const model = MongoManagerModel.create<ReportBuilderDashboardBuilderModel>({
-			collectionName: 'report-builder-dashboard-builders',
-			schema: schema,
-			useVersionCollection: false,
-			useReportBuilder: false,
-			reportBuilderLookupTables: [],
-			timestamps: true,
-			createLogs: true,
-			checkSchema: true,
-			collectionOptions: null
-		});
-		ReportBuilderDashboardBuilders = model.collection_main;
-		ReportBuilderDashboardBuilders.createIndex({name: 1});
-		ReportBuilderDashboardBuilders.createIndex({date_created: 1});
-	}
-	else {
-		setImmediate(() => {
-			initializeCollection();
-		});
-	}
-}

package/src/collections/report-builder-library.collection.ts

@@ -1,89 +0,0 @@
-import { MongoManagerCollection, MongoManagerModel } from '../managers/mongo.manager';
-import { ReportBuilderLibraryModel } from '../models/report-builder-library.model';
-import { ResolveIOServer } from '../resolveio-server-app';
-
-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
-	},
-	id_user_create: {
-		type: String
-	},
-	user_create: {
-		type: String
-	},
-	date: {
-		type: Date
-	},
-	reports: {
-		type: Array
-	},
-	'reports.$': {
-		type: Object
-	},
-	'reports.$.id_report': {
-		type: String
-	},
-	'reports.$.report': {
-		type: String
-	},
-	user_groups: {
-		type: Array
-	},
-	'user_groups.$': {
-		type: Object
-	},
-	'user_groups.$.id_user_group': {
-		type: String
-	},
-	'user_groups.$.user_group': {
-		type: String
-	}
-};
-
-
-
-export let ReportBuilderLibraries: MongoManagerCollection<ReportBuilderLibraryModel> = null;
-
-initializeCollection();
-
-function initializeCollection() {
-	if (ResolveIOServer && ResolveIOServer.getMainDB() && MongoManagerModel) {
-		const model = MongoManagerModel.create<ReportBuilderLibraryModel>({
-			collectionName: 'report-builder-libraries',
-			schema: schema,
-			useVersionCollection: false,
-			useReportBuilder: false,
-			reportBuilderLookupTables: [],
-			timestamps: true,
-			createLogs: true,
-			checkSchema: true,
-			collectionOptions: null
-		});
-		ReportBuilderLibraries = model.collection_main;
-		ReportBuilderLibraries.createIndex({name: 1});
-		ReportBuilderLibraries.createIndex({id_user_create: 1});
-		ReportBuilderLibraries.createIndex({'user_groups.id_user_group': 1});
-	}
-	else {
-		setImmediate(() => {
-			initializeCollection();
-		});
-	}
-}

package/src/collections/report-builder-report.collection.ts

@@ -1,180 +0,0 @@
-import { MongoManagerCollection, MongoManagerModel } from '../managers/mongo.manager';
-import { ReportBuilderReportModel } from '../models/report-builder-report.model';
-import { ResolveIOServer } from '../resolveio-server-app';
-
-let schema: any = {
-	_id: {
-		type: String,
-		optional: true
-	},
-	__v: {
-		type: Number,
-		optional: true
-	},
-	updatedAt: {
-		type: Date,
-		optional: true
-	},
-	createdAt: {
-		type: Date,
-		optional: true
-	},
-	collection_root: {
-		type: String
-	},
-	collection_joins: {
-		type: Array,
-		optional: true
-	},
-	'collection_joins.$': {
-		type: Object
-	},
-	'collection_joins.$.collection': {
-		type: String
-	},
-	'collection_joins.$.alias': {
-		type: String,
-		optional: true
-	},
-	'collection_joins.$.local_key': {
-		type: String,
-		optional: true
-	},
-	'collection_joins.$.foreign_key': {
-		type: String,
-		optional: true
-	},
-	report_name: {
-		type: String
-	},
-	fields_sort: {
-		type: Array
-	},
-	'fields_sort.$': {
-		type: Object
-	},
-	'fields_sort.$.field': {
-		type: String
-	},
-	'fields_sort.$.order': {
-		type: String
-	},
-	fields_filter: {
-		type: Array
-	},
-	'fields_filter.$': {
-		type: Object,
-		blackbox: true
-	},
-	fields_custom: {
-		type: Array
-	},
-	'fields_custom.$': {
-		type: Object,
-		blackbox: true
-	},
-	fields_selected: {
-		type: Array
-	},
-	'fields_selected.$': {
-		type: Object,
-		blackbox: true
-	},
-	fields_total: {
-		type: Array
-	},
-	'fields_total.$': {
-		type: Object,
-		blackbox: true
-	},
-	fields_link: {
-		type: Array
-	},
-	'fields_link.$': {
-		type: Object,
-		blackbox: true
-	},
-	id_user: {
-		type: String
-	},
-	user: {
-		type: String
-	},
-	date_created: {
-		type: Date
-	},
-	shared_users: {
-		type: Array
-	},
-	'shared_users.$': {
-		type: String
-	},
-	type: {
-		type: String
-	},
-	groups_row: {
-		type: Array
-	},
-	'groups_row.$': {
-		type: Object,
-		blackbox: true
-	},
-	groups_column: {
-		type: Array
-	},
-	'groups_column.$': {
-		type: Object,
-		blackbox: true
-	},
-	group_type: {
-		type: String
-	},
-	fields_layout: {
-		type: Array,
-		optional: true
-	},
-	'fields_layout.$': {
-		type: Object,
-		blackbox: true,
-		optional: true
-	},
-	id_date_field: {
-		type: String,
-		optional: true
-	},
-	date_interval: {
-		type: String,
-		optional: true
-	}
-};
-
-export let ReportBuilderReports: MongoManagerCollection<ReportBuilderReportModel> = null;
-export let ReportBuilderReportVersions: MongoManagerCollection<ReportBuilderReportModel> = null;
-
-initializeCollection();
-
-function initializeCollection() {
-	if (ResolveIOServer && ResolveIOServer.getMainDB() && MongoManagerModel) {
-		const model = MongoManagerModel.create<ReportBuilderReportModel>({
-			collectionName: 'report-builder-reports',
-			schema: schema,
-			useVersionCollection: true,
-			useReportBuilder: false,
-			reportBuilderLookupTables: [],
-			timestamps: true,
-			createLogs: true,
-			checkSchema: true,
-			collectionOptions: null
-		});
-		ReportBuilderReports = model.collection_main;
-		ReportBuilderReports.createIndex({id_user: 1});
-		ReportBuilderReports.createIndex({shared_users: 1});
-		ReportBuilderReports.createIndex({report_name: 1, collection_root: 1});
-		ReportBuilderReportVersions = model.collection_version;
-	}
-	else {
-		setImmediate(() => {
-			initializeCollection();
-		});
-	}
-}

package/src/collections/user-group.collection.ts

@@ -1,89 +0,0 @@
-import { MongoManagerCollection, MongoManagerModel } from '../managers/mongo.manager';
-import { UserGroupModel } from '../models/user-group.model';
-import { ResolveIOServer } from '../resolveio-server-app';
-
-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
-	},
-	landing_page: {
-		type: String,
-		optional: true
-	},
-	permissions: {
-		type: Array
-	},
-	'permissions.$': {
-		type:  Object
-	},
-	'permissions.$.name': {
-		type: String
-	},
-	'permissions.$.selected': {
-		type: Boolean
-	},
-	'permissions.$.views': {
-		type: Array
-	},
-	'permissions.$.views.$': {
-		type: Object
-	},
-	'permissions.$.views.$.link': {
-		type: String
-	},
-	'permissions.$.views.$.selected': {
-		type: Boolean
-	},
-	notifications: {
-		type: Array
-	},
-	'notifications.$': {
-		type:  Object,
-		blackbox: true
-	},
-};
-
-export let UserGroups: MongoManagerCollection<UserGroupModel> = null;
-export let UserGroupVersions: MongoManagerCollection<UserGroupModel> = null;
-
-initializeCollection();
-
-function initializeCollection() {
-	if (ResolveIOServer && ResolveIOServer.getMainDB() && MongoManagerModel) {
-		const model = MongoManagerModel.create<UserGroupModel>({
-			collectionName: 'user-groups',
-			schema: schema,
-			useVersionCollection: true,
-			useReportBuilder: true,
-			reportBuilderLookupTables: [],
-			timestamps: true,
-			createLogs: false,
-			checkSchema: true,
-			collectionOptions: null
-		});
-		UserGroups = model.collection_main;
-		UserGroups.createIndex({name: 1});
-		UserGroupVersions = model.collection_version;
-	}
-	else {
-		setImmediate(() => {
-			initializeCollection();
-		});
-	}
-}

package/src/collections/user-guide.collection.ts

@@ -1,57 +0,0 @@
- import { MongoManagerCollection, MongoManagerModel } from '../managers/mongo.manager';
-import { UserGuideModel } from '../models/user-guide.model';
-import { ResolveIOServer } from '../resolveio-server-app';
-
-let schema: any = {
-	_id: {
-		type: String,
-		optional: true
-	},
-	__v: {
-		type: Number,
-		optional: true
-	},
-	updatedAt: {
-		type: Date,
-		optional: true
-	},
-	createdAt: {
-		type: Date,
-		optional: true
-	},
-	link: {
-		type: String
-	},
-	label: {
-		type: String
-	},
-	message: {
-		type: String
-	},
-};
-
-export let UserGuides: MongoManagerCollection<UserGuideModel> = null;
-
-initializeCollection();
-
-function initializeCollection() {
-	if (ResolveIOServer && ResolveIOServer.getMainDB() && MongoManagerModel) {
-		const model = MongoManagerModel.create<UserGuideModel>({
-			collectionName: 'user-guides',
-			schema: schema,
-			useVersionCollection: false,
-			useReportBuilder: false,
-			reportBuilderLookupTables: [],
-			timestamps: true,
-			createLogs: false,
-			checkSchema: true,
-			collectionOptions: null
-		});
-		UserGuides = model.collection_main;
-	}
-	else {
-		setImmediate(() => {
-			initializeCollection();
-		});
-	}
-}