@contember/engine-server 1.2.0-alpha.8 → 1.2.0-beta.1

package/package.json

@@ -1,31 +1,29 @@
 {
   "name": "@contember/engine-server",
-  "version": "v1.2.0-alpha.8",
+  "version": "1.2.0-beta.1",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
   "scripts": {
+    "test": "vitest tests/cases",
     "test-e2e": "vitest --no-threads tests/e2e"
   },
   "dependencies": {
-    "@contember/authorization": "^v1.2.0-alpha.8",
-    "@contember/config-loader": "^v1.2.0-alpha.8",
-    "@contember/database": "^v1.2.0-alpha.8",
-    "@contember/database-migrations": "^v1.2.0-alpha.8",
-    "@contember/dic": "^v1.2.0-alpha.8",
-    "@contember/typesafe": "^v1.2.0-alpha.8",
-    "@contember/engine-content-api": "^v1.2.0-alpha.8",
-    "@contember/engine-http": "^v1.2.0-alpha.8",
-    "@contember/engine-plugins": "^v1.2.0-alpha.8",
-    "@contember/engine-s3-plugin": "^v1.2.0-alpha.8",
-    "@contember/engine-system-api": "^v1.2.0-alpha.8",
-    "@contember/engine-tenant-api": "^v1.2.0-alpha.8",
-    "@contember/engine-vimeo-plugin": "^v1.2.0-alpha.8",
-    "@contember/queryable": "^v1.2.0-alpha.8",
-    "@contember/schema": "^v1.2.0-alpha.8",
-    "@contember/schema-definition": "^v1.2.0-alpha.8",
-    "@contember/schema-migrations": "^v1.2.0-alpha.8",
-    "@contember/schema-utils": "^v1.2.0-alpha.8",
+    "@contember/config-loader": "^1.2.0-beta.1",
+    "@contember/database": "^1.2.0-beta.1",
+    "@contember/dic": "^1.2.0-beta.1",
+    "@contember/typesafe": "^1.2.0-beta.1",
+    "@contember/engine-content-api": "^1.2.0-beta.1",
+    "@contember/engine-common": "^1.2.0-beta.1",
+    "@contember/engine-http": "^1.2.0-beta.1",
+    "@contember/engine-plugins": "^1.2.0-beta.1",
+    "@contember/engine-s3-plugin": "^1.2.0-beta.1",
+    "@contember/engine-system-api": "^1.2.0-beta.1",
+    "@contember/engine-tenant-api": "^1.2.0-beta.1",
+    "@contember/engine-vimeo-plugin": "^1.2.0-beta.1",
+    "@contember/logger": "^1.2.0-beta.1",
+    "@contember/schema": "^1.2.0-beta.1",
+    "@contember/schema-migrations": "^1.2.0-beta.1",
     "@koa/cors": "^3.1.0",
     "@sentry/node": "^7.1.1",
     "graphql": "^16.5.0",
@@ -33,13 +31,12 @@
     "koa-bodyparser": "^4.3.0",
     "koa-compress": "^5.0.1",
     "pg": "^8.5.0",
-    "prom-client": "^12",
     "uuid": "^8.3.1"
   },
   "devDependencies": {
-    "@contember/engine-api-tester": "^v1.2.0-alpha.8",
+    "@contember/engine-api-tester": "^1.2.0-beta.1",
     "@types/koa-compress": "^4.0.1",
-    "@types/node": "^16",
+    "@types/node": "^18",
     "@types/supertest": "^2.0.8",
     "supertest": "^6.0.1"
   }

package/src/MasterContainer.ts

@@ -2,7 +2,6 @@ import { SystemContainerFactory } from '@contember/engine-system-api'
 import { TenantContainerFactory } from '@contember/engine-tenant-api'
 import { Builder } from '@contember/dic'
 import { ServerConfig } from './config/config'
-import { logSentryError } from './utils'
 import { ModificationHandlerFactory } from '@contember/schema-migrations'
 import { Initializer } from './bootstrap'
 import { Plugin } from '@contember/engine-plugins'
@@ -13,6 +12,7 @@ import {
 	ContentQueryHandlerFactory,
 	ContentSchemaTransferMappingFactory,
 	createHomepageMiddleware,
+	createLoggerMiddleware,
 	createModuleInfoMiddleware,
 	createPlaygroundMiddleware,
 	createPoweredByHeaderMiddleware,
@@ -25,6 +25,7 @@ import {
 	ImportExecutor,
 	Koa,
 	NotModifiedChecker,
+	ProjectGroupResolver as ProjectGroupResolverInterface,
 	Providers,
 	route,
 	SystemApiMiddlewareFactory,
@@ -43,8 +44,7 @@ import { TenantConfigResolver } from './config/tenantConfigResolver'
 import { ProjectGroupContainerFactory } from './projectGroup/ProjectGroupContainer'
 import corsMiddleware from '@koa/cors'
 import { ProjectGroupResolver } from './projectGroup/ProjectGroupResolver'
-import { ProjectGroupResolver as ProjectGroupResolverInterface } from '@contember/engine-http'
-import { Logger } from '@contember/engine-common'
+import { Logger } from '@contember/logger'
 
 export interface MasterContainer {
 	initializer: Initializer
@@ -58,6 +58,7 @@ export interface MasterContainerArgs {
 	projectConfigResolver: ProjectConfigResolver
 	tenantConfigResolver: TenantConfigResolver
 	plugins: Plugin[]
+	logger: Logger
 	version?: string
 }
 
@@ -69,6 +70,7 @@ export class MasterContainerFactory {
 		projectConfigResolver,
 		tenantConfigResolver,
 		version,
+		logger,
 	}: MasterContainerArgs) {
 		return new Builder({})
 			.addService('serverConfig', () =>
@@ -94,11 +96,13 @@ export class MasterContainerFactory {
 			.addService('projectContainerFactoryFactory', ({ debugMode, plugins, providers }) =>
 				new ProjectContainerFactoryFactory(debugMode, plugins, providers))
 			.addService('tenantGraphQLHandlerFactory', () =>
-				new TenantGraphQLHandlerFactory(logSentryError))
+				new TenantGraphQLHandlerFactory())
 			.addService('systemGraphQLHandlerFactory', ({ debugMode }) =>
-				new SystemGraphQLHandlerFactory(logSentryError, debugMode))
-			.addService('projectGroupContainerFactory', ({ debugMode, providers, systemContainerFactory, tenantContainerFactory, projectContainerFactoryFactory, projectConfigResolver, tenantGraphQLHandlerFactory, systemGraphQLHandlerFactory }) =>
-				new ProjectGroupContainerFactory(debugMode, providers, systemContainerFactory, tenantContainerFactory, projectContainerFactoryFactory, projectConfigResolver, tenantGraphQLHandlerFactory, systemGraphQLHandlerFactory))
+				new SystemGraphQLHandlerFactory(debugMode))
+			.addService('logger', () =>
+				logger)
+			.addService('projectGroupContainerFactory', ({ debugMode, providers, systemContainerFactory, tenantContainerFactory, projectContainerFactoryFactory, projectConfigResolver, tenantGraphQLHandlerFactory, systemGraphQLHandlerFactory, logger }) =>
+				new ProjectGroupContainerFactory(debugMode, providers, systemContainerFactory, tenantContainerFactory, projectContainerFactoryFactory, projectConfigResolver, tenantGraphQLHandlerFactory, systemGraphQLHandlerFactory, logger))
 			.addService('projectGroupContainer', ({ tenantConfigResolver, projectGroupContainerFactory }) =>
 				projectGroupContainerFactory.create({ slug: undefined, config: tenantConfigResolver(undefined, {}) }))
 			.addService('httpErrorMiddlewareFactory', ({ debugMode }) =>
@@ -110,7 +114,7 @@ export class MasterContainerFactory {
 			.addService('contentGraphqlContextFactory', ({ providers }) =>
 				new ContentGraphQLContextFactory(providers))
 			.addService('contentQueryHandlerFactory', ({ debugMode }) =>
-				new ContentQueryHandlerFactory(debugMode, logSentryError))
+				new ContentQueryHandlerFactory(debugMode))
 			.addService('contentApiMiddlewareFactory', ({ projectGroupResolver, notModifiedChecker, contentGraphqlContextFactory, contentQueryHandlerFactory }) =>
 				new ContentApiMiddlewareFactory(projectGroupResolver, notModifiedChecker, contentGraphqlContextFactory, contentQueryHandlerFactory))
 			.addService('tenantGraphQLContextFactory', () =>
@@ -121,22 +125,19 @@ export class MasterContainerFactory {
 				new SystemGraphQLContextFactory())
 			.addService('systemApiMiddlewareFactory', ({ debugMode, projectGroupResolver, systemGraphQLContextFactory }) =>
 				new SystemApiMiddlewareFactory(debugMode, projectGroupResolver, systemGraphQLContextFactory))
-			.addService('logger', () =>
-				// eslint-disable-next-line no-console
-				new Logger(console.log))
 			.addService('contentSchemaTransferMappingFactory', () =>
 				new ContentSchemaTransferMappingFactory())
 			.addService('systemSchemaTransferMappingFactory', () =>
 				new SystemSchemaTransferMappingFactory())
-			.addService('importExecutor', ({ contentSchemaTransferMappingFactory, systemSchemaTransferMappingFactory, logger }) =>
-				new ImportExecutor(contentSchemaTransferMappingFactory, systemSchemaTransferMappingFactory, logger))
+			.addService('importExecutor', ({ contentSchemaTransferMappingFactory, systemSchemaTransferMappingFactory }) =>
+				new ImportExecutor(contentSchemaTransferMappingFactory, systemSchemaTransferMappingFactory))
 			.addService('exportExecutor', ({ contentSchemaTransferMappingFactory, systemSchemaTransferMappingFactory }) =>
 				new ExportExecutor(contentSchemaTransferMappingFactory, systemSchemaTransferMappingFactory))
 			.addService('importApiMiddlewareFactory', ({ projectGroupResolver, importExecutor }) =>
 				new ImportApiMiddlewareFactory(projectGroupResolver, importExecutor))
 			.addService('exportApiMiddlewareFactory', ({ projectGroupResolver, exportExecutor }) =>
 				new ExportApiMiddlewareFactory(projectGroupResolver, exportExecutor))
-			.addService('koaMiddlewares', ({ contentApiMiddlewareFactory, tenantApiMiddlewareFactory, systemApiMiddlewareFactory, importApiMiddlewareFactory, exportApiMiddlewareFactory, httpErrorMiddlewareFactory, debugMode, version, serverConfig }) =>
+			.addService('koaMiddlewares', ({ contentApiMiddlewareFactory, tenantApiMiddlewareFactory, systemApiMiddlewareFactory, importApiMiddlewareFactory, exportApiMiddlewareFactory, httpErrorMiddlewareFactory, debugMode, version, serverConfig, logger }) =>
 				compose([
 					koaCompress({
 						br: false,
@@ -145,8 +146,9 @@ export class MasterContainerFactory {
 						jsonLimit: serverConfig.http.requestBodySize || '1mb',
 					}),
 					createPoweredByHeaderMiddleware(debugMode, version ?? 'unknown'),
+					createLoggerMiddleware(logger),
+					createTimerMiddleware({ debugMode }),
 					httpErrorMiddlewareFactory.create(),
-					createTimerMiddleware(),
 					route('/playground$', createPlaygroundMiddleware()),
 					createHomepageMiddleware(),
 					corsMiddleware(),

package/src/bootstrap/Initializer.ts

@@ -1,4 +1,3 @@
-import { Logger } from '@contember/engine-common'
 import { ProjectGroupContainer } from '@contember/engine-http'
 
 export class Initializer {
@@ -7,34 +6,22 @@ export class Initializer {
 	) {}
 
 	public async initialize(): Promise<string[]> {
-		// eslint-disable-next-line no-console
-		const logger = new Logger(console.log)
-		logger.group('\nInitializing tenant database')
-		// todo
 		const groupContainer = await this.projectGroupContainer
-
+		const tenantMigrationsLogger = groupContainer.logger.child()
 		const tenantContainer = groupContainer.tenantContainer
-		await tenantContainer.migrationsRunner.run(logger.write.bind(logger))
-		logger.groupEnd()
+		await tenantContainer.migrationsRunner.run(tenantMigrationsLogger)
 
 		const projects: string[] = []
 
 		const tenantProjects = await tenantContainer.projectManager.getProjects(tenantContainer.databaseContext)
 		for (const { slug: projectSlug } of tenantProjects) {
-			logger.group(`\nUpdating project ${projectSlug}`)
-			const projectContainer = await groupContainer.projectContainerResolver.getProjectContainer(projectSlug, {
-				alias: false,
-				logger,
-			})
+			const projectContainer = await groupContainer.projectContainerResolver.getProjectContainer(projectSlug, { alias: false })
 			if (!projectContainer) {
 				throw new Error()
 			}
 			const project = projectContainer.project
 			projects.push(project.slug)
-			logger.groupEnd()
 		}
-		// eslint-disable-next-line no-console
-		console.log('')
 		return projects
 	}
 }

package/src/config/configSchema.ts

@@ -3,29 +3,52 @@ import { MailerOptions } from '@contember/engine-tenant-api'
 import { upperCaseFirst } from '../utils'
 
 
-export const dbConfigSchema = Typesafe.intersection(
-	Typesafe.object({
-		host: Typesafe.string,
-		port: Typesafe.number,
-		user: Typesafe.string,
-		password: Typesafe.string,
-		database: Typesafe.string,
+const dbConfigRequired = {
+	host: Typesafe.string,
+	port: Typesafe.number,
+	user: Typesafe.string,
+	password: Typesafe.string,
+	database: Typesafe.string,
+}
+const dbConfigOptional = {
+	ssl: Typesafe.boolean,
+	queryTimeoutMs: Typesafe.number,
+	statementTimeoutMs: Typesafe.number,
+	connectionTimeoutMs: Typesafe.number,
+	pool: Typesafe.partial({
+		maxConnections: Typesafe.number,
+		maxConnecting: Typesafe.number,
+		maxIdle: Typesafe.number,
+		reconnectIntervalMs: Typesafe.number,
+		rateLimitCount: Typesafe.number,
+		rateLimitPeriodMs: Typesafe.number,
+		idleTimeoutMs: Typesafe.number,
+		acquireTimeoutMs: Typesafe.number,
+		maxUses: Typesafe.number,
+		maxAgeMs: Typesafe.number,
 	}),
+}
+
+const dbConfigSchemaInner = Typesafe.intersection(
+	Typesafe.object(dbConfigRequired),
+	Typesafe.partial(dbConfigOptional),
+)
+
+const readDbSchema = Typesafe.intersection(
+	Typesafe.partial(dbConfigRequired),
+	Typesafe.partial(dbConfigOptional),
+)
+
+export const dbConfigSchema = Typesafe.intersection(
+	dbConfigSchemaInner,
 	Typesafe.partial({
-		ssl: Typesafe.boolean,
-		queryTimeoutMs: Typesafe.number,
-		statementTimeoutMs: Typesafe.number,
-		connectionTimeoutMs: Typesafe.number,
-		pool: Typesafe.partial({
-			maxConnections: Typesafe.number,
-			maxConnecting: Typesafe.number,
-			maxIdle: Typesafe.number,
-			reconnectIntervalMs: Typesafe.number,
-			idleTimeoutMs: Typesafe.number,
-			acquireTimeoutMs: Typesafe.number,
-			maxUses: Typesafe.number,
-			maxAgeMs: Typesafe.number,
-		}),
+		read: (val: unknown) => {
+			const readDb = readDbSchema(val)
+			if ('host' in readDb) {
+				return readDb
+			}
+			return undefined
+		},
 	}),
 )
 

package/src/config/configTemplate.ts

@@ -1,3 +1,23 @@
+const createDbConfigTemplate = (prefix: string) => {
+	return {
+		ssl: `%?${prefix}_SSL::bool%`,
+		queryTimeoutMs: `%?${prefix}_QUERY_TIMEOUT_MS::number%`,
+		statementTimeoutMs: `%?${prefix}_STATEMENT_TIMEOUT_MS::number%`,
+		connectionTimeoutMs: `%?${prefix}_CONNECTION_TIMEOUT_MS::number%`,
+		pool: {
+			maxConnections: `%?${prefix}_POOL_MAX_CONNECTIONS::number%`,
+			maxConnecting: `%?${prefix}_POOL_MAX_CONNECTING::number%`,
+			maxIdle: `%?${prefix}_POOL_MAX_IDLE::number%`,
+			reconnectIntervalMs: `%?${prefix}_POOL_RECONNECT_INTERVAL_MS::number%`,
+			idleTimeoutMs: `%?${prefix}_POOL_IDLE_TIMEOUT_MS::number%`,
+			acquireTimeoutMs: `%?${prefix}_POOL_ACQUIRE_TIMEOUT_MS::number%`,
+			maxUses: `%?${prefix}_POOL_MAX_USES::number%`,
+			maxAgeMs: `%?${prefix}_POOL_MAX_AGE_MS::number%`,
+			rateLimitCount: `%?${prefix}_POOL_RATE_LIMIT_COUNT::number%`,
+			rateLimitPeriodMs: `%?${prefix}_POOL_RATE_LIMIT_PERIOD_MS::number%`,
+		},
+	}
+}
 export const configTemplate: any = {
 	tenant: {
 		db: {
@@ -6,20 +26,7 @@ export const configTemplate: any = {
 			user: `%tenant.env.DB_USER%`,
 			password: `%tenant.env.DB_PASSWORD%`,
 			database: `%tenant.env.DB_NAME%`,
-			ssl: `%?tenant.env.DB_SSL::bool%`,
-			queryTimeoutMs: '%?tenant.env.DB_QUERY_TIMEOUT_MS::number%',
-			statementTimeoutMs: '%?tenant.env.DB_STATEMENT_TIMEOUT_MS::number%',
-			connectionTimeoutMs: '%?tenant.env.DB_CONNECTION_TIMEOUT_MS::number%',
-			pool: {
-				maxConnections: '%?tenant.env.DB_POOL_MAX_CONNECTIONS::number%',
-				maxConnecting: '%?tenant.env.DB_POOL_MAX_CONNECTING::number%',
-				maxIdle: '%?tenant.env.DB_POOL_MAX_IDLE::number%',
-				reconnectIntervalMs: '%?tenant.env.DB_POOL_RECONNECT_INTERVAL_MS::number%',
-				idleTimeoutMs: '%?tenant.env.DB_POOL_IDLE_TIMEOUT_MS::number%',
-				acquireTimeoutMs: '%?tenant.env.DB_POOL_ACQUIRE_TIMEOUT_MS::number%',
-				maxUses: '%?tenant.env.DB_POOL_MAX_USES::number%',
-				maxAgeMs: '%?tenant.env.DB_POOL_MAX_AGE_MS::number%',
-			},
+			...createDbConfigTemplate('tenant.env.DB'),
 		},
 		mailer: {
 			from: '%?tenant.env.MAILER_FROM%',
@@ -47,16 +54,14 @@ export const configTemplate: any = {
 			user: `%?project.env.DB_USER%`,
 			password: `%?project.secret.db.password||project.env.DB_PASSWORD%`,
 			database: `%?project.env.DB_NAME||project.slug%`,
-			ssl: `%?project.env.DB_SSL::bool%`,
-			pool: {
-				maxConnections: '%?project.env.DB_POOL_MAX_CONNECTIONS%',
-				maxConnecting: '%?project.env.DB_POOL_MAX_CONNECTING%',
-				maxIdle: '%?project.env.DB_POOL_MAX_IDLE%',
-				reconnectIntervalMs: '%?project.env.DB_POOL_RECONNECT_INTERVAL_MS%',
-				idleTimeoutMs: '%?project.env.DB_POOL_IDLE_TIMEOUT_MS%',
-				acquireTimeoutMs: '%?project.env.DB_POOL_ACQUIRE_TIMEOUT_MS%',
-				maxUses: '%?project.env.DB_POOL_MAX_USES%',
-				maxAgeMs: '%?project.env.DB_POOL_MAX_AGE_MS%',
+			...createDbConfigTemplate('project.env.DB'),
+			read: {
+				host: `%?project.env.DB_READ_HOST%`,
+				port: `%?project.env.DB_READ_PORT::number%`,
+				user: `%?project.env.DB_READ_USER%`,
+				password: `%?project.secret.db.read.password||project.env.DB_READ_PASSWORD%`,
+				database: `%?project.env.DB_READ_NAME%`,
+				...createDbConfigTemplate('project.env.DB_READ'),
 			},
 		},
 	},

package/src/project/ProjectContainer.ts

@@ -10,6 +10,7 @@ import {
 	ProjectContainer,
 	Providers,
 } from '@contember/engine-http'
+import { Logger } from '@contember/logger'
 
 export class ProjectContainerFactoryFactory {
 	constructor(
@@ -19,8 +20,8 @@ export class ProjectContainerFactoryFactory {
 	) {
 	}
 
-	create(schemaVersionBuilder: SchemaVersionBuilder): ProjectContainerFactory {
-		return new ProjectContainerFactory(this.debug, this.plugins, schemaVersionBuilder, this.providers)
+	create(schemaVersionBuilder: SchemaVersionBuilder, logger: Logger): ProjectContainerFactory {
+		return new ProjectContainerFactory(this.debug, this.plugins, schemaVersionBuilder, this.providers, logger)
 	}
 }
 
@@ -34,6 +35,7 @@ export class ProjectContainerFactory {
 		private readonly plugins: Plugin[],
 		private readonly schemaVersionBuilder: SchemaVersionBuilder,
 		private readonly providers: Providers,
+		private readonly logger: Logger,
 	) {}
 
 	public createContainer(args: ProjectContainerFactoryArgs): ProjectContainer {
@@ -42,9 +44,11 @@ export class ProjectContainerFactory {
 			.pick(
 				'project',
 				'connection',
+				'readConnection',
 				'systemDatabaseContextFactory',
 				'contentSchemaResolver',
 				'graphQlSchemaFactory',
+				'logger',
 			)
 	}
 
@@ -54,10 +58,25 @@ export class ProjectContainerFactory {
 				this.providers)
 			.addService('schemaVersionBuilder', () =>
 				this.schemaVersionBuilder)
+			.addService('logger', () =>
+				this.logger.child({ project: project.slug }))
 			.addService('project', () =>
 				project)
-			.addService('connection', ({ project }) =>
-				Connection.create(project.db))
+			.addService('connection', ({ project, logger }) =>
+				Connection.create(project.db, err => logger.error(err)))
+			.addService('readConnection', ({ project, logger, connection }) => {
+				if (!project.db.read) {
+					return connection
+				}
+				return Connection.create({
+					...project.db,
+					...project.db.read,
+					pool: {
+						...project.db.pool,
+						...project.db.read.pool,
+					},
+				}, err => logger.error(err))
+			})
 			.addService('graphQlSchemaBuilderFactory', () =>
 				new GraphQlSchemaBuilderFactory())
 			.addService('permissionsByIdentityFactory', ({}) =>

package/src/project/ProjectContainerResolver.ts

@@ -3,9 +3,9 @@ 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 { ProjectContainerStore } from './ProjectContainerStore'
-import { Logger } from '@contember/engine-common'
 import { ProjectConfigResolver } from '../config/projectConfigResolver'
 import { TenantConfig } from '../config/config'
+import { Logger } from '@contember/logger'
 
 export class ProjectContainerResolver {
 	private projectContainers = new ProjectContainerStore()
@@ -22,7 +22,7 @@ export class ProjectContainerResolver {
 	) {}
 
 
-	public async getProjectContainer(slug: string, { alias = false, logger }: {alias?: boolean; logger?: Logger} = {}): Promise<ProjectContainer | undefined> {
+	public async getProjectContainer(slug: string, { alias = false }: { alias?: boolean } = {}): Promise<ProjectContainer | undefined> {
 		const realSlug = this.projectContainers.resolveAlias(slug)
 		if (realSlug) {
 			slug = realSlug
@@ -43,7 +43,7 @@ export class ProjectContainerResolver {
 		if (!project) {
 			return undefined
 		}
-		const container = await this.createProjectContainer(project, logger)
+		const container = await this.createProjectContainer(project)
 		if (slug !== project.slug) {
 			this.projectContainers.setAlias(project.slug, slug)
 		}
@@ -59,7 +59,7 @@ export class ProjectContainerResolver {
 			await this.systemProjectInitializer.initialize(
 				projectContainer.systemDatabaseContextFactory,
 				projectContainer.project,
-				logger ?? new Logger(() => null),
+				logger ?? projectContainer.logger,
 			)
 			const cleanups = this.onCreate.map(it => it(projectContainer) || (() => null))
 			return {

package/src/project/ProjectInitializer.ts

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

package/src/project/ProjectSchemaResolver.ts

@@ -1,14 +1,10 @@
 import { ProjectSchemaResolver as ProjectSchemaResolverInterface } from '@contember/engine-tenant-api'
-import { SchemaVersionBuilder, VersionedSchema } from '@contember/engine-system-api'
 import { ProjectContainerResolver } from '@contember/engine-http'
 import { Schema } from '@contember/schema'
 
 export class ProjectSchemaResolver implements ProjectSchemaResolverInterface {
-	private schemaCache = new Map<string, VersionedSchema>()
-
 	constructor(
 		private readonly projectContainerResolver: ProjectContainerResolver,
-		private readonly schemaVersionBuilder: SchemaVersionBuilder,
 	) {}
 
 	async getSchema(slug: string) {
@@ -17,16 +13,7 @@ export class ProjectSchemaResolver implements ProjectSchemaResolverInterface {
 			return undefined
 		}
 		const db = container.systemDatabaseContextFactory.create()
-		const cachedSchema = this.schemaCache.get(slug)
-		const newSchema = await this.schemaVersionBuilder.buildSchema(db, cachedSchema)
-		if (cachedSchema !== newSchema) {
-			this.schemaCache.set(slug, newSchema)
-		}
-		return newSchema
-	}
-
-	clearCache() {
-		this.schemaCache.clear()
+		return container.contentSchemaResolver.getSchema(db)
 	}
 }
 
@@ -43,8 +30,4 @@ export class ProjectSchemaResolverProxy implements ProjectSchemaResolverInterfac
 		}
 		return this.resolver.getSchema(projectSlug)
 	}
-
-	clearCache() {
-		this.resolver?.clearCache()
-	}
 }

package/src/projectGroup/ProjectGroupContainer.ts

@@ -22,7 +22,8 @@ import {
 } from '../project'
 import { SystemContainerFactory } from '@contember/engine-system-api'
 import { ProjectConfigResolver } from '../config/projectConfigResolver'
-import { createSecretKey } from 'crypto'
+import { createSecretKey } from 'node:crypto'
+import { Logger } from '@contember/logger'
 
 interface ProjectGroupContainerFactoryArgs
 {
@@ -40,18 +41,21 @@ export class ProjectGroupContainerFactory {
 		private readonly projectConfigResolver: ProjectConfigResolver,
 		private readonly tenantGraphQLHandlerFactory: TenantGraphQLHandlerFactory,
 		private readonly systemGraphQLHandlerFactory: SystemGraphQLHandlerFactory,
+		private readonly logger: Logger,
 	) {}
 
 	public create({ config, slug }: ProjectGroupContainerFactoryArgs): ProjectGroupContainer {
 		return new Builder({})
 			.addService('slug', () =>
 				slug)
+			.addService('logger', ({ slug }) =>
+				this.logger.child({ projectGroup: slug }))
 			.addService('providers', () =>
 				this.providers)
 			.addService('tenantDbCredentials', () =>
 				config.db)
-			.addService('tenantConnection', ({ tenantDbCredentials }): Connection.ConnectionType =>
-				Connection.create(tenantDbCredentials))
+			.addService('tenantConnection', ({ tenantDbCredentials, logger }): Connection.ConnectionType =>
+				Connection.create(tenantDbCredentials, err => logger.error(err)))
 			.addService('projectSchemaResolver', () =>
 				new ProjectSchemaResolverProxy())
 			.addService('projectInitializer', () =>
@@ -83,8 +87,8 @@ export class ProjectGroupContainerFactory {
 				this.systemContainerFactory.create({ identityFetcher }))
 			.addService('schemaVersionBuilder', ({ systemContainer }) =>
 				systemContainer.schemaVersionBuilder)
-			.addService('projectContainerFactory', ({  schemaVersionBuilder }) =>
-				this.projectContainerFactoryFactory.create(schemaVersionBuilder))
+			.addService('projectContainerFactory', ({  schemaVersionBuilder, logger }) =>
+				this.projectContainerFactoryFactory.create(schemaVersionBuilder, logger))
 			.addService('tenantProjectManager', ({ tenantContainer }) =>
 				tenantContainer.projectManager)
 			.addService('projectContainerResolver', ({ projectContainerFactory, tenantProjectManager, systemContainer, tenantContainer }) =>
@@ -97,8 +101,8 @@ export class ProjectGroupContainerFactory {
 					config,
 				))
 
-			.setupService('projectSchemaResolver', (it, { projectContainerResolver, schemaVersionBuilder }) => {
-				it.setResolver(new ProjectSchemaResolver(projectContainerResolver, schemaVersionBuilder))
+			.setupService('projectSchemaResolver', (it, { projectContainerResolver }) => {
+				it.setResolver(new ProjectSchemaResolver(projectContainerResolver))
 			})
 			.setupService('projectInitializer', (it, { projectContainerResolver }) => {
 				it.setInitializer(new ProjectInitializer(projectContainerResolver))
@@ -124,6 +128,7 @@ export class ProjectGroupContainerFactory {
 				'projectMembershipResolver',
 				'tenantGraphQLHandler',
 				'slug',
+				'logger',
 			)
 	}
 }