@contember/engine-server 1.1.0-alpha.1 → 1.1.0-alpha.4

package/src/project/ProjectContainer.ts

@@ -1,19 +1,32 @@
 import { Builder } from '@contember/dic'
 import { Connection } from '@contember/database'
 import { DatabaseContextFactory, SchemaVersionBuilder } from '@contember/engine-system-api'
-import { logSentryError } from '../utils'
-import { ModificationHandlerFactory } from '@contember/schema-migrations'
 import { GraphQlSchemaBuilderFactory, PermissionsByIdentityFactory } from '@contember/engine-content-api'
 import { GraphQLSchemaContributor, Plugin } from '@contember/engine-plugins'
 import {
-	ProjectConfig,
-	ContentQueryHandlerProvider,
 	ContentSchemaResolver,
 	GraphQlSchemaFactory,
-	Providers,
+	ProjectConfig,
 	ProjectContainer,
+	Providers,
 } from '@contember/engine-http'
-import { ContentQueryHandlerFactory } from '@contember/engine-http'
+
+export class ProjectContainerFactoryFactory {
+	constructor(
+		private readonly debug: boolean,
+		private readonly plugins: Plugin[],
+		private readonly providers: Providers,
+	) {
+	}
+
+	create(schemaVersionBuilder: SchemaVersionBuilder): ProjectContainerFactory {
+		return new ProjectContainerFactory(this.debug, this.plugins, schemaVersionBuilder, this.providers)
+	}
+}
+
+interface ProjectContainerFactoryArgs {
+	project: ProjectConfig
+}
 
 export class ProjectContainerFactory {
 	constructor(
@@ -23,19 +36,19 @@ export class ProjectContainerFactory {
 		private readonly providers: Providers,
 	) {}
 
-	public createContainer(project: ProjectConfig): ProjectContainer {
-		return this.createBuilder(project)
+	public createContainer(args: ProjectContainerFactoryArgs): ProjectContainer {
+		return this.createBuilder(args)
 			.build()
 			.pick(
 				'project',
 				'connection',
-				'contentQueryHandlerProvider',
 				'systemDatabaseContextFactory',
 				'contentSchemaResolver',
+				'graphQlSchemaFactory',
 			)
 	}
 
-	protected createBuilder(project: ProjectConfig) {
+	protected createBuilder({ project }: ProjectContainerFactoryArgs) {
 		return new Builder({})
 			.addService('providers', () =>
 				this.providers)
@@ -45,8 +58,6 @@ export class ProjectContainerFactory {
 				project)
 			.addService('connection', ({ project }) =>
 				new Connection(project.db, { timing: true }))
-			.addService('modificationHandlerFactory', () =>
-				new ModificationHandlerFactory(ModificationHandlerFactory.defaultFactoryMap))
 			.addService('graphQlSchemaBuilderFactory', () =>
 				new GraphQlSchemaBuilderFactory())
 			.addService('permissionsByIdentityFactory', ({}) =>
@@ -57,13 +68,9 @@ export class ProjectContainerFactory {
 					.filter((it): it is GraphQLSchemaContributor => !!it)
 				return new GraphQlSchemaFactory(graphQlSchemaBuilderFactory, permissionsByIdentityFactory, contributors)
 			})
-			.addService('contentQueryHandlerFactory', () =>
-				new ContentQueryHandlerFactory(project.slug, this.debug, logSentryError))
 			.addService('contentSchemaResolver', ({ schemaVersionBuilder }) =>
 				new ContentSchemaResolver(schemaVersionBuilder))
-			.addService('contentQueryHandlerProvider', ({ contentSchemaResolver, graphQlSchemaFactory, contentQueryHandlerFactory }) =>
-				new ContentQueryHandlerProvider(contentSchemaResolver, graphQlSchemaFactory, contentQueryHandlerFactory))
-			.addService('systemDatabaseContextFactory', ({ connection, providers }) =>
-				new DatabaseContextFactory(connection.createClient('system', { module: 'system' }), providers))
+			.addService('systemDatabaseContextFactory', ({ connection, providers, project }) =>
+				new DatabaseContextFactory(connection.createClient(project.db.systemSchema ?? 'system', { module: 'system' }), providers))
 	}
 }

package/src/project/ProjectContainerResolver.ts

@@ -1,13 +1,14 @@
 import { ProjectContainerFactory } from './ProjectContainer'
-import { ProjectConfigResolver, ProjectContainer } from '@contember/engine-http'
-import { ProjectManager, ProjectWithSecrets } from '@contember/engine-tenant-api'
-import { ProjectGroup } from '@contember/engine-tenant-api'
+import { ProjectContainer } from '@contember/engine-http'
+import { DatabaseContext, ProjectManager, ProjectWithSecrets } from '@contember/engine-tenant-api'
 import { ProjectInitializer as SystemProjectInitializer } from '@contember/engine-system-api'
-import { ProjectGroupState } from './ProjectGroupState'
+import { ProjectContainerStore } from './ProjectContainerStore'
 import { Logger } from '@contember/engine-common'
+import { ProjectConfigResolver } from '../config/projectConfigResolver'
+import { TenantConfig } from '../config/config'
 
 export class ProjectContainerResolver {
-	private projectGroupStates = new WeakMap<ProjectGroup, ProjectGroupState>()
+	private projectContainers = new ProjectContainerStore()
 
 	public readonly onCreate: ((container: ProjectContainer) => void | (() => void))[] = []
 
@@ -16,13 +17,15 @@ export class ProjectContainerResolver {
 		private readonly projectConfigResolver: ProjectConfigResolver,
 		private readonly projectManager: ProjectManager,
 		private readonly systemProjectInitializer: SystemProjectInitializer,
+		private readonly tenantDatabase: DatabaseContext,
+		private readonly tenantConfig: TenantConfig,
 	) {}
 
-	public async getAllProjectContainers(projectGroup: ProjectGroup): Promise<ProjectContainer[]> {
-		const projects = await this.projectManager.getProjects(projectGroup.database)
+	public async getAllProjectContainers(): Promise<ProjectContainer[]> {
+		const projects = await this.projectManager.getProjects(this.tenantDatabase)
 		return await Promise.all(
 			projects.map(async it => {
-				const container = await this.getProjectContainer(projectGroup, it.slug)
+				const container = await this.getProjectContainer(it.slug)
 				if (!container) {
 					throw new Error('should not happen')
 				}
@@ -31,41 +34,40 @@ export class ProjectContainerResolver {
 		)
 	}
 
-	public async getProjectContainer(projectGroup: ProjectGroup, slug: string, alias: boolean = false): Promise<ProjectContainer | undefined> {
-		let groupState = this.getProjectGroupState(projectGroup)
-
-		const realSlug = groupState.resolveAlias(slug)
+	public async getProjectContainer(slug: string, alias: boolean = false): Promise<ProjectContainer | undefined> {
+		const realSlug = this.projectContainers.resolveAlias(slug)
 		if (realSlug) {
 			slug = realSlug
 		}
-		const existing = groupState.getContainer(slug)
+		const existing = this.projectContainers.getContainer(slug)
 		if (existing) {
 			const existingAwaited = await existing
-			const state = await this.projectManager.getProjectState(projectGroup.database, slug, existingAwaited.timestamp)
+			const state = await this.projectManager.getProjectState(this.tenantDatabase, slug, existingAwaited.timestamp)
 			if (state === 'valid') {
 				return (await existingAwaited).container
 			}
-			await this.destroyContainer(projectGroup, slug)
+			await this.destroyContainer(slug)
 			if (state === 'not_found') {
 				return undefined
 			}
 		}
-		const project = await this.projectManager.getProjectWithSecretsBySlug(projectGroup.database, slug, alias)
+		const project = await this.projectManager.getProjectWithSecretsBySlug(this.tenantDatabase, slug, alias)
 		if (!project) {
 			return undefined
 		}
-		const container = await this.createProjectContainer(projectGroup, project)
+		const container = await this.createProjectContainer(project)
 		if (slug !== project.slug) {
-			groupState.setAlias(project.slug, slug)
+			this.projectContainers.setAlias(project.slug, slug)
 		}
 		return container
 	}
 
-	public async createProjectContainer(projectGroup: ProjectGroup, project: ProjectWithSecrets): Promise<ProjectContainer> {
-		const projectConfig = this.projectConfigResolver(project.slug, project.config, project.secrets)
-		const groupState = this.getProjectGroupState(projectGroup)
-		return (await groupState.fetchContainer(project.slug, async slug => {
-			const projectContainer = this.projectContainerFactory.createContainer(projectConfig)
+	public async createProjectContainer(project: ProjectWithSecrets): Promise<ProjectContainer> {
+		const projectConfig = this.projectConfigResolver(project.slug, project.config, project.secrets, this.tenantConfig)
+		return (await this.projectContainers.fetchContainer(project.slug, async slug => {
+			const projectContainer = this.projectContainerFactory.createContainer({
+				project: projectConfig,
+			})
 			await this.systemProjectInitializer.initialize(
 				projectContainer.systemDatabaseContextFactory,
 				projectContainer.project,
@@ -81,14 +83,13 @@ export class ProjectContainerResolver {
 		})).container
 	}
 
-	public async destroyContainer(projectGroup: ProjectGroup, slug: string): Promise<void> {
-		const groupState = this.getProjectGroupState(projectGroup)
-		const existing = groupState.getContainer(slug)
+	public async destroyContainer(slug: string): Promise<void> {
+		const existing = this.projectContainers.getContainer(slug)
 		if (existing) {
 			const existingAwaited = await existing
 			existingAwaited.cleanups.forEach(it => it())
-			existingAwaited.container.project.alias?.forEach(it => groupState.removeAlias(it))
-			groupState.removeContainer(slug)
+			existingAwaited.container.project.alias?.forEach(it => this.projectContainers.removeAlias(it))
+			this.projectContainers.removeContainer(slug)
 		}
 		process.nextTick(() => {
 			if (global.gc) {
@@ -96,13 +97,4 @@ export class ProjectContainerResolver {
 			}
 		})
 	}
-
-	private getProjectGroupState(projectGroup: ProjectGroup): ProjectGroupState {
-		let groupState = this.projectGroupStates.get(projectGroup)
-		if (!groupState) {
-			groupState = new ProjectGroupState()
-			this.projectGroupStates.set(projectGroup, new ProjectGroupState())
-		}
-		return groupState
-	}
 }

package/src/project/{ProjectGroupState.ts → ProjectContainerStore.ts}

@@ -3,7 +3,7 @@ import { PromiseMap } from '@contember/engine-common'
 
 type ContainerWithMeta = { container: ProjectContainer; cleanups: (() => void)[]; timestamp: Date }
 
-export class ProjectGroupState {
+export class ProjectContainerStore {
 	private containers = new PromiseMap<string, ContainerWithMeta>()
 	private aliasMapping = new Map<string, string>()
 

package/src/project/ProjectInitializer.ts

@@ -1,8 +1,4 @@
-import {
-	ProjectGroup,
-	ProjectInitializer as ProjectInitializerInterface,
-	ProjectWithSecrets,
-} from '@contember/engine-tenant-api'
+import { ProjectInitializer as ProjectInitializerInterface, ProjectWithSecrets } from '@contember/engine-tenant-api'
 import { ProjectContainerResolver } from './ProjectContainerResolver'
 
 export class ProjectInitializer implements ProjectInitializerInterface {
@@ -10,8 +6,8 @@ export class ProjectInitializer implements ProjectInitializerInterface {
 		private readonly projectContainerResolver: ProjectContainerResolver,
 	) {}
 
-	async initializeProject(projectGroup: ProjectGroup, project: ProjectWithSecrets) {
-		await this.projectContainerResolver.createProjectContainer(projectGroup, project)
+	async initializeProject(project: ProjectWithSecrets) {
+		await this.projectContainerResolver.createProjectContainer(project)
 	}
 }
 
@@ -22,10 +18,10 @@ export class ProjectInitializerProxy implements ProjectInitializerInterface {
 		this.initializer = initializer
 	}
 
-	initializeProject(projectGroup: ProjectGroup, project: ProjectWithSecrets) {
+	initializeProject(project: ProjectWithSecrets) {
 		if (!this.initializer) {
 			throw new Error('Initializer is not set')
 		}
-		return this.initializer.initializeProject(projectGroup, project)
+		return this.initializer.initializeProject(project)
 	}
 }

package/src/project/ProjectSchemaResolver.ts

@@ -1,8 +1,4 @@
-import {
-	DatabaseContext,
-	ProjectGroup,
-	ProjectSchemaResolver as ProjectSchemaResolverInterface,
-} from '@contember/engine-tenant-api'
+import { ProjectSchemaResolver as ProjectSchemaResolverInterface } from '@contember/engine-tenant-api'
 import { SchemaVersionBuilder } from '@contember/engine-system-api'
 import { ProjectContainerResolver } from '@contember/engine-http'
 import { Schema } from '@contember/schema'
@@ -13,12 +9,12 @@ export class ProjectSchemaResolver implements ProjectSchemaResolverInterface {
 		private readonly schemaVersionBuilder: SchemaVersionBuilder,
 	) {}
 
-	async getSchema(projectGroup: ProjectGroup, slug: string) {
-		const container = await this.projectContainerResolver.getProjectContainer(projectGroup, slug)
+	async getSchema(slug: string) {
+		const container = await this.projectContainerResolver.getProjectContainer(slug)
 		if (!container) {
 			return undefined
 		}
-		const db = container.systemDatabaseContextFactory.create(undefined)
+		const db = container.systemDatabaseContextFactory.create()
 		return await this.schemaVersionBuilder.buildSchema(db)
 	}
 }
@@ -30,10 +26,10 @@ export class ProjectSchemaResolverProxy implements ProjectSchemaResolverInterfac
 		this.resolver = resolver
 	}
 
-	getSchema(projectGroup: ProjectGroup, projectSlug: string): Promise<Schema | undefined> {
+	getSchema(projectSlug: string): Promise<Schema | undefined> {
 		if (!this.resolver) {
 			throw new Error('Resolved is not set')
 		}
-		return this.resolver.getSchema(projectGroup, projectSlug)
+		return this.resolver.getSchema(projectSlug)
 	}
 }

package/src/projectGroup/ProjectGroupContainer.ts

@@ -0,0 +1,120 @@
+import { Builder } from '@contember/dic'
+import { Connection } from '@contember/database'
+import { TenantContainerFactory } from '@contember/engine-tenant-api'
+import { TenantConfig } from '../config/config'
+import {
+	Authenticator,
+	CryptoWrapper,
+	ProjectGroupContainer,
+	Providers,
+	SystemGraphQLHandlerFactory,
+	TenantGraphQLHandlerFactory,
+} from '@contember/engine-http'
+import {
+	ProjectContainerFactoryFactory,
+	ProjectContainerResolver,
+	ProjectInitializer,
+	ProjectInitializerProxy,
+	ProjectSchemaResolver,
+	ProjectSchemaResolverProxy,
+} from '../project'
+import { SystemContainerFactory } from '@contember/engine-system-api'
+import { ProjectConfigResolver } from '../config/projectConfigResolver'
+import { createSecretKey } from 'crypto'
+
+interface ProjectGroupContainerFactoryArgs
+{
+	config: TenantConfig
+	slug: string | undefined
+}
+
+export class ProjectGroupContainerFactory {
+	constructor(
+		private readonly providers: Providers,
+		private readonly systemContainerFactory: SystemContainerFactory,
+		private readonly tenantContainerFactory: TenantContainerFactory,
+		private readonly projectContainerFactoryFactory: ProjectContainerFactoryFactory,
+		private readonly projectConfigResolver: ProjectConfigResolver,
+		private readonly tenantGraphQLHandlerFactory: TenantGraphQLHandlerFactory,
+		private readonly systemGraphQLHandlerFactory: SystemGraphQLHandlerFactory,
+	) {}
+
+	public create({ config, slug }: ProjectGroupContainerFactoryArgs): ProjectGroupContainer {
+		return new Builder({})
+			.addService('slug', () =>
+				slug)
+			.addService('providers', () =>
+				this.providers)
+			.addService('tenantConnection', (): Connection.ConnectionType =>
+				new Connection(config.db, {}))
+			.addService('projectSchemaResolver', () =>
+				new ProjectSchemaResolverProxy())
+			.addService('projectInitializer', () =>
+				new ProjectInitializerProxy())
+			.addService('tenantContainer', ({ tenantConnection, projectSchemaResolver, projectInitializer }) => {
+				const encryptionKey = config.secrets.encryptionKey
+					? createSecretKey(Buffer.from(config.secrets.encryptionKey, 'hex'))
+					: undefined
+
+				const cryptoWrapper = new CryptoWrapper(encryptionKey)
+				return this.tenantContainerFactory.create({
+					connection: tenantConnection,
+					mailOptions: config.mailer,
+					tenantCredentials: config.credentials,
+					projectInitializer,
+					projectSchemaResolver,
+					cryptoProviders: {
+						decrypt: cryptoWrapper.decrypt.bind(cryptoWrapper),
+						encrypt: cryptoWrapper.encrypt.bind(cryptoWrapper),
+					},
+				})
+			})
+			.addService('tenantDatabase', ({ tenantContainer }) =>
+				tenantContainer.databaseContext)
+			.addService('identityFetcher', ({ tenantContainer: { identityFetcher } }) =>
+				identityFetcher)
+			.addService('systemContainer', ({ identityFetcher }) =>
+				this.systemContainerFactory.create({ identityFetcher }))
+			.addService('schemaVersionBuilder', ({ systemContainer }) =>
+				systemContainer.schemaVersionBuilder)
+			.addService('projectContainerFactory', ({  schemaVersionBuilder }) =>
+				this.projectContainerFactoryFactory.create(schemaVersionBuilder))
+			.addService('tenantProjectManager', ({ tenantContainer }) =>
+				tenantContainer.projectManager)
+			.addService('projectContainerResolver', ({ projectContainerFactory, tenantProjectManager, systemContainer, tenantContainer }) =>
+				new ProjectContainerResolver(
+					projectContainerFactory,
+					this.projectConfigResolver,
+					tenantProjectManager,
+					systemContainer.projectInitializer,
+					tenantContainer.databaseContext,
+					config,
+				))
+
+			.setupService('projectSchemaResolver', (it, { projectContainerResolver, schemaVersionBuilder }) => {
+				it.setResolver(new ProjectSchemaResolver(projectContainerResolver, schemaVersionBuilder))
+			})
+			.setupService('projectInitializer', (it, { projectContainerResolver }) => {
+				it.setInitializer(new ProjectInitializer(projectContainerResolver))
+			})
+			.addService('tenantGraphQLHandler', ({ tenantContainer }) =>
+				this.tenantGraphQLHandlerFactory.create(tenantContainer.resolvers))
+			.addService('systemGraphQLHandler', ({ systemContainer }) =>
+				this.systemGraphQLHandlerFactory.create(systemContainer.systemResolversFactory))
+			.addService('authenticator', ({ tenantDatabase, tenantContainer }) =>
+				new Authenticator(tenantDatabase, tenantContainer.apiKeyManager))
+			.build()
+			.pick(
+				'projectContainerResolver',
+				'projectSchemaResolver',
+				'projectInitializer',
+				'systemContainer',
+				'systemGraphQLHandler',
+				'tenantContainer',
+				'tenantDatabase',
+				'authenticator',
+				'tenantGraphQLHandler',
+				'slug',
+			)
+	}
+}

package/src/projectGroup/ProjectGroupContainerResolver.ts

@@ -0,0 +1,47 @@
+import { TenantConfigResolver } from '../config/tenantConfigResolver'
+import {
+	ProjectGroupContainer,
+	ProjectGroupContainerResolver as ProjectGroupContainerResolverInterface,
+} from '@contember/engine-http'
+import { ProjectGroupContainerFactory } from './ProjectGroupContainer'
+import { PromiseMap } from '@contember/engine-common'
+import { isDeepStrictEqual } from 'util'
+
+interface ContainerWithMeta {
+	container: ProjectGroupContainer
+	cleanups: (() => void)[]
+	inputConfig: any
+}
+
+export class ProjectGroupContainerResolver implements ProjectGroupContainerResolverInterface {
+	private containers = new PromiseMap<string | undefined, ContainerWithMeta>()
+
+	public readonly onCreate: ((container: ProjectGroupContainer, slug: string | undefined) => void | (() => void))[] = []
+
+	constructor(
+		private readonly configResolver: TenantConfigResolver,
+		private readonly containerFactory: ProjectGroupContainerFactory,
+	) {}
+
+	public async getProjectGroupContainer(slug: string | undefined, config: any = {}): Promise<ProjectGroupContainer> {
+		const existing = this.containers.get(slug)
+		if (existing) {
+			const existingAwaited = await existing
+			if (isDeepStrictEqual(config, existingAwaited.inputConfig)) {
+				return existingAwaited.container
+			}
+			existingAwaited.cleanups.forEach(it => it())
+			this.containers.delete(slug)
+		}
+		return (await this.containers.fetch(slug, async slug => {
+			const container = this.containerFactory.create({
+				config: this.configResolver(slug, config),
+				slug,
+			})
+			const cleanups = this.onCreate.map(it => it(container, slug) || (() => null))
+			// eslint-disable-next-line no-console
+			await container.tenantContainer.migrationsRunner.run(console.log)
+			return { container, inputConfig: config, cleanups }
+		})).container
+	}
+}

package/src/start.ts

@@ -68,13 +68,13 @@ const createServerTerminator = (): Server[] => {
 		}
 	}
 
-	const { config, projectConfigResolver } = await readConfig(configSources, configProcessors)
+	const { serverConfig, projectConfigResolver, tenantConfigResolver } = await readConfig(configSources, configProcessors)
 
 	if (process.argv[2] === 'validate') {
 		process.exit(0)
 	}
-	'sentry' in config.server.logging && initSentry(config.server.logging.sentry?.dsn)
-	const workerConfig = config.server.workerCount || 1
+	'sentry' in serverConfig.logging && initSentry(serverConfig.logging.sentry?.dsn)
+	const workerConfig = serverConfig.workerCount || 1
 
 	const workerCount = workerConfig === 'auto' ? os.cpus().length : Number(workerConfig)
 	const isClusterMode = workerCount > 1
@@ -83,8 +83,9 @@ const createServerTerminator = (): Server[] => {
 
 	const container = createContainer({
 		debugMode: isDebug,
-		config,
+		serverConfig,
 		projectConfigResolver,
+		tenantConfigResolver,
 		plugins,
 		processType,
 		version,
@@ -92,7 +93,7 @@ const createServerTerminator = (): Server[] => {
 
 	let initializedProjects: string[] = []
 	if (cluster.isMaster) {
-		const monitoringPort = config.server.monitoringPort
+		const monitoringPort = serverConfig.monitoringPort
 		const terminator = createServerTerminator()
 		terminator.push(
 			container.monitoringKoa.listen(monitoringPort, () => {
@@ -100,14 +101,14 @@ const createServerTerminator = (): Server[] => {
 				console.log(`Monitoring running on http://localhost:${monitoringPort}`)
 			}),
 		)
-		if (!config.server.projectGroup) {
+		if (!serverConfig.projectGroup) {
 			initializedProjects = await container.initializer.initialize()
 		}
 	}
 
-	const port = config.server.port
+	const port = serverConfig.port
 	const printStarted = () => {
-		if (config.server.projectGroup) {
+		if (serverConfig.projectGroup) {
 			// eslint-disable-next-line no-console
 			console.log('Contember Cloud running')
 		} else {

package/src/utils/dbMetrics.ts

@@ -1,10 +1,12 @@
 import prom from 'prom-client'
 import { Connection, EventManager } from '@contember/database'
 
+const labelNames = ['contember_project' as const, 'contember_module' as const, 'contember_project_group' as const]
+type LabelNames = typeof labelNames[number]
+type Labels = { [K in LabelNames]: string }
 type DatabaseMetricsEntry = {
 	connection: Connection.PoolStatusProvider & Connection.Queryable
-	module: string
-	project: string
+	labels: Labels
 }
 type Unregistrar = () => void
 type DatabaseMetricsRegistrar = (entry: DatabaseMetricsEntry) => Unregistrar
@@ -14,17 +16,14 @@ export const createDbMetricsRegistrar = (registry: prom.Registry): DatabaseMetri
 	const entries = new Set<DatabaseMetricsEntry>()
 	const collector = () => {
 		for (const entry of entries) {
-			dbPoolCollectorInner(entry.connection, { contember_module: entry.module, contember_project: entry.project })
+			dbPoolCollectorInner(entry.connection, entry.labels)
 		}
 	}
 	registry.registerCollector(collector)
 	const sqlMetricsRegistrar = createSqlMetricsRegistrar(registry)
 	return entry => {
 		entries.add(entry)
-		const sqlMetricsUnregistrar = sqlMetricsRegistrar(entry.connection, {
-			contember_module: entry.module,
-			contember_project: entry.project,
-		})
+		const sqlMetricsUnregistrar = sqlMetricsRegistrar(entry.connection, entry.labels)
 		return () => {
 			entries.delete(entry)
 			sqlMetricsUnregistrar()
@@ -33,33 +32,33 @@ export const createDbMetricsRegistrar = (registry: prom.Registry): DatabaseMetri
 }
 
 const createSingleDbPoolMetricsCollector = (registry: prom.Registry) => {
-	const labelNames = ['contember_project', 'contember_module']
+
 	const totalCount = new prom.Gauge({
 		registers: [registry],
 		name: `contember_db_pool_total_count`,
 		help: 'The total number of clients existing within the pool by contember_module (tenant or content; system is not used since it uses the same connection) and contember_project for contember_module=content.',
-		labelNames: labelNames,
+		labelNames,
 	})
 	const idleCount = new prom.Gauge({
 		registers: [registry],
 		name: `contember_db_pool_idle_count`,
 		help: 'The number of clients which are not checked out but are currently idle in the pool by contember_module (tenant or content; system is not used since it uses the same connection) and contember_project for contember_module=content.',
-		labelNames: labelNames,
+		labelNames,
 	})
 	const waitingCount = new prom.Gauge({
 		registers: [registry],
 		name: `contember_db_pool_waiting_count`,
 		help: 'The number of queued requests waiting on a client when all clients are checked out. It can be helpful to monitor this number to see if you need to adjust the size of the pool by contember_module (tenant or content; system is not used since it uses the same connection) and contember_project for contember_module=content.',
-		labelNames: labelNames,
+		labelNames,
 	})
 	const maxCount = new prom.Gauge({
 		registers: [registry],
 		name: `contember_db_pool_max_count`,
 		help: 'Maximum number of clients the pool should contain by contember_module (tenant or content; system is not used since it uses the same connection) and contember_project for contember_module=content.',
-		labelNames: labelNames,
+		labelNames,
 	})
 
-	return (db: Connection.PoolStatusProvider, labels: { contember_module: string; contember_project: string }) => {
+	return (db: Connection.PoolStatusProvider, labels: Labels) => {
 		const poolInfo = db.getPoolStatus()
 		totalCount.set(labels, poolInfo.totalCount)
 		idleCount.set(labels, poolInfo.idleCount)
@@ -69,20 +68,20 @@ const createSingleDbPoolMetricsCollector = (registry: prom.Registry) => {
 }
 type SqlMetricsRegistrar = (
 	connection: Connection.Queryable,
-	labels: { contember_module?: string; contember_project?: string },
+	labels: Labels,
 ) => Unregistrar
 const createSqlMetricsRegistrar = (registry: prom.Registry): SqlMetricsRegistrar => {
 	const sqlDuration = new prom.Histogram({
 		name: 'contember_sql_duration_ms',
 		help: 'Executed SQL queries by contember_module (system, tenant, content or unknown) and contember_project (or "unknown" for unknown project)',
 		registers: [registry],
-		labelNames: ['contember_project', 'contember_module'],
+		labelNames,
 		buckets: [1, 2, 5, 10, 25, 50, 100, 250, 500, 1000],
 	})
 	const sqlErrorRate = new prom.Counter({
 		name: 'contember_sql_error_count',
 		help: 'Failed SQL queries by contember_module (system, tenant, content or unknown) and contember_project (or "unknown" for unknown project)',
-		labelNames: ['contember_project', 'contember_module'],
+		labelNames,
 		registers: [registry],
 	})
 
@@ -90,16 +89,16 @@ const createSqlMetricsRegistrar = (registry: prom.Registry): SqlMetricsRegistrar
 		const queryEndCallback: EventManager.ListenerTypes[EventManager.Event.queryEnd] = ({ meta }, { timing }) => {
 			sqlDuration.observe(
 				{
-					contember_module: labels.contember_module || meta.module || 'unknown',
-					contember_project: labels.contember_project || 'unknown',
+					...labels,
+					contember_module: meta.module || labels.contember_module,
 				},
 				timing ? timing.selfDuration / 1000 : 0,
 			)
 		}
 		const queryErrorCallback: EventManager.ListenerTypes[EventManager.Event.queryError] = ({ meta }) => {
 			sqlErrorRate.inc({
-				contember_module: labels.contember_module || meta.module || 'unknown',
-				contember_project: labels.contember_project || 'unknown',
+				...labels,
+				contember_module: meta.module || labels.contember_module,
 			})
 		}
 		connection.eventManager.on(EventManager.Event.queryEnd, queryEndCallback)